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)

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;
}>>

Type declaration

  • ReadonlyacceptedCommandList: Attribute<CommandId[], never>

    List of client generated commands which are supported by this cluster server instance.

  • ReadonlyattributeList: Attribute<AttributeId[], never>

    List of the attribute IDs of the attributes supported by the cluster instance.

  • ReadonlyblockApplicationList: Attribute<TypeFromFields<{
        applicationId: FieldType<string>;
        catalogVendorId: FieldType<number>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockApplications: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyblockChannelList: 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>;
    }
  • ReadonlyblockContentTimeWindow: 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>;
    }
  • ReadonlyblockUnrated: Attribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockUnrated: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyclusterRevision: Attribute<number, never>

    Indicates the revision of the server cluster specification supported by the cluster instance.

  • Readonlyenabled: Attribute<boolean, any>

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

    See

    MatterSpecification.v13.Cluster § 6.13.7.1

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{
        blockApplications: BitFlag;
        blockChannels: BitFlag;
        blockContentTimeWindow: BitFlag;
        blockUnrated: BitFlag;
        onDemandContentRating: BitFlag;
        pinManagement: BitFlag;
        scheduledContentRating: BitFlag;
        screenTime: BitFlag;
    }>, never>

    Indicates whether the server supports zero or more optional cluster features.

  • ReadonlygeneratedCommandList: Attribute<CommandId[], never>

    List of server generated commands (server to client commands).

  • ReadonlyonDemandRatings: Attribute<TypeFromFields<{
        ratingName: FieldType<string>;
        ratingNameDesc: OptionalFieldType<string>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            onDemandContentRating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyonDemandRatingThreshold: Attribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            onDemandContentRating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyremainingScreenTime: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            screenTime: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyscheduledContentRatings: Attribute<TypeFromFields<{
        ratingName: FieldType<string>;
        ratingNameDesc: OptionalFieldType<string>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduledContentRating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyscheduledContentRatingThreshold: Attribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduledContentRating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyscreenDailyTime: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            screenTime: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

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

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

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

    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>

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

    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>

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

    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>

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

    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>

Settings

Member Visibility

On This Page

Properties
Methods