Interface Complete

This cluster supports all ContentControl features. It may support illegal feature combinations.

If you use this cluster you must manually specify which features are active and ensure the set of active features is legal per the Matter specification.

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

Hierarchy (view full)

Identity<typeof ContentControl.CompleteInstance>
- Complete

Index

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    attributeList: Attribute<AttributeId[], never>;
    blockApplicationList: Attribute<TypeFromFields<{
        applicationId: FieldType<string>;
        catalogVendorId: FieldType<number>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockApplications: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    blockChannelList: Attribute<TypeFromFields<{
        blockChannelIndex: FieldType<null | number>;
        identifier: OptionalFieldType<string>;
        majorNumber: FieldType<number>;
        minorNumber: FieldType<number>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockChannels: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    blockContentTimeWindow: Attribute<TypeFromFields<{
        dayOfWeek: FieldType<ContentControl.DayOfWeek>;
        timePeriod: FieldType<TypeFromFields<{
            endHour: ...;
            endMinute: ...;
            startHour: ...;
            startMinute: ...;
        }>[]>;
        timeWindowIndex: FieldType<null | number>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockContentTimeWindow: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    blockUnrated: Attribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockUnrated: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clusterRevision: Attribute<number, never>;
    enabled: Attribute<boolean, any>;
    featureMap: Attribute<TypeFromPartialBitSchema<{
        blockApplications: BitFlag;
        blockChannels: BitFlag;
        blockContentTimeWindow: BitFlag;
        blockUnrated: BitFlag;
        onDemandContentRating: BitFlag;
        pinManagement: BitFlag;
        scheduledContentRating: BitFlag;
        screenTime: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    onDemandRatings: Attribute<TypeFromFields<{
        ratingName: FieldType<string>;
        ratingNameDesc: OptionalFieldType<string>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            onDemandContentRating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    onDemandRatingThreshold: Attribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            onDemandContentRating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    remainingScreenTime: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            screenTime: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    scheduledContentRatings: Attribute<TypeFromFields<{
        ratingName: FieldType<string>;
        ratingNameDesc: OptionalFieldType<string>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduledContentRating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    scheduledContentRatingThreshold: Attribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduledContentRating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    screenDailyTime: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            screenTime: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    blockApplications: BitFlag;
    blockChannels: BitFlag;
    blockContentTimeWindow: BitFlag;
    blockUnrated: BitFlag;
    onDemandContentRating: BitFlag;
    pinManagement: BitFlag;
    scheduledContentRating: BitFlag;
    screenTime: BitFlag;
}>>

base

base: undefined

commands

commands: {
    addBlockApplications: Command<TypeFromFields<{
        applications: FieldType<TypeFromFields<{
            applicationId: FieldType<string>;
            catalogVendorId: FieldType<number>;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockApplications: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    addBlockChannels: Command<TypeFromFields<{
        channels: FieldType<TypeFromFields<{
            blockChannelIndex: FieldType<(...) | (...)>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockChannels: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    addBonusTime: Command<TypeFromFields<{
        bonusTime: FieldType<number>;
        pinCode: OptionalFieldType<string>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            screenTime: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    blockUnratedContent: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockUnrated: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    disable: Command<void, void, any>;
    enable: Command<void, void, any>;
    removeBlockApplications: Command<TypeFromFields<{
        applications: FieldType<TypeFromFields<{
            applicationId: FieldType<string>;
            catalogVendorId: FieldType<number>;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockApplications: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    removeBlockChannels: Command<TypeFromFields<{
        channelIndexes: FieldType<number[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockChannels: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    removeBlockContentTimeWindow: Command<TypeFromFields<{
        timeWindowIndexes: FieldType<number[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockContentTimeWindow: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    resetPin: Command<void, TypeFromFields<{
        pinCode: FieldType<string>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinManagement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setBlockContentTimeWindow: Command<TypeFromFields<{
        timeWindow: FieldType<TypeFromFields<{
            dayOfWeek: FieldType<ContentControl.DayOfWeek>;
            timePeriod: FieldType<TypeFromFields<(...)>[]>;
            timeWindowIndex: FieldType<null | number>;
        }>>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockContentTimeWindow: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setOnDemandRatingThreshold: Command<TypeFromFields<{
        rating: FieldType<string>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            onDemandContentRating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setScheduledContentRatingThreshold: Command<TypeFromFields<{
        rating: FieldType<string>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduledContentRating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setScreenDailyTime: Command<TypeFromFields<{
        screenTime: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            screenTime: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    unblockUnratedContent: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockUnrated: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    updatePin: Command<TypeFromFields<{
        newPin: FieldType<string>;
        oldPin: FieldType<string>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinManagement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}

Type declaration

ReadonlyaddBlockApplications: Command<TypeFromFields<{
    applications: FieldType<TypeFromFields<{
        applicationId: FieldType<string>;
        catalogVendorId: FieldType<number>;
    }>[]>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        blockApplications: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyaddBlockChannels: Command<TypeFromFields<{
    channels: FieldType<TypeFromFields<{
        blockChannelIndex: FieldType<(...) | (...)>;
        identifier: OptionalFieldType<string>;
        majorNumber: FieldType<number>;
        minorNumber: FieldType<number>;
    }>[]>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        blockChannels: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyaddBonusTime: Command<TypeFromFields<{
    bonusTime: FieldType<number>;
    pinCode: OptionalFieldType<string>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        screenTime: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyblockUnratedContent: Command<void, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        blockUnrated: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
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
ReadonlyremoveBlockApplications: Command<TypeFromFields<{
    applications: FieldType<TypeFromFields<{
        applicationId: FieldType<string>;
        catalogVendorId: FieldType<number>;
    }>[]>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        blockApplications: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyremoveBlockChannels: Command<TypeFromFields<{
    channelIndexes: FieldType<number[]>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        blockChannels: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyremoveBlockContentTimeWindow: Command<TypeFromFields<{
    timeWindowIndexes: FieldType<number[]>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        blockContentTimeWindow: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyresetPin: Command<void, TypeFromFields<{
    pinCode: FieldType<string>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        pinManagement: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlysetBlockContentTimeWindow: Command<TypeFromFields<{
    timeWindow: FieldType<TypeFromFields<{
        dayOfWeek: FieldType<ContentControl.DayOfWeek>;
        timePeriod: FieldType<TypeFromFields<(...)>[]>;
        timeWindowIndex: FieldType<null | number>;
    }>>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        blockContentTimeWindow: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlysetOnDemandRatingThreshold: Command<TypeFromFields<{
    rating: FieldType<string>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        onDemandContentRating: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlysetScheduledContentRatingThreshold: Command<TypeFromFields<{
    rating: FieldType<string>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        scheduledContentRating: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlysetScreenDailyTime: Command<TypeFromFields<{
    screenTime: FieldType<number>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        screenTime: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyunblockUnratedContent: Command<void, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        blockUnrated: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyupdatePin: Command<TypeFromFields<{
    newPin: FieldType<string>;
    oldPin: FieldType<string>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        pinManagement: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

events

events: {
    enteringBlockContentTimeWindow: Event<void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockContentTimeWindow: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    remainingScreenTimeExpired: Event<void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            screenTime: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}

extensions

extensions: undefined

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<Branded<1295, "ClusterId">, "ClusterId">

name

revision

supportedFeatures

supportedFeatures: {}

unknown

Methods

alter

alter<const AlterationsT>(alterations): WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        blockApplicationList: Attribute<TypeFromFields<{
            applicationId: FieldType<string>;
            catalogVendorId: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockChannelList: Attribute<TypeFromFields<{
            blockChannelIndex: FieldType<(...) | (...)>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockContentTimeWindow: Attribute<TypeFromFields<{
            dayOfWeek: FieldType<ContentControl.DayOfWeek>;
            timePeriod: FieldType<(...)[]>;
            timeWindowIndex: FieldType<(...) | (...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnrated: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        enabled: Attribute<boolean, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        onDemandRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        onDemandRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        screenDailyTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        addBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBlockChannels: Command<TypeFromFields<{
            channels: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBonusTime: Command<TypeFromFields<{
            bonusTime: FieldType<number>;
            pinCode: OptionalFieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        disable: Command<void, void, any>;
        enable: Command<void, void, any>;
        removeBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockChannels: Command<TypeFromFields<{
            channelIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindowIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        resetPin: Command<void, TypeFromFields<{
            pinCode: FieldType<string>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindow: FieldType<TypeFromFields<{
                dayOfWeek: ...;
                timePeriod: ...;
                timeWindowIndex: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setOnDemandRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScheduledContentRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScreenDailyTime: Command<TypeFromFields<{
            screenTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unblockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        updatePin: Command<TypeFromFields<{
            newPin: FieldType<string>;
            oldPin: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        enteringBlockContentTimeWindow: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTimeExpired: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    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;
}>, AlterationsT>
Modify elements using ElementModifier.alter.
Type Parameters
- const AlterationsT extends Alterations<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          attributeList: Attribute<AttributeId[], never>;
          blockApplicationList: Attribute<TypeFromFields<{
              applicationId: FieldType<string>;
              catalogVendorId: FieldType<number>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockApplications: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockChannelList: Attribute<TypeFromFields<{
              blockChannelIndex: FieldType<(...) | (...)>;
              identifier: OptionalFieldType<string>;
              majorNumber: FieldType<number>;
              minorNumber: FieldType<number>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockChannels: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockContentTimeWindow: Attribute<TypeFromFields<{
              dayOfWeek: FieldType<ContentControl.DayOfWeek>;
              timePeriod: FieldType<(...)[]>;
              timeWindowIndex: FieldType<(...) | (...)>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockUnrated: Attribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockUnrated: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          clusterRevision: Attribute<number, never>;
          enabled: Attribute<boolean, any>;
          featureMap: Attribute<TypeFromPartialBitSchema<{
              blockApplications: BitFlag;
              blockChannels: BitFlag;
              blockContentTimeWindow: BitFlag;
              blockUnrated: BitFlag;
              onDemandContentRating: BitFlag;
              pinManagement: BitFlag;
              scheduledContentRating: BitFlag;
              screenTime: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          onDemandRatings: Attribute<TypeFromFields<{
              ratingName: FieldType<string>;
              ratingNameDesc: OptionalFieldType<string>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  onDemandContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          onDemandRatingThreshold: Attribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  onDemandContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          remainingScreenTime: Attribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          scheduledContentRatings: Attribute<TypeFromFields<{
              ratingName: FieldType<string>;
              ratingNameDesc: OptionalFieldType<string>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  scheduledContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          scheduledContentRatingThreshold: Attribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  scheduledContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          screenDailyTime: Attribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      commands: {
          addBlockApplications: Command<TypeFromFields<{
              applications: FieldType<TypeFromFields<(...)>[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockApplications: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          addBlockChannels: Command<TypeFromFields<{
              channels: FieldType<TypeFromFields<(...)>[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockChannels: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          addBonusTime: Command<TypeFromFields<{
              bonusTime: FieldType<number>;
              pinCode: OptionalFieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockUnratedContent: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockUnrated: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          disable: Command<void, void, any>;
          enable: Command<void, void, any>;
          removeBlockApplications: Command<TypeFromFields<{
              applications: FieldType<TypeFromFields<(...)>[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockApplications: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          removeBlockChannels: Command<TypeFromFields<{
              channelIndexes: FieldType<number[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockChannels: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          removeBlockContentTimeWindow: Command<TypeFromFields<{
              timeWindowIndexes: FieldType<number[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          resetPin: Command<void, TypeFromFields<{
              pinCode: FieldType<string>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  pinManagement: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setBlockContentTimeWindow: Command<TypeFromFields<{
              timeWindow: FieldType<TypeFromFields<{
                  dayOfWeek: ...;
                  timePeriod: ...;
                  timeWindowIndex: ...;
              }>>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setOnDemandRatingThreshold: Command<TypeFromFields<{
              rating: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  onDemandContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setScheduledContentRatingThreshold: Command<TypeFromFields<{
              rating: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  scheduledContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setScreenDailyTime: Command<TypeFromFields<{
              screenTime: FieldType<number>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          unblockUnratedContent: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockUnrated: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          updatePin: Command<TypeFromFields<{
              newPin: FieldType<string>;
              oldPin: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  pinManagement: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          enteringBlockContentTimeWindow: Event<void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          remainingScreenTimeExpired: Event<void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      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;
  }>>
Parameters
- alterations: AlterationsT
Returns WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        blockApplicationList: Attribute<TypeFromFields<{
            applicationId: FieldType<string>;
            catalogVendorId: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockChannelList: Attribute<TypeFromFields<{
            blockChannelIndex: FieldType<(...) | (...)>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockContentTimeWindow: Attribute<TypeFromFields<{
            dayOfWeek: FieldType<ContentControl.DayOfWeek>;
            timePeriod: FieldType<(...)[]>;
            timeWindowIndex: FieldType<(...) | (...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnrated: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        enabled: Attribute<boolean, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        onDemandRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        onDemandRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        screenDailyTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        addBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBlockChannels: Command<TypeFromFields<{
            channels: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBonusTime: Command<TypeFromFields<{
            bonusTime: FieldType<number>;
            pinCode: OptionalFieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        disable: Command<void, void, any>;
        enable: Command<void, void, any>;
        removeBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockChannels: Command<TypeFromFields<{
            channelIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindowIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        resetPin: Command<void, TypeFromFields<{
            pinCode: FieldType<string>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindow: FieldType<TypeFromFields<{
                dayOfWeek: ...;
                timePeriod: ...;
                timeWindowIndex: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setOnDemandRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScheduledContentRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScreenDailyTime: Command<TypeFromFields<{
            screenTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unblockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        updatePin: Command<TypeFromFields<{
            newPin: FieldType<string>;
            oldPin: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        enteringBlockContentTimeWindow: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTimeExpired: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    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;
}>, 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: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        blockApplicationList: Attribute<TypeFromFields<{
            applicationId: FieldType<string>;
            catalogVendorId: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockChannelList: Attribute<TypeFromFields<{
            blockChannelIndex: FieldType<(...) | (...)>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockContentTimeWindow: Attribute<TypeFromFields<{
            dayOfWeek: FieldType<ContentControl.DayOfWeek>;
            timePeriod: FieldType<(...)[]>;
            timeWindowIndex: FieldType<(...) | (...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnrated: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        enabled: Attribute<boolean, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        onDemandRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        onDemandRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        screenDailyTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        addBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBlockChannels: Command<TypeFromFields<{
            channels: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBonusTime: Command<TypeFromFields<{
            bonusTime: FieldType<number>;
            pinCode: OptionalFieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        disable: Command<void, void, any>;
        enable: Command<void, void, any>;
        removeBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockChannels: Command<TypeFromFields<{
            channelIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindowIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        resetPin: Command<void, TypeFromFields<{
            pinCode: FieldType<string>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindow: FieldType<TypeFromFields<{
                dayOfWeek: ...;
                timePeriod: ...;
                timeWindowIndex: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setOnDemandRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScheduledContentRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScreenDailyTime: Command<TypeFromFields<{
            screenTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unblockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        updatePin: Command<TypeFromFields<{
            newPin: FieldType<string>;
            oldPin: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        enteringBlockContentTimeWindow: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTimeExpired: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    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;
}>, FlagsT>
Modify elements using ElementModifier.enable.
Type Parameters
- const FlagsT extends ElementFlags<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          attributeList: Attribute<AttributeId[], never>;
          blockApplicationList: Attribute<TypeFromFields<{
              applicationId: FieldType<string>;
              catalogVendorId: FieldType<number>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockApplications: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockChannelList: Attribute<TypeFromFields<{
              blockChannelIndex: FieldType<(...) | (...)>;
              identifier: OptionalFieldType<string>;
              majorNumber: FieldType<number>;
              minorNumber: FieldType<number>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockChannels: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockContentTimeWindow: Attribute<TypeFromFields<{
              dayOfWeek: FieldType<ContentControl.DayOfWeek>;
              timePeriod: FieldType<(...)[]>;
              timeWindowIndex: FieldType<(...) | (...)>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockUnrated: Attribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockUnrated: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          clusterRevision: Attribute<number, never>;
          enabled: Attribute<boolean, any>;
          featureMap: Attribute<TypeFromPartialBitSchema<{
              blockApplications: BitFlag;
              blockChannels: BitFlag;
              blockContentTimeWindow: BitFlag;
              blockUnrated: BitFlag;
              onDemandContentRating: BitFlag;
              pinManagement: BitFlag;
              scheduledContentRating: BitFlag;
              screenTime: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          onDemandRatings: Attribute<TypeFromFields<{
              ratingName: FieldType<string>;
              ratingNameDesc: OptionalFieldType<string>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  onDemandContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          onDemandRatingThreshold: Attribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  onDemandContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          remainingScreenTime: Attribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          scheduledContentRatings: Attribute<TypeFromFields<{
              ratingName: FieldType<string>;
              ratingNameDesc: OptionalFieldType<string>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  scheduledContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          scheduledContentRatingThreshold: Attribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  scheduledContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          screenDailyTime: Attribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      commands: {
          addBlockApplications: Command<TypeFromFields<{
              applications: FieldType<TypeFromFields<(...)>[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockApplications: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          addBlockChannels: Command<TypeFromFields<{
              channels: FieldType<TypeFromFields<(...)>[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockChannels: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          addBonusTime: Command<TypeFromFields<{
              bonusTime: FieldType<number>;
              pinCode: OptionalFieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockUnratedContent: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockUnrated: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          disable: Command<void, void, any>;
          enable: Command<void, void, any>;
          removeBlockApplications: Command<TypeFromFields<{
              applications: FieldType<TypeFromFields<(...)>[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockApplications: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          removeBlockChannels: Command<TypeFromFields<{
              channelIndexes: FieldType<number[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockChannels: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          removeBlockContentTimeWindow: Command<TypeFromFields<{
              timeWindowIndexes: FieldType<number[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          resetPin: Command<void, TypeFromFields<{
              pinCode: FieldType<string>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  pinManagement: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setBlockContentTimeWindow: Command<TypeFromFields<{
              timeWindow: FieldType<TypeFromFields<{
                  dayOfWeek: ...;
                  timePeriod: ...;
                  timeWindowIndex: ...;
              }>>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setOnDemandRatingThreshold: Command<TypeFromFields<{
              rating: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  onDemandContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setScheduledContentRatingThreshold: Command<TypeFromFields<{
              rating: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  scheduledContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setScreenDailyTime: Command<TypeFromFields<{
              screenTime: FieldType<number>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          unblockUnratedContent: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockUnrated: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          updatePin: Command<TypeFromFields<{
              newPin: FieldType<string>;
              oldPin: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  pinManagement: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          enteringBlockContentTimeWindow: Event<void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          remainingScreenTimeExpired: Event<void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      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;
  }>>
Parameters
- flags: FlagsT
Returns WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        blockApplicationList: Attribute<TypeFromFields<{
            applicationId: FieldType<string>;
            catalogVendorId: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockChannelList: Attribute<TypeFromFields<{
            blockChannelIndex: FieldType<(...) | (...)>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockContentTimeWindow: Attribute<TypeFromFields<{
            dayOfWeek: FieldType<ContentControl.DayOfWeek>;
            timePeriod: FieldType<(...)[]>;
            timeWindowIndex: FieldType<(...) | (...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnrated: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        enabled: Attribute<boolean, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        onDemandRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        onDemandRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        screenDailyTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        addBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBlockChannels: Command<TypeFromFields<{
            channels: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBonusTime: Command<TypeFromFields<{
            bonusTime: FieldType<number>;
            pinCode: OptionalFieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        disable: Command<void, void, any>;
        enable: Command<void, void, any>;
        removeBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockChannels: Command<TypeFromFields<{
            channelIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindowIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        resetPin: Command<void, TypeFromFields<{
            pinCode: FieldType<string>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindow: FieldType<TypeFromFields<{
                dayOfWeek: ...;
                timePeriod: ...;
                timeWindowIndex: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setOnDemandRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScheduledContentRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScreenDailyTime: Command<TypeFromFields<{
            screenTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unblockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        updatePin: Command<TypeFromFields<{
            newPin: FieldType<string>;
            oldPin: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        enteringBlockContentTimeWindow: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTimeExpired: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    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;
}>, 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: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        blockApplicationList: Attribute<TypeFromFields<{
            applicationId: FieldType<string>;
            catalogVendorId: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockChannelList: Attribute<TypeFromFields<{
            blockChannelIndex: FieldType<(...) | (...)>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockContentTimeWindow: Attribute<TypeFromFields<{
            dayOfWeek: FieldType<ContentControl.DayOfWeek>;
            timePeriod: FieldType<(...)[]>;
            timeWindowIndex: FieldType<(...) | (...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnrated: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        enabled: Attribute<boolean, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        onDemandRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        onDemandRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        screenDailyTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        addBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBlockChannels: Command<TypeFromFields<{
            channels: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBonusTime: Command<TypeFromFields<{
            bonusTime: FieldType<number>;
            pinCode: OptionalFieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        disable: Command<void, void, any>;
        enable: Command<void, void, any>;
        removeBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockChannels: Command<TypeFromFields<{
            channelIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindowIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        resetPin: Command<void, TypeFromFields<{
            pinCode: FieldType<string>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindow: FieldType<TypeFromFields<{
                dayOfWeek: ...;
                timePeriod: ...;
                timeWindowIndex: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setOnDemandRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScheduledContentRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScreenDailyTime: Command<TypeFromFields<{
            screenTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unblockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        updatePin: Command<TypeFromFields<{
            newPin: FieldType<string>;
            oldPin: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        enteringBlockContentTimeWindow: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTimeExpired: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    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;
}>, ValuesT>
Modify elements using ElementModifier.set.
Type Parameters
- const ValuesT extends {
      blockApplicationList?: {
          applicationId: string;
          catalogVendorId: number;
      }[];
      blockChannelList?: {
          blockChannelIndex: null | number;
          identifier?: string;
          majorNumber: number;
          minorNumber: number;
      }[];
      blockContentTimeWindow?: {
          dayOfWeek: number;
          timePeriod: {
              endHour: number;
              endMinute: number;
              startHour: number;
              startMinute: number;
          }[];
          timeWindowIndex: null | number;
      }[];
      blockUnrated?: boolean;
      enabled: boolean;
      onDemandRatings?: {
          ratingName: string;
          ratingNameDesc?: string;
      }[];
      onDemandRatingThreshold?: string;
      remainingScreenTime?: number;
      scheduledContentRatings?: {
          ratingName: string;
          ratingNameDesc?: string;
      }[];
      scheduledContentRatingThreshold?: string;
      screenDailyTime?: number;
  }
Parameters
- values: ValuesT
Returns WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        blockApplicationList: Attribute<TypeFromFields<{
            applicationId: FieldType<string>;
            catalogVendorId: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockChannelList: Attribute<TypeFromFields<{
            blockChannelIndex: FieldType<(...) | (...)>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockContentTimeWindow: Attribute<TypeFromFields<{
            dayOfWeek: FieldType<ContentControl.DayOfWeek>;
            timePeriod: FieldType<(...)[]>;
            timeWindowIndex: FieldType<(...) | (...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnrated: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        enabled: Attribute<boolean, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        onDemandRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        onDemandRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        screenDailyTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        addBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBlockChannels: Command<TypeFromFields<{
            channels: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBonusTime: Command<TypeFromFields<{
            bonusTime: FieldType<number>;
            pinCode: OptionalFieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        disable: Command<void, void, any>;
        enable: Command<void, void, any>;
        removeBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockChannels: Command<TypeFromFields<{
            channelIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindowIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        resetPin: Command<void, TypeFromFields<{
            pinCode: FieldType<string>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindow: FieldType<TypeFromFields<{
                dayOfWeek: ...;
                timePeriod: ...;
                timeWindowIndex: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setOnDemandRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScheduledContentRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScreenDailyTime: Command<TypeFromFields<{
            screenTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unblockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        updatePin: Command<TypeFromFields<{
            newPin: FieldType<string>;
            oldPin: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        enteringBlockContentTimeWindow: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTimeExpired: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    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;
}>, 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: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        blockApplicationList: Attribute<TypeFromFields<{
            applicationId: FieldType<string>;
            catalogVendorId: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockChannelList: Attribute<TypeFromFields<{
            blockChannelIndex: FieldType<(...) | (...)>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockContentTimeWindow: Attribute<TypeFromFields<{
            dayOfWeek: FieldType<ContentControl.DayOfWeek>;
            timePeriod: FieldType<(...)[]>;
            timeWindowIndex: FieldType<(...) | (...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnrated: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        enabled: Attribute<boolean, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        onDemandRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        onDemandRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        screenDailyTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        addBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBlockChannels: Command<TypeFromFields<{
            channels: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBonusTime: Command<TypeFromFields<{
            bonusTime: FieldType<number>;
            pinCode: OptionalFieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        disable: Command<void, void, any>;
        enable: Command<void, void, any>;
        removeBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockChannels: Command<TypeFromFields<{
            channelIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindowIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        resetPin: Command<void, TypeFromFields<{
            pinCode: FieldType<string>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindow: FieldType<TypeFromFields<{
                dayOfWeek: ...;
                timePeriod: ...;
                timeWindowIndex: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setOnDemandRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScheduledContentRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScreenDailyTime: Command<TypeFromFields<{
            screenTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unblockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        updatePin: Command<TypeFromFields<{
            newPin: FieldType<string>;
            oldPin: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        enteringBlockContentTimeWindow: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTimeExpired: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    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;
}>, SelectionT>
Select features using ClusterComposer.compose.
Type Parameters
- const SelectionT extends FeatureSelection<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          attributeList: Attribute<AttributeId[], never>;
          blockApplicationList: Attribute<TypeFromFields<{
              applicationId: FieldType<string>;
              catalogVendorId: FieldType<number>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockApplications: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockChannelList: Attribute<TypeFromFields<{
              blockChannelIndex: FieldType<(...) | (...)>;
              identifier: OptionalFieldType<string>;
              majorNumber: FieldType<number>;
              minorNumber: FieldType<number>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockChannels: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockContentTimeWindow: Attribute<TypeFromFields<{
              dayOfWeek: FieldType<ContentControl.DayOfWeek>;
              timePeriod: FieldType<(...)[]>;
              timeWindowIndex: FieldType<(...) | (...)>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockUnrated: Attribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockUnrated: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          clusterRevision: Attribute<number, never>;
          enabled: Attribute<boolean, any>;
          featureMap: Attribute<TypeFromPartialBitSchema<{
              blockApplications: BitFlag;
              blockChannels: BitFlag;
              blockContentTimeWindow: BitFlag;
              blockUnrated: BitFlag;
              onDemandContentRating: BitFlag;
              pinManagement: BitFlag;
              scheduledContentRating: BitFlag;
              screenTime: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          onDemandRatings: Attribute<TypeFromFields<{
              ratingName: FieldType<string>;
              ratingNameDesc: OptionalFieldType<string>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  onDemandContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          onDemandRatingThreshold: Attribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  onDemandContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          remainingScreenTime: Attribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          scheduledContentRatings: Attribute<TypeFromFields<{
              ratingName: FieldType<string>;
              ratingNameDesc: OptionalFieldType<string>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  scheduledContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          scheduledContentRatingThreshold: Attribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  scheduledContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          screenDailyTime: Attribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      commands: {
          addBlockApplications: Command<TypeFromFields<{
              applications: FieldType<TypeFromFields<(...)>[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockApplications: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          addBlockChannels: Command<TypeFromFields<{
              channels: FieldType<TypeFromFields<(...)>[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockChannels: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          addBonusTime: Command<TypeFromFields<{
              bonusTime: FieldType<number>;
              pinCode: OptionalFieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          blockUnratedContent: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockUnrated: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          disable: Command<void, void, any>;
          enable: Command<void, void, any>;
          removeBlockApplications: Command<TypeFromFields<{
              applications: FieldType<TypeFromFields<(...)>[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockApplications: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          removeBlockChannels: Command<TypeFromFields<{
              channelIndexes: FieldType<number[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockChannels: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          removeBlockContentTimeWindow: Command<TypeFromFields<{
              timeWindowIndexes: FieldType<number[]>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          resetPin: Command<void, TypeFromFields<{
              pinCode: FieldType<string>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  pinManagement: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setBlockContentTimeWindow: Command<TypeFromFields<{
              timeWindow: FieldType<TypeFromFields<{
                  dayOfWeek: ...;
                  timePeriod: ...;
                  timeWindowIndex: ...;
              }>>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setOnDemandRatingThreshold: Command<TypeFromFields<{
              rating: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  onDemandContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setScheduledContentRatingThreshold: Command<TypeFromFields<{
              rating: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  scheduledContentRating: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          setScreenDailyTime: Command<TypeFromFields<{
              screenTime: FieldType<number>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          unblockUnratedContent: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockUnrated: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          updatePin: Command<TypeFromFields<{
              newPin: FieldType<string>;
              oldPin: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  pinManagement: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          enteringBlockContentTimeWindow: Event<void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  blockContentTimeWindow: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          remainingScreenTimeExpired: Event<void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  screenTime: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      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;
  }>>
Parameters
- Rest...selection: SelectionT
Returns Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        blockApplicationList: Attribute<TypeFromFields<{
            applicationId: FieldType<string>;
            catalogVendorId: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockChannelList: Attribute<TypeFromFields<{
            blockChannelIndex: FieldType<(...) | (...)>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockContentTimeWindow: Attribute<TypeFromFields<{
            dayOfWeek: FieldType<ContentControl.DayOfWeek>;
            timePeriod: FieldType<(...)[]>;
            timeWindowIndex: FieldType<(...) | (...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnrated: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        enabled: Attribute<boolean, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            blockApplications: BitFlag;
            blockChannels: BitFlag;
            blockContentTimeWindow: BitFlag;
            blockUnrated: BitFlag;
            onDemandContentRating: BitFlag;
            pinManagement: BitFlag;
            scheduledContentRating: BitFlag;
            screenTime: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        onDemandRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        onDemandRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatings: Attribute<TypeFromFields<{
            ratingName: FieldType<string>;
            ratingNameDesc: OptionalFieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scheduledContentRatingThreshold: Attribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        screenDailyTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        addBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBlockChannels: Command<TypeFromFields<{
            channels: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addBonusTime: Command<TypeFromFields<{
            bonusTime: FieldType<number>;
            pinCode: OptionalFieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        blockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        disable: Command<void, void, any>;
        enable: Command<void, void, any>;
        removeBlockApplications: Command<TypeFromFields<{
            applications: FieldType<TypeFromFields<(...)>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockApplications: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockChannels: Command<TypeFromFields<{
            channelIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockChannels: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindowIndexes: FieldType<number[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        resetPin: Command<void, TypeFromFields<{
            pinCode: FieldType<string>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setBlockContentTimeWindow: Command<TypeFromFields<{
            timeWindow: FieldType<TypeFromFields<{
                dayOfWeek: ...;
                timePeriod: ...;
                timeWindowIndex: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setOnDemandRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                onDemandContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScheduledContentRatingThreshold: Command<TypeFromFields<{
            rating: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduledContentRating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setScreenDailyTime: Command<TypeFromFields<{
            screenTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unblockUnratedContent: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockUnrated: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        updatePin: Command<TypeFromFields<{
            newPin: FieldType<string>;
            oldPin: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinManagement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        enteringBlockContentTimeWindow: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                blockContentTimeWindow: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        remainingScreenTimeExpired: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                screenTime: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    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;
}>, SelectionT>
Inherited from Identity.with
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:33

Interface Complete

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

base

commands

Type declaration

ReadonlyaddBonusTime: Command<TypeFromFields<{ bonusTime: FieldType<number>; pinCode: OptionalFieldType<string>; }>, void, any> & { isConditional: true; mandatoryIf: [] | [{ screenTime: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyblockUnratedContent: Command<void, void, any> & { isConditional: true; mandatoryIf: [] | [{ blockUnrated: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

Readonlydisable: Command<void, void, any>

See

Readonlyenable: Command<void, void, any>

See

ReadonlyremoveBlockChannels: Command<TypeFromFields<{ channelIndexes: FieldType<number[]>; }>, void, any> & { isConditional: true; mandatoryIf: [] | [{ blockChannels: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyremoveBlockContentTimeWindow: Command<TypeFromFields<{ timeWindowIndexes: FieldType<number[]>; }>, void, any> & { isConditional: true; mandatoryIf: [] | [{ blockContentTimeWindow: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyresetPin: Command<void, TypeFromFields<{ pinCode: FieldType<string>; }>, any> & { isConditional: true; mandatoryIf: [] | [{ pinManagement: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlysetOnDemandRatingThreshold: Command<TypeFromFields<{ rating: FieldType<string>; }>, void, any> & { isConditional: true; mandatoryIf: [] | [{ onDemandContentRating: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlysetScheduledContentRatingThreshold: Command<TypeFromFields<{ rating: FieldType<string>; }>, void, any> & { isConditional: true; mandatoryIf: [] | [{ scheduledContentRating: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlysetScreenDailyTime: Command<TypeFromFields<{ screenTime: FieldType<number>; }>, void, any> & { isConditional: true; mandatoryIf: [] | [{ screenTime: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyunblockUnratedContent: Command<void, void, any> & { isConditional: true; mandatoryIf: [] | [{ blockUnrated: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyupdatePin: Command<TypeFromFields<{ newPin: FieldType<string>; oldPin: FieldType<string>; }>, void, any> & { isConditional: true; mandatoryIf: [] | [{ pinManagement: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

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`addBonusTime: Command<TypeFromFields<{
bonusTime: FieldType<number>;
pinCode: OptionalFieldType<string>;
}>, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
screenTime: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`blockUnratedContent: Command<void, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
blockUnrated: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

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

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

`Readonly`removeBlockChannels: Command<TypeFromFields<{
channelIndexes: FieldType<number[]>;
}>, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
blockChannels: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`removeBlockContentTimeWindow: Command<TypeFromFields<{
timeWindowIndexes: FieldType<number[]>;
}>, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
blockContentTimeWindow: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`resetPin: Command<void, TypeFromFields<{
pinCode: FieldType<string>;
}>, any> & {
isConditional: true;
mandatoryIf: [] | [{
pinManagement: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`setOnDemandRatingThreshold: Command<TypeFromFields<{
rating: FieldType<string>;
}>, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
onDemandContentRating: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`setScheduledContentRatingThreshold: Command<TypeFromFields<{
rating: FieldType<string>;
}>, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
scheduledContentRating: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`setScreenDailyTime: Command<TypeFromFields<{
screenTime: FieldType<number>;
}>, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
screenTime: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`unblockUnratedContent: Command<void, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
blockUnrated: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`updatePin: Command<TypeFromFields<{
newPin: FieldType<string>;
oldPin: FieldType<string>;
}>, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
pinManagement: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`blockApplications: BitFlag

`Readonly`blockChannels: BitFlag

`Readonly`blockContentTimeWindow: BitFlag

`Readonly`blockUnrated: BitFlag

`Readonly`onDemandContentRating: BitFlag

`Readonly`pinManagement: BitFlag

`Readonly`scheduledContentRating: BitFlag

`Readonly`screenTime: BitFlag