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)

Identity<typeof ContentControl.ClusterInstance>
- Cluster

Index

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

revision

supportedFeatures

supportedFeatures: {}

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
- alterations: AlterationsT
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>
Inherited from Identity.alter
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:37

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
- flags: FlagsT
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>
Inherited from Identity.enable
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:45

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
- values: ValuesT
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>
Inherited from Identity.set
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:41

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
- Rest...selection: SelectionT
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>
Inherited from Identity.with
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:33

Interface Cluster

See

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

Type declaration

Readonlyenabled: Attribute<boolean, any>

See

base

commands

Type declaration

Readonlydisable: Command<void, void, any>

See

Readonlyenable: Command<void, void, any>

See

events

extensions

features

Type declaration

ReadonlyblockApplications: BitFlag

ReadonlyblockChannels: BitFlag

ReadonlyblockContentTimeWindow: BitFlag

ReadonlyblockUnrated: BitFlag

ReadonlyonDemandContentRating: BitFlag

ReadonlypinManagement: BitFlag

ReadonlyscheduledContentRating: BitFlag

ReadonlyscreenTime: BitFlag

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page

`Readonly`enabled: Attribute<boolean, any>

`Readonly`disable: Command<void, void, any>

`Readonly`enable: Command<void, void, any>

`Readonly`blockApplications: BitFlag

`Readonly`blockChannels: BitFlag

`Readonly`blockContentTimeWindow: BitFlag

`Readonly`blockUnrated: BitFlag

`Readonly`onDemandContentRating: BitFlag

`Readonly`pinManagement: BitFlag

`Readonly`scheduledContentRating: BitFlag

`Readonly`screenTime: BitFlag