Variable CompleteInstanceConst

Type declaration

• Readonlyattributes: {
      acceptedCommandList: Attribute<CommandId[], never>;
      attributeList: Attribute<AttributeId[], never>;
      clusterRevision: Attribute<number, never>;
      defaultNtp: Attribute<null | string, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              ntpClient: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      dstOffset: Attribute<TypeFromFields<{
          offset: FieldType<number>;
          validStarting: FieldType<number | bigint>;
          validUntil: FieldType<null | number | bigint>;
      }>[], any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      dstOffsetListMaxSize: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      featureMap: Attribute<TypeFromPartialBitSchema<{
          ntpClient: BitFlag;
          ntpServer: BitFlag;
          timeSyncClient: BitFlag;
          timeZone: BitFlag;
      }>, never>;
      generatedCommandList: Attribute<CommandId[], never>;
      granularity: Attribute<TimeSynchronization.Granularity, any>;
      localTime: Attribute<null | number | bigint, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      ntpServerAvailable: Attribute<boolean, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              ntpServer: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      supportsDnsResolve: FixedAttribute<boolean, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              ntpClient: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
      timeZone: Attribute<TypeFromFields<{
          name: OptionalFieldType<string>;
          offset: FieldType<number>;
          validAt: FieldType<number | bigint>;
      }>[], any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      timeZoneListMaxSize: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      trustedTimeSource: Attribute<null | TypeFromFields<{
          endpoint: FieldType<EndpointNumber>;
          fabricIndex: FieldType<FabricIndex>;
          nodeId: FieldType<NodeId>;
      }>, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeSyncClient: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      utcTime: Attribute<null | number | bigint, any>;
  }

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

  • ReadonlyclusterRevision: Attribute<number, never>

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

  • ReadonlydefaultNtp: Attribute<null | string, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            ntpClient: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlydstOffset: Attribute<TypeFromFields<{
        offset: FieldType<number>;
        validStarting: FieldType<number | bigint>;
        validUntil: FieldType<null | number | bigint>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlydstOffsetListMaxSize: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{
        ntpClient: BitFlag;
        ntpServer: BitFlag;
        timeSyncClient: BitFlag;
        timeZone: 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).

  • Readonlygranularity: Attribute<TimeSynchronization.Granularity, any>

    The granularity of the error that the node is willing to guarantee on the time synchronization. It is of type GranularityEnum.

    This value shall be set to NoTimeGranularity if UTCTime is null and shall NOT be set to NoTimeGranularity if UTCTime is non-null.

    See

    MatterSpecification.v13.Core § 11.17.8.2

  • ReadonlylocalTime: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyntpServerAvailable: Attribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            ntpServer: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlysupportsDnsResolve: FixedAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            ntpClient: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlytimeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>

    The node’s time source. This attribute indicates what method the node is using to sync, whether the source uses NTS or not and whether the source is internal or external to the Matter network. This attribute may be used by a client to determine its level of trust in the UTCTime. It is of type TimeSourceEnum.

    If a node is unsure if the selected NTP server is within the Matter network, it SHOULD select one of the NonMatter* values.

    This value shall be set to None if UTCTime is null and shall NOT be set to None if UTCTime is non-null.

    See

    MatterSpecification.v13.Core § 11.17.8.3

  • ReadonlytimeZone: Attribute<TypeFromFields<{
        name: OptionalFieldType<string>;
        offset: FieldType<number>;
        validAt: FieldType<number | bigint>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlytimeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlytimeZoneListMaxSize: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlytrustedTimeSource: Attribute<null | TypeFromFields<{
        endpoint: FieldType<EndpointNumber>;
        fabricIndex: FieldType<FabricIndex>;
        nodeId: FieldType<NodeId>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeSyncClient: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyutcTime: Attribute<null | number | bigint, any>

    If the node has achieved time synchronization, this shall indicate the current time as a UTC epoch-us (Epoch Time in Microseconds).

    If the node has not achieved time synchronization, this shall be null. This attribute may be set when a SetUTCTime is received.

    See

    MatterSpecification.v13.Core § 11.17.8.1

• Readonlycommands: {
      setDefaultNtp: Command<TypeFromFields<{
          defaultNtp: FieldType<null | string>;
      }>, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              ntpClient: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      setDstOffset: Command<TypeFromFields<{
          dstOffset: FieldType<TypeFromFields<{
              offset: ...;
              validStarting: ...;
              validUntil: ...;
          }>[]>;
      }>, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      setTimeZone: Command<TypeFromFields<{
          timeZone: FieldType<TypeFromFields<{
              name: ...;
              offset: ...;
              validAt: ...;
          }>[]>;
      }>, TypeFromFields<{
          dstOffsetsRequired: FieldType<boolean>;
      }>, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      setTrustedTimeSource: Command<TypeFromFields<{
          fabricIndex: FieldType<FabricIndex>;
          trustedTimeSource: FieldType<null | TypeFromFields<{
              endpoint: ...;
              nodeId: ...;
          }>>;
      }>, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeSyncClient: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      setUtcTime: Command<TypeFromFields<{
          granularity: FieldType<TimeSynchronization.Granularity>;
          timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
          utcTime: FieldType<number | bigint>;
      }>, void, any>;
  }

  • ReadonlysetDefaultNtp: Command<TypeFromFields<{
        defaultNtp: FieldType<null | string>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            ntpClient: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlysetDstOffset: Command<TypeFromFields<{
        dstOffset: FieldType<TypeFromFields<{
            offset: ...;
            validStarting: ...;
            validUntil: ...;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlysetTimeZone: Command<TypeFromFields<{
        timeZone: FieldType<TypeFromFields<{
            name: ...;
            offset: ...;
            validAt: ...;
        }>[]>;
    }>, TypeFromFields<{
        dstOffsetsRequired: FieldType<boolean>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlysetTrustedTimeSource: Command<TypeFromFields<{
        fabricIndex: FieldType<FabricIndex>;
        trustedTimeSource: FieldType<null | TypeFromFields<{
            endpoint: ...;
            nodeId: ...;
        }>>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeSyncClient: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlysetUtcTime: Command<TypeFromFields<{
        granularity: FieldType<TimeSynchronization.Granularity>;
        timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
        utcTime: FieldType<number | bigint>;
    }>, void, any>

    This command may be issued by Administrator to set the time. If the Commissioner does not have a valid time source, it may send a Granularity of NoTimeGranularity.

    Upon receipt of this command, the node may update its UTCTime attribute to match the time specified in the command, if the stated Granularity and TimeSource are acceptable. The node shall update its UTCTime attribute if its current Granularity is NoTimeGranularity.

    If the time is updated, the node shall also update its Granularity attribute based on the granularity specified in the command and the expected clock drift of the node. This SHOULD normally be one level lower than the stated command Granularity. It shall also update its TimeSource attribute to Admin. It shall also update its Last Known Good UTC Time as defined in Section 3.5.6.1, “Last Known Good UTC Time”.

    If the node updates its UTCTime attribute, it shall accept the command with a status code of SUCCESS. If it opts to not update its time, it shall fail the command with a cluster specific Status Code of TimeNotAccepted.

    See

    MatterSpecification.v13.Core § 11.17.9.1

• Readonlyevents: {
      dstStatus: Event<TypeFromFields<{
          dstOffsetActive: FieldType<boolean>;
      }>, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      dstTableEmpty: Event<void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      missingTrustedTimeSource: Event<void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeSyncClient: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      timeFailure: Event<void, any>;
      timeZoneStatus: Event<TypeFromFields<{
          name: OptionalFieldType<string>;
          offset: FieldType<number>;
      }>, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              timeZone: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
  }

  • ReadonlydstStatus: Event<TypeFromFields<{
        dstOffsetActive: FieldType<boolean>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

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

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

  • ReadonlytimeFailure: Event<void, any>

    This event shall be generated if the node has not generated a TimeFailure event in the last hour, and the node is unable to get a time from any source. This event SHOULD NOT be generated more often than once per hour.

    See

    MatterSpecification.v13.Core § 11.17.10.4

  • ReadonlytimeZoneStatus: Event<TypeFromFields<{
        name: OptionalFieldType<string>;
        offset: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

• Readonlyfeatures: {
      ntpClient: BitFlag;
      ntpServer: BitFlag;
      timeSyncClient: BitFlag;
      timeZone: BitFlag;
  }

  • ReadonlyntpClient: BitFlag

    NtpClient

    Allows a node to use NTP/SNTP for time synchronization.

    See

    MatterSpecification.v13.Core § 11.17.5.2

  • ReadonlyntpServer: BitFlag

    NtpServer

    Allows a Node to host an NTP server for the network so that other Nodes can achieve a high accuracy time synchronization within the network. See Section 11.17.15, “Acting as an NTP Server”.

    See

    MatterSpecification.v13.Core § 11.17.5.3

  • ReadonlytimeSyncClient: BitFlag

    TimeSyncClient

    This node also supports a time synchronization client and can connect to and read time from other nodes.

    See

    MatterSpecification.v13.Core § 11.17.5.4

  • ReadonlytimeZone: BitFlag

    TimeZone

    Allows a server to translate a UTC time to a local time using the time zone and daylight savings time (DST) offsets. If a server supports the TimeZone feature, it shall support the SetTimeZone and SetDSTOffset commands, and TimeZone and DSTOffset attributes, and shall expose the local time through the LocalTime attribute.

    See

    MatterSpecification.v13.Core § 11.17.5.1

• Readonlyid: Branded<56, "ClusterId">

• Readonlyname: "TimeSynchronization"

• Readonlyrevision: 2