Interface Cluster

This cluster is used for managing the content control (including "parental control") settings on a

media device such as a TV, or Set-top Box.

This cluster allows to configure content control settings by clients with the Management privilege. It is responsibility of the end product to enforce appropriate right access (for example, to prevent a child from disabling this feature).

NOTE Support for Content Control cluster is provisional.

ContentControlCluster supports optional features that you can enable with the ContentControlCluster.with() factory method.

See

MatterSpecification.v13.Cluster § 6.13

interface Cluster {
    attributes: Merge<{
        enabled: Attribute<boolean, any>;
    }, GlobalAttributes<{
        blockApplications: BitFlag;
        blockChannels: BitFlag;
        blockContentTimeWindow: BitFlag;
        blockUnrated: BitFlag;
        onDemandContentRating: BitFlag;
        pinManagement: BitFlag;
        scheduledContentRating: BitFlag;
        screenTime: BitFlag;
    }>>;
    base: undefined;
    commands: {
        disable: Command<void, void, any>;
        enable: Command<void, void, any>;
    };
    events: {};
    extensions: readonly [{
        component: {
            attributes: {
                onDemandRatings: Attribute<TypeFromFields<{
                    ratingName: FieldType<string>;
                    ratingNameDesc: OptionalFieldType<string>;
                }>[], any>;
                onDemandRatingThreshold: Attribute<string, any>;
            };
            commands: {
                setOnDemandRatingThreshold: Command<TypeFromFields<{
                    rating: FieldType<string>;
                }>, void, any>;
            };
        };
        flags: {
            onDemandContentRating: true;
        };
    }, {
        component: {
            attributes: {
                scheduledContentRatings: Attribute<TypeFromFields<{
                    ratingName: FieldType<string>;
                    ratingNameDesc: OptionalFieldType<string>;
                }>[], any>;
                scheduledContentRatingThreshold: Attribute<string, any>;
            };
            commands: {
                setScheduledContentRatingThreshold: Command<TypeFromFields<{
                    rating: FieldType<string>;
                }>, void, any>;
            };
        };
        flags: {
            scheduledContentRating: true;
        };
    }, {
        component: {
            attributes: {
                remainingScreenTime: Attribute<number, any>;
                screenDailyTime: Attribute<number, any>;
            };
            commands: {
                addBonusTime: Command<TypeFromFields<{
                    bonusTime: FieldType<number>;
                    pinCode: OptionalFieldType<string>;
                }>, void, any>;
                setScreenDailyTime: Command<TypeFromFields<{
                    screenTime: FieldType<number>;
                }>, void, any>;
            };
            events: {
                remainingScreenTimeExpired: Event<void, any>;
            };
        };
        flags: {
            screenTime: true;
        };
    }, {
        component: {
            attributes: {
                blockUnrated: Attribute<boolean, any>;
            };
            commands: {
                blockUnratedContent: Command<void, void, any>;
                unblockUnratedContent: Command<void, void, any>;
            };
        };
        flags: {
            blockUnrated: true;
        };
    }, {
        component: {
            attributes: {
                blockChannelList: Attribute<TypeFromFields<{
                    blockChannelIndex: FieldType<null | number>;
                    identifier: OptionalFieldType<string>;
                    majorNumber: FieldType<number>;
                    minorNumber: FieldType<number>;
                }>[], any>;
            };
            commands: {
                addBlockChannels: Command<TypeFromFields<{
                    channels: FieldType<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[]>;
                }>, void, any>;
                removeBlockChannels: Command<TypeFromFields<{
                    channelIndexes: FieldType<number[]>;
                }>, void, any>;
            };
        };
        flags: {
            blockChannels: true;
        };
    }, {
        component: {
            attributes: {
                blockApplicationList: Attribute<TypeFromFields<{
                    applicationId: FieldType<string>;
                    catalogVendorId: FieldType<number>;
                }>[], any>;
            };
            commands: {
                addBlockApplications: Command<TypeFromFields<{
                    applications: FieldType<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[]>;
                }>, void, any>;
                removeBlockApplications: Command<TypeFromFields<{
                    applications: FieldType<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[]>;
                }>, void, any>;
            };
        };
        flags: {
            blockApplications: true;
        };
    }, {
        component: {
            attributes: {
                blockContentTimeWindow: Attribute<TypeFromFields<{
                    dayOfWeek: FieldType<ContentControl.DayOfWeek>;
                    timePeriod: FieldType<TypeFromFields<(...)>[]>;
                    timeWindowIndex: FieldType<null | number>;
                }>[], any>;
            };
            commands: {
                removeBlockContentTimeWindow: Command<TypeFromFields<{
                    timeWindowIndexes: FieldType<number[]>;
                }>, void, any>;
                setBlockContentTimeWindow: Command<TypeFromFields<{
                    timeWindow: FieldType<TypeFromFields<{
                        dayOfWeek: FieldType<(...)>;
                        timePeriod: FieldType<(...)>;
                        timeWindowIndex: FieldType<(...)>;
                    }>>;
                }>, void, any>;
            };
            events: {
                enteringBlockContentTimeWindow: Event<void, any>;
            };
        };
        flags: {
            blockContentTimeWindow: true;
        };
    }, {
        component: {
            commands: {
                resetPin: Command<void, TypeFromFields<{
                    pinCode: FieldType<string>;
                }>, any>;
                updatePin: Command<TypeFromFields<{
                    newPin: FieldType<string>;
                    oldPin: FieldType<string>;
                }>, void, any>;
            };
        };
        flags: {
            pinManagement: true;
        };
    }];
    features: {
        blockApplications: BitFlag;
        blockChannels: BitFlag;
        blockContentTimeWindow: BitFlag;
        blockUnrated: BitFlag;
        onDemandContentRating: BitFlag;
        pinManagement: BitFlag;
        scheduledContentRating: BitFlag;
        screenTime: BitFlag;
    };
    id: Branded<1295, "ClusterId">;
    name: "ContentControl";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    enabled: Attribute<boolean, any>;
}, GlobalAttributes<{
    blockApplications: BitFlag;
    blockChannels: BitFlag;
    blockContentTimeWindow: BitFlag;
    blockUnrated: BitFlag;
    onDemandContentRating: BitFlag;
    pinManagement: BitFlag;
    scheduledContentRating: BitFlag;
    screenTime: BitFlag;
}>>

Type declaration

  • Readonlyenabled: Attribute<boolean, any>

    Indicates whether the Content Control feature implemented on a media device is turned off (FALSE) or turned on (TRUE).

    See

    MatterSpecification.v13.Cluster § 6.13.7.1

base

base: undefined

commands

commands: {
    disable: Command<void, void, any>;
    enable: Command<void, void, any>;
}

Type declaration

  • Readonlydisable: Command<void, void, any>

    The purpose of this command is to turn off the Content Control feature on a media device.

    On receipt of the Disable command, the media device shall set the Enabled attribute to FALSE.

    See

    MatterSpecification.v13.Cluster § 6.13.8.5

  • Readonlyenable: Command<void, void, any>

    The purpose of this command is to turn on the Content Control feature on a media device.

    Upon receipt of the Enable command, the media device shall set the Enabled attribute to TRUE.

    See

    MatterSpecification.v13.Cluster § 6.13.8.4

events

events: {}

extensions

extensions: readonly [{
    component: {
        attributes: {
            onDemandRatings: Attribute<TypeFromFields<{
                ratingName: FieldType<string>;
                ratingNameDesc: OptionalFieldType<string>;
            }>[], any>;
            onDemandRatingThreshold: Attribute<string, any>;
        };
        commands: {
            setOnDemandRatingThreshold: Command<TypeFromFields<{
                rating: FieldType<string>;
            }>, void, any>;
        };
    };
    flags: {
        onDemandContentRating: true;
    };
}, {
    component: {
        attributes: {
            scheduledContentRatings: Attribute<TypeFromFields<{
                ratingName: FieldType<string>;
                ratingNameDesc: OptionalFieldType<string>;
            }>[], any>;
            scheduledContentRatingThreshold: Attribute<string, any>;
        };
        commands: {
            setScheduledContentRatingThreshold: Command<TypeFromFields<{
                rating: FieldType<string>;
            }>, void, any>;
        };
    };
    flags: {
        scheduledContentRating: true;
    };
}, {
    component: {
        attributes: {
            remainingScreenTime: Attribute<number, any>;
            screenDailyTime: Attribute<number, any>;
        };
        commands: {
            addBonusTime: Command<TypeFromFields<{
                bonusTime: FieldType<number>;
                pinCode: OptionalFieldType<string>;
            }>, void, any>;
            setScreenDailyTime: Command<TypeFromFields<{
                screenTime: FieldType<number>;
            }>, void, any>;
        };
        events: {
            remainingScreenTimeExpired: Event<void, any>;
        };
    };
    flags: {
        screenTime: true;
    };
}, {
    component: {
        attributes: {
            blockUnrated: Attribute<boolean, any>;
        };
        commands: {
            blockUnratedContent: Command<void, void, any>;
            unblockUnratedContent: Command<void, void, any>;
        };
    };
    flags: {
        blockUnrated: true;
    };
}, {
    component: {
        attributes: {
            blockChannelList: Attribute<TypeFromFields<{
                blockChannelIndex: FieldType<null | number>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>[], any>;
        };
        commands: {
            addBlockChannels: Command<TypeFromFields<{
                channels: FieldType<TypeFromFields<{
                    blockChannelIndex: ...;
                    identifier: ...;
                    majorNumber: ...;
                    minorNumber: ...;
                }>[]>;
            }>, void, any>;
            removeBlockChannels: Command<TypeFromFields<{
                channelIndexes: FieldType<number[]>;
            }>, void, any>;
        };
    };
    flags: {
        blockChannels: true;
    };
}, {
    component: {
        attributes: {
            blockApplicationList: Attribute<TypeFromFields<{
                applicationId: FieldType<string>;
                catalogVendorId: FieldType<number>;
            }>[], any>;
        };
        commands: {
            addBlockApplications: Command<TypeFromFields<{
                applications: FieldType<TypeFromFields<{
                    applicationId: ...;
                    catalogVendorId: ...;
                }>[]>;
            }>, void, any>;
            removeBlockApplications: Command<TypeFromFields<{
                applications: FieldType<TypeFromFields<{
                    applicationId: ...;
                    catalogVendorId: ...;
                }>[]>;
            }>, void, any>;
        };
    };
    flags: {
        blockApplications: true;
    };
}, {
    component: {
        attributes: {
            blockContentTimeWindow: Attribute<TypeFromFields<{
                dayOfWeek: FieldType<ContentControl.DayOfWeek>;
                timePeriod: FieldType<TypeFromFields<(...)>[]>;
                timeWindowIndex: FieldType<null | number>;
            }>[], any>;
        };
        commands: {
            removeBlockContentTimeWindow: Command<TypeFromFields<{
                timeWindowIndexes: FieldType<number[]>;
            }>, void, any>;
            setBlockContentTimeWindow: Command<TypeFromFields<{
                timeWindow: FieldType<TypeFromFields<{
                    dayOfWeek: FieldType<(...)>;
                    timePeriod: FieldType<(...)>;
                    timeWindowIndex: FieldType<(...)>;
                }>>;
            }>, void, any>;
        };
        events: {
            enteringBlockContentTimeWindow: Event<void, any>;
        };
    };
    flags: {
        blockContentTimeWindow: true;
    };
}, {
    component: {
        commands: {
            resetPin: Command<void, TypeFromFields<{
                pinCode: FieldType<string>;
            }>, any>;
            updatePin: Command<TypeFromFields<{
                newPin: FieldType<string>;
                oldPin: FieldType<string>;
            }>, void, any>;
        };
    };
    flags: {
        pinManagement: true;
    };
}]

features

features: {
    blockApplications: BitFlag;
    blockChannels: BitFlag;
    blockContentTimeWindow: BitFlag;
    blockUnrated: BitFlag;
    onDemandContentRating: BitFlag;
    pinManagement: BitFlag;
    scheduledContentRating: BitFlag;
    screenTime: BitFlag;
}

Type declaration

  • ReadonlyblockApplications: BitFlag

    BlockApplications

    Supports managing a set of applications that are prohibited.

  • ReadonlyblockChannels: BitFlag

    BlockChannels

    Supports managing a set of channels that are prohibited.

  • ReadonlyblockContentTimeWindow: BitFlag

    BlockContentTimeWindow

    Supports managing content controls based upon setting time window in which all contents and applications SHALL be blocked.

  • ReadonlyblockUnrated: BitFlag

    BlockUnrated

    Supports managing content controls for unrated content.

  • ReadonlyonDemandContentRating: BitFlag

    OnDemandContentRating

    Supports managing content controls based upon rating threshold for on demand content.

  • ReadonlypinManagement: BitFlag

    PinManagement

    Supports managing a PIN code which is used for restricting access to configuration of this feature.

  • ReadonlyscheduledContentRating: BitFlag

    ScheduledContentRating

    Supports managing content controls based upon rating threshold for scheduled content.

  • ReadonlyscreenTime: BitFlag

    ScreenTime

    Supports managing screen time limits.

id

id: Branded<1295, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              enabled: Attribute<boolean, any>;
          };
          commands: {
              disable: Command<void, void, any>;
              enable: Command<void, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      onDemandRatings: Attribute<TypeFromFields<{
                          ratingName: ...;
                          ratingNameDesc: ...;
                      }>[], any>;
                      onDemandRatingThreshold: Attribute<string, any>;
                  };
                  commands: {
                      setOnDemandRatingThreshold: Command<TypeFromFields<{
                          rating: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  onDemandContentRating: true;
              };
          }, {
              component: {
                  attributes: {
                      scheduledContentRatings: Attribute<TypeFromFields<{
                          ratingName: ...;
                          ratingNameDesc: ...;
                      }>[], any>;
                      scheduledContentRatingThreshold: Attribute<string, any>;
                  };
                  commands: {
                      setScheduledContentRatingThreshold: Command<TypeFromFields<{
                          rating: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  scheduledContentRating: true;
              };
          }, {
              component: {
                  attributes: {
                      remainingScreenTime: Attribute<number, any>;
                      screenDailyTime: Attribute<number, any>;
                  };
                  commands: {
                      addBonusTime: Command<TypeFromFields<{
                          bonusTime: FieldType<(...)>;
                          pinCode: OptionalFieldType<(...)>;
                      }>, void, any>;
                      setScreenDailyTime: Command<TypeFromFields<{
                          screenTime: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      remainingScreenTimeExpired: Event<void, any>;
                  };
              };
              flags: {
                  screenTime: true;
              };
          }, {
              component: {
                  attributes: {
                      blockUnrated: Attribute<boolean, any>;
                  };
                  commands: {
                      blockUnratedContent: Command<void, void, any>;
                      unblockUnratedContent: Command<void, void, any>;
                  };
              };
              flags: {
                  blockUnrated: true;
              };
          }, {
              component: {
                  attributes: {
                      blockChannelList: Attribute<TypeFromFields<{
                          blockChannelIndex: ...;
                          identifier: ...;
                          majorNumber: ...;
                          minorNumber: ...;
                      }>[], any>;
                  };
                  commands: {
                      addBlockChannels: Command<TypeFromFields<{
                          channels: FieldType<(...)>;
                      }>, void, any>;
                      removeBlockChannels: Command<TypeFromFields<{
                          channelIndexes: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  blockChannels: true;
              };
          }, {
              component: {
                  attributes: {
                      blockApplicationList: Attribute<TypeFromFields<{
                          applicationId: ...;
                          catalogVendorId: ...;
                      }>[], any>;
                  };
                  commands: {
                      addBlockApplications: Command<TypeFromFields<{
                          applications: FieldType<(...)>;
                      }>, void, any>;
                      removeBlockApplications: Command<TypeFromFields<{
                          applications: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  blockApplications: true;
              };
          }, {
              component: {
                  attributes: {
                      blockContentTimeWindow: Attribute<TypeFromFields<{
                          dayOfWeek: ...;
                          timePeriod: ...;
                          timeWindowIndex: ...;
                      }>[], any>;
                  };
                  commands: {
                      removeBlockContentTimeWindow: Command<TypeFromFields<{
                          timeWindowIndexes: FieldType<(...)>;
                      }>, void, any>;
                      setBlockContentTimeWindow: Command<TypeFromFields<{
                          timeWindow: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      enteringBlockContentTimeWindow: Event<void, any>;
                  };
              };
              flags: {
                  blockContentTimeWindow: true;
              };
          }, {
              component: {
                  commands: {
                      resetPin: Command<void, TypeFromFields<{
                          pinCode: FieldType<(...)>;
                      }>, any>;
                      updatePin: Command<TypeFromFields<{
                          newPin: FieldType<(...)>;
                          oldPin: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  pinManagement: true;
              };
          }];
          features: {
              blockApplications: BitFlag;
              blockChannels: BitFlag;
              blockContentTimeWindow: BitFlag;
              blockUnrated: BitFlag;
              onDemandContentRating: BitFlag;
              pinManagement: BitFlag;
              scheduledContentRating: BitFlag;
              screenTime: BitFlag;
          };
          id: 1295;
          name: "ContentControl";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              enabled: Attribute<boolean, any>;
          };
          commands: {
              disable: Command<void, void, any>;
              enable: Command<void, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      onDemandRatings: Attribute<TypeFromFields<{
                          ratingName: ...;
                          ratingNameDesc: ...;
                      }>[], any>;
                      onDemandRatingThreshold: Attribute<string, any>;
                  };
                  commands: {
                      setOnDemandRatingThreshold: Command<TypeFromFields<{
                          rating: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  onDemandContentRating: true;
              };
          }, {
              component: {
                  attributes: {
                      scheduledContentRatings: Attribute<TypeFromFields<{
                          ratingName: ...;
                          ratingNameDesc: ...;
                      }>[], any>;
                      scheduledContentRatingThreshold: Attribute<string, any>;
                  };
                  commands: {
                      setScheduledContentRatingThreshold: Command<TypeFromFields<{
                          rating: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  scheduledContentRating: true;
              };
          }, {
              component: {
                  attributes: {
                      remainingScreenTime: Attribute<number, any>;
                      screenDailyTime: Attribute<number, any>;
                  };
                  commands: {
                      addBonusTime: Command<TypeFromFields<{
                          bonusTime: FieldType<(...)>;
                          pinCode: OptionalFieldType<(...)>;
                      }>, void, any>;
                      setScreenDailyTime: Command<TypeFromFields<{
                          screenTime: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      remainingScreenTimeExpired: Event<void, any>;
                  };
              };
              flags: {
                  screenTime: true;
              };
          }, {
              component: {
                  attributes: {
                      blockUnrated: Attribute<boolean, any>;
                  };
                  commands: {
                      blockUnratedContent: Command<void, void, any>;
                      unblockUnratedContent: Command<void, void, any>;
                  };
              };
              flags: {
                  blockUnrated: true;
              };
          }, {
              component: {
                  attributes: {
                      blockChannelList: Attribute<TypeFromFields<{
                          blockChannelIndex: ...;
                          identifier: ...;
                          majorNumber: ...;
                          minorNumber: ...;
                      }>[], any>;
                  };
                  commands: {
                      addBlockChannels: Command<TypeFromFields<{
                          channels: FieldType<(...)>;
                      }>, void, any>;
                      removeBlockChannels: Command<TypeFromFields<{
                          channelIndexes: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  blockChannels: true;
              };
          }, {
              component: {
                  attributes: {
                      blockApplicationList: Attribute<TypeFromFields<{
                          applicationId: ...;
                          catalogVendorId: ...;
                      }>[], any>;
                  };
                  commands: {
                      addBlockApplications: Command<TypeFromFields<{
                          applications: FieldType<(...)>;
                      }>, void, any>;
                      removeBlockApplications: Command<TypeFromFields<{
                          applications: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  blockApplications: true;
              };
          }, {
              component: {
                  attributes: {
                      blockContentTimeWindow: Attribute<TypeFromFields<{
                          dayOfWeek: ...;
                          timePeriod: ...;
                          timeWindowIndex: ...;
                      }>[], any>;
                  };
                  commands: {
                      removeBlockContentTimeWindow: Command<TypeFromFields<{
                          timeWindowIndexes: FieldType<(...)>;
                      }>, void, any>;
                      setBlockContentTimeWindow: Command<TypeFromFields<{
                          timeWindow: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      enteringBlockContentTimeWindow: Event<void, any>;
                  };
              };
              flags: {
                  blockContentTimeWindow: true;
              };
          }, {
              component: {
                  commands: {
                      resetPin: Command<void, TypeFromFields<{
                          pinCode: FieldType<(...)>;
                      }>, any>;
                      updatePin: Command<TypeFromFields<{
                          newPin: FieldType<(...)>;
                          oldPin: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  pinManagement: true;
              };
          }];
          features: {
              blockApplications: BitFlag;
              blockChannels: BitFlag;
              blockContentTimeWindow: BitFlag;
              blockUnrated: BitFlag;
              onDemandContentRating: BitFlag;
              pinManagement: BitFlag;
              scheduledContentRating: BitFlag;
              screenTime: BitFlag;
          };
          id: 1295;
          name: "ContentControl";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          enabled: boolean;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              enabled: Attribute<boolean, any>;
          };
          commands: {
              disable: Command<void, void, any>;
              enable: Command<void, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      onDemandRatings: Attribute<TypeFromFields<{
                          ratingName: ...;
                          ratingNameDesc: ...;
                      }>[], any>;
                      onDemandRatingThreshold: Attribute<string, any>;
                  };
                  commands: {
                      setOnDemandRatingThreshold: Command<TypeFromFields<{
                          rating: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  onDemandContentRating: true;
              };
          }, {
              component: {
                  attributes: {
                      scheduledContentRatings: Attribute<TypeFromFields<{
                          ratingName: ...;
                          ratingNameDesc: ...;
                      }>[], any>;
                      scheduledContentRatingThreshold: Attribute<string, any>;
                  };
                  commands: {
                      setScheduledContentRatingThreshold: Command<TypeFromFields<{
                          rating: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  scheduledContentRating: true;
              };
          }, {
              component: {
                  attributes: {
                      remainingScreenTime: Attribute<number, any>;
                      screenDailyTime: Attribute<number, any>;
                  };
                  commands: {
                      addBonusTime: Command<TypeFromFields<{
                          bonusTime: FieldType<(...)>;
                          pinCode: OptionalFieldType<(...)>;
                      }>, void, any>;
                      setScreenDailyTime: Command<TypeFromFields<{
                          screenTime: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      remainingScreenTimeExpired: Event<void, any>;
                  };
              };
              flags: {
                  screenTime: true;
              };
          }, {
              component: {
                  attributes: {
                      blockUnrated: Attribute<boolean, any>;
                  };
                  commands: {
                      blockUnratedContent: Command<void, void, any>;
                      unblockUnratedContent: Command<void, void, any>;
                  };
              };
              flags: {
                  blockUnrated: true;
              };
          }, {
              component: {
                  attributes: {
                      blockChannelList: Attribute<TypeFromFields<{
                          blockChannelIndex: ...;
                          identifier: ...;
                          majorNumber: ...;
                          minorNumber: ...;
                      }>[], any>;
                  };
                  commands: {
                      addBlockChannels: Command<TypeFromFields<{
                          channels: FieldType<(...)>;
                      }>, void, any>;
                      removeBlockChannels: Command<TypeFromFields<{
                          channelIndexes: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  blockChannels: true;
              };
          }, {
              component: {
                  attributes: {
                      blockApplicationList: Attribute<TypeFromFields<{
                          applicationId: ...;
                          catalogVendorId: ...;
                      }>[], any>;
                  };
                  commands: {
                      addBlockApplications: Command<TypeFromFields<{
                          applications: FieldType<(...)>;
                      }>, void, any>;
                      removeBlockApplications: Command<TypeFromFields<{
                          applications: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  blockApplications: true;
              };
          }, {
              component: {
                  attributes: {
                      blockContentTimeWindow: Attribute<TypeFromFields<{
                          dayOfWeek: ...;
                          timePeriod: ...;
                          timeWindowIndex: ...;
                      }>[], any>;
                  };
                  commands: {
                      removeBlockContentTimeWindow: Command<TypeFromFields<{
                          timeWindowIndexes: FieldType<(...)>;
                      }>, void, any>;
                      setBlockContentTimeWindow: Command<TypeFromFields<{
                          timeWindow: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      enteringBlockContentTimeWindow: Event<void, any>;
                  };
              };
              flags: {
                  blockContentTimeWindow: true;
              };
          }, {
              component: {
                  commands: {
                      resetPin: Command<void, TypeFromFields<{
                          pinCode: FieldType<(...)>;
                      }>, any>;
                      updatePin: Command<TypeFromFields<{
                          newPin: FieldType<(...)>;
                          oldPin: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  pinManagement: true;
              };
          }];
          features: {
              blockApplications: BitFlag;
              blockChannels: BitFlag;
              blockContentTimeWindow: BitFlag;
              blockUnrated: BitFlag;
              onDemandContentRating: BitFlag;
              pinManagement: BitFlag;
              scheduledContentRating: BitFlag;
              screenTime: BitFlag;
          };
          id: 1295;
          name: "ContentControl";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            enabled: Attribute<boolean, any>;
        };
        commands: {
            disable: Command<void, void, any>;
            enable: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onDemandRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    onDemandRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setOnDemandRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                onDemandContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    scheduledContentRatings: Attribute<TypeFromFields<{
                        ratingName: ...;
                        ratingNameDesc: ...;
                    }>[], any>;
                    scheduledContentRatingThreshold: Attribute<string, any>;
                };
                commands: {
                    setScheduledContentRatingThreshold: Command<TypeFromFields<{
                        rating: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                scheduledContentRating: true;
            };
        }, {
            component: {
                attributes: {
                    remainingScreenTime: Attribute<number, any>;
                    screenDailyTime: Attribute<number, any>;
                };
                commands: {
                    addBonusTime: Command<TypeFromFields<{
                        bonusTime: FieldType<(...)>;
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                    setScreenDailyTime: Command<TypeFromFields<{
                        screenTime: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    remainingScreenTimeExpired: Event<void, any>;
                };
            };
            flags: {
                screenTime: true;
            };
        }, {
            component: {
                attributes: {
                    blockUnrated: Attribute<boolean, any>;
                };
                commands: {
                    blockUnratedContent: Command<void, void, any>;
                    unblockUnratedContent: Command<void, void, any>;
                };
            };
            flags: {
                blockUnrated: true;
            };
        }, {
            component: {
                attributes: {
                    blockChannelList: Attribute<TypeFromFields<{
                        blockChannelIndex: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockChannels: Command<TypeFromFields<{
                        channels: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockChannels: Command<TypeFromFields<{
                        channelIndexes: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockChannels: true;
            };
        }, {
            component: {
                attributes: {
                    blockApplicationList: Attribute<TypeFromFields<{
                        applicationId: ...;
                        catalogVendorId: ...;
                    }>[], any>;
                };
                commands: {
                    addBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                    removeBlockApplications: Command<TypeFromFields<{
                        applications: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                blockApplications: true;
            };
        }, {
            component: {
                attributes: {
                    blockContentTimeWindow: Attribute<TypeFromFields<{
                        dayOfWeek: ...;
                        timePeriod: ...;
                        timeWindowIndex: ...;
                    }>[], any>;
                };
                commands: {
                    removeBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindowIndexes: FieldType<(...)>;
                    }>, void, any>;
                    setBlockContentTimeWindow: Command<TypeFromFields<{
                        timeWindow: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    enteringBlockContentTimeWindow: Event<void, any>;
                };
            };
            flags: {
                blockContentTimeWindow: true;
            };
        }, {
            component: {
                commands: {
                    resetPin: Command<void, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                    }>, any>;
                    updatePin: Command<TypeFromFields<{
                        newPin: FieldType<(...)>;
                        oldPin: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinManagement: true;
            };
        }];
        features: {
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        };
        id: 1295;
        name: "ContentControl";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods