Variable CompleteInstanceConst

Type declaration

• Readonlyattributes: {
      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<(...)>[]>;
          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>;
      };
  }

  • 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<(...)>[]>;
        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>;
    }

• Readonlycommands: {
      addBlockApplications: Command<TypeFromFields<{
          applications: FieldType<TypeFromFields<{
              applicationId: ...;
              catalogVendorId: ...;
          }>[]>;
      }>, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              blockApplications: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      addBlockChannels: Command<TypeFromFields<{
          channels: FieldType<TypeFromFields<{
              blockChannelIndex: ...;
              identifier: ...;
              majorNumber: ...;
              minorNumber: ...;
          }>[]>;
      }>, 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: ...;
              catalogVendorId: ...;
          }>[]>;
      }>, 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<(...)>;
              timePeriod: FieldType<(...)>;
              timeWindowIndex: FieldType<(...)>;
          }>>;
      }>, 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>;
      };
  }

  • ReadonlyaddBlockApplications: Command<TypeFromFields<{
        applications: FieldType<TypeFromFields<{
            applicationId: ...;
            catalogVendorId: ...;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockApplications: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyaddBlockChannels: Command<TypeFromFields<{
        channels: FieldType<TypeFromFields<{
            blockChannelIndex: ...;
            identifier: ...;
            majorNumber: ...;
            minorNumber: ...;
        }>[]>;
    }>, 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: ...;
            catalogVendorId: ...;
        }>[]>;
    }>, 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<(...)>;
            timePeriod: FieldType<(...)>;
            timeWindowIndex: FieldType<(...)>;
        }>>;
    }>, 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>;
    }

• Readonlyevents: {
      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>;
      };
  }

  • ReadonlyenteringBlockContentTimeWindow: Event<void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            blockContentTimeWindow: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyremainingScreenTimeExpired: Event<void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            screenTime: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

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

  • 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.

• Readonlyid: Branded<1295, "ClusterId">

• Readonlyname: "ContentControl"

• Readonlyrevision: 1