Interface Cluster

Accurate time is required for a number of reasons, including scheduling, display and validating security materials.

This section describes a mechanism for Nodes to achieve and maintain time synchronization. The Time Synchronization cluster provides attributes for reading a Node’s current time. It also allows Administrators to set current time, time zone and daylight savings time (DST) settings.

The Time Synchronization cluster may be present on the root node endpoint, and shall NOT be present on any other Endpoint of any Node.

TimeSynchronizationCluster supports optional features that you can enable with the TimeSynchronizationCluster.with() factory method.

See

MatterSpecification.v13.Core § 11.17

interface Cluster {
    attributes: Merge<{
        granularity: Attribute<TimeSynchronization.Granularity, any>;
        timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
        utcTime: Attribute<null | number | bigint, any>;
    }, GlobalAttributes<{
        ntpClient: BitFlag;
        ntpServer: BitFlag;
        timeSyncClient: BitFlag;
        timeZone: BitFlag;
    }>>;
    base: undefined;
    commands: {
        setUtcTime: Command<TypeFromFields<{
            granularity: FieldType<TimeSynchronization.Granularity>;
            timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
            utcTime: FieldType<number | bigint>;
        }>, void, any>;
    };
    events: {
        timeFailure: Event<void, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                trustedTimeSource: Attribute<null | TypeFromFields<{
                    endpoint: FieldType<EndpointNumber>;
                    fabricIndex: FieldType<FabricIndex>;
                    nodeId: FieldType<NodeId>;
                }>, any>;
            };
            commands: {
                setTrustedTimeSource: Command<TypeFromFields<{
                    fabricIndex: FieldType<FabricIndex>;
                    trustedTimeSource: FieldType<null | TypeFromFields<{
                        endpoint: ...;
                        nodeId: ...;
                    }>>;
                }>, void, any>;
            };
            events: {
                missingTrustedTimeSource: Event<void, any>;
            };
        };
        flags: {
            timeSyncClient: true;
        };
    }, {
        component: {
            attributes: {
                defaultNtp: Attribute<null | string, any>;
                supportsDnsResolve: FixedAttribute<boolean, any>;
            };
            commands: {
                setDefaultNtp: Command<TypeFromFields<{
                    defaultNtp: FieldType<null | string>;
                }>, void, any>;
            };
        };
        flags: {
            ntpClient: true;
        };
    }, {
        component: {
            attributes: {
                dstOffset: Attribute<TypeFromFields<{
                    offset: FieldType<number>;
                    validStarting: FieldType<number | bigint>;
                    validUntil: FieldType<null | number | bigint>;
                }>[], any>;
                dstOffsetListMaxSize: FixedAttribute<number, any>;
                localTime: Attribute<null | number | bigint, any>;
                timeZone: Attribute<TypeFromFields<{
                    name: OptionalFieldType<string>;
                    offset: FieldType<number>;
                    validAt: FieldType<number | bigint>;
                }>[], any>;
                timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                timeZoneListMaxSize: FixedAttribute<number, any>;
            };
            commands: {
                setDstOffset: Command<TypeFromFields<{
                    dstOffset: FieldType<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[]>;
                }>, void, any>;
                setTimeZone: Command<TypeFromFields<{
                    timeZone: FieldType<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[]>;
                }>, TypeFromFields<{
                    dstOffsetsRequired: FieldType<boolean>;
                }>, any>;
            };
            events: {
                dstStatus: Event<TypeFromFields<{
                    dstOffsetActive: FieldType<boolean>;
                }>, any>;
                dstTableEmpty: Event<void, any>;
                timeZoneStatus: Event<TypeFromFields<{
                    name: OptionalFieldType<string>;
                    offset: FieldType<number>;
                }>, any>;
            };
        };
        flags: {
            timeZone: true;
        };
    }, {
        component: {
            attributes: {
                ntpServerAvailable: Attribute<boolean, any>;
            };
        };
        flags: {
            ntpServer: true;
        };
    }];
    features: {
        ntpClient: BitFlag;
        ntpServer: BitFlag;
        timeSyncClient: BitFlag;
        timeZone: BitFlag;
    };
    id: Branded<56, "ClusterId">;
    name: "TimeSynchronization";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, 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<{
    granularity: Attribute<TimeSynchronization.Granularity, any>;
    timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
    utcTime: Attribute<null | number | bigint, any>;
}, GlobalAttributes<{
    ntpClient: BitFlag;
    ntpServer: BitFlag;
    timeSyncClient: BitFlag;
    timeZone: BitFlag;
}>>

Type declaration

  • 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

  • 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

  • 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

base

base: undefined

commands

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

Type declaration

  • 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

events

events: {
    timeFailure: Event<void, any>;
}

Type declaration

  • 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

extensions

extensions: readonly [{
    component: {
        attributes: {
            trustedTimeSource: Attribute<null | TypeFromFields<{
                endpoint: FieldType<EndpointNumber>;
                fabricIndex: FieldType<FabricIndex>;
                nodeId: FieldType<NodeId>;
            }>, any>;
        };
        commands: {
            setTrustedTimeSource: Command<TypeFromFields<{
                fabricIndex: FieldType<FabricIndex>;
                trustedTimeSource: FieldType<null | TypeFromFields<{
                    endpoint: ...;
                    nodeId: ...;
                }>>;
            }>, void, any>;
        };
        events: {
            missingTrustedTimeSource: Event<void, any>;
        };
    };
    flags: {
        timeSyncClient: true;
    };
}, {
    component: {
        attributes: {
            defaultNtp: Attribute<null | string, any>;
            supportsDnsResolve: FixedAttribute<boolean, any>;
        };
        commands: {
            setDefaultNtp: Command<TypeFromFields<{
                defaultNtp: FieldType<null | string>;
            }>, void, any>;
        };
    };
    flags: {
        ntpClient: true;
    };
}, {
    component: {
        attributes: {
            dstOffset: Attribute<TypeFromFields<{
                offset: FieldType<number>;
                validStarting: FieldType<number | bigint>;
                validUntil: FieldType<null | number | bigint>;
            }>[], any>;
            dstOffsetListMaxSize: FixedAttribute<number, any>;
            localTime: Attribute<null | number | bigint, any>;
            timeZone: Attribute<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
                validAt: FieldType<number | bigint>;
            }>[], any>;
            timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
            timeZoneListMaxSize: FixedAttribute<number, any>;
        };
        commands: {
            setDstOffset: Command<TypeFromFields<{
                dstOffset: FieldType<TypeFromFields<{
                    offset: ...;
                    validStarting: ...;
                    validUntil: ...;
                }>[]>;
            }>, void, any>;
            setTimeZone: Command<TypeFromFields<{
                timeZone: FieldType<TypeFromFields<{
                    name: ...;
                    offset: ...;
                    validAt: ...;
                }>[]>;
            }>, TypeFromFields<{
                dstOffsetsRequired: FieldType<boolean>;
            }>, any>;
        };
        events: {
            dstStatus: Event<TypeFromFields<{
                dstOffsetActive: FieldType<boolean>;
            }>, any>;
            dstTableEmpty: Event<void, any>;
            timeZoneStatus: Event<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
            }>, any>;
        };
    };
    flags: {
        timeZone: true;
    };
}, {
    component: {
        attributes: {
            ntpServerAvailable: Attribute<boolean, any>;
        };
    };
    flags: {
        ntpServer: true;
    };
}]

features

features: {
    ntpClient: BitFlag;
    ntpServer: BitFlag;
    timeSyncClient: BitFlag;
    timeZone: BitFlag;
}

Type declaration

  • 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

id

id: Branded<56, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              granularity: Attribute<TimeSynchronization.Granularity, any>;
              timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
              utcTime: Attribute<null | number | bigint, any>;
          };
          commands: {
              setUtcTime: Command<TypeFromFields<{
                  granularity: FieldType<TimeSynchronization.Granularity>;
                  timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                  utcTime: FieldType<number | bigint>;
              }>, void, any>;
          };
          events: {
              timeFailure: Event<void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      trustedTimeSource: Attribute<null | TypeFromFields<{
                          endpoint: ...;
                          fabricIndex: ...;
                          nodeId: ...;
                      }>, any>;
                  };
                  commands: {
                      setTrustedTimeSource: Command<TypeFromFields<{
                          fabricIndex: FieldType<(...)>;
                          trustedTimeSource: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      missingTrustedTimeSource: Event<void, any>;
                  };
              };
              flags: {
                  timeSyncClient: true;
              };
          }, {
              component: {
                  attributes: {
                      defaultNtp: Attribute<null | string, any>;
                      supportsDnsResolve: FixedAttribute<boolean, any>;
                  };
                  commands: {
                      setDefaultNtp: Command<TypeFromFields<{
                          defaultNtp: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  ntpClient: true;
              };
          }, {
              component: {
                  attributes: {
                      dstOffset: Attribute<TypeFromFields<{
                          offset: ...;
                          validStarting: ...;
                          validUntil: ...;
                      }>[], any>;
                      dstOffsetListMaxSize: FixedAttribute<number, any>;
                      localTime: Attribute<null | number | bigint, any>;
                      timeZone: Attribute<TypeFromFields<{
                          name: ...;
                          offset: ...;
                          validAt: ...;
                      }>[], any>;
                      timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                      timeZoneListMaxSize: FixedAttribute<number, any>;
                  };
                  commands: {
                      setDstOffset: Command<TypeFromFields<{
                          dstOffset: FieldType<(...)>;
                      }>, void, any>;
                      setTimeZone: Command<TypeFromFields<{
                          timeZone: FieldType<(...)>;
                      }>, TypeFromFields<{
                          dstOffsetsRequired: FieldType<(...)>;
                      }>, any>;
                  };
                  events: {
                      dstStatus: Event<TypeFromFields<{
                          dstOffsetActive: FieldType<(...)>;
                      }>, any>;
                      dstTableEmpty: Event<void, any>;
                      timeZoneStatus: Event<TypeFromFields<{
                          name: OptionalFieldType<(...)>;
                          offset: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  timeZone: true;
              };
          }, {
              component: {
                  attributes: {
                      ntpServerAvailable: Attribute<boolean, any>;
                  };
              };
              flags: {
                  ntpServer: true;
              };
          }];
          features: {
              ntpClient: BitFlag;
              ntpServer: BitFlag;
              timeSyncClient: BitFlag;
              timeZone: BitFlag;
          };
          id: 56;
          name: "TimeSynchronization";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              granularity: Attribute<TimeSynchronization.Granularity, any>;
              timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
              utcTime: Attribute<null | number | bigint, any>;
          };
          commands: {
              setUtcTime: Command<TypeFromFields<{
                  granularity: FieldType<TimeSynchronization.Granularity>;
                  timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                  utcTime: FieldType<number | bigint>;
              }>, void, any>;
          };
          events: {
              timeFailure: Event<void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      trustedTimeSource: Attribute<null | TypeFromFields<{
                          endpoint: ...;
                          fabricIndex: ...;
                          nodeId: ...;
                      }>, any>;
                  };
                  commands: {
                      setTrustedTimeSource: Command<TypeFromFields<{
                          fabricIndex: FieldType<(...)>;
                          trustedTimeSource: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      missingTrustedTimeSource: Event<void, any>;
                  };
              };
              flags: {
                  timeSyncClient: true;
              };
          }, {
              component: {
                  attributes: {
                      defaultNtp: Attribute<null | string, any>;
                      supportsDnsResolve: FixedAttribute<boolean, any>;
                  };
                  commands: {
                      setDefaultNtp: Command<TypeFromFields<{
                          defaultNtp: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  ntpClient: true;
              };
          }, {
              component: {
                  attributes: {
                      dstOffset: Attribute<TypeFromFields<{
                          offset: ...;
                          validStarting: ...;
                          validUntil: ...;
                      }>[], any>;
                      dstOffsetListMaxSize: FixedAttribute<number, any>;
                      localTime: Attribute<null | number | bigint, any>;
                      timeZone: Attribute<TypeFromFields<{
                          name: ...;
                          offset: ...;
                          validAt: ...;
                      }>[], any>;
                      timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                      timeZoneListMaxSize: FixedAttribute<number, any>;
                  };
                  commands: {
                      setDstOffset: Command<TypeFromFields<{
                          dstOffset: FieldType<(...)>;
                      }>, void, any>;
                      setTimeZone: Command<TypeFromFields<{
                          timeZone: FieldType<(...)>;
                      }>, TypeFromFields<{
                          dstOffsetsRequired: FieldType<(...)>;
                      }>, any>;
                  };
                  events: {
                      dstStatus: Event<TypeFromFields<{
                          dstOffsetActive: FieldType<(...)>;
                      }>, any>;
                      dstTableEmpty: Event<void, any>;
                      timeZoneStatus: Event<TypeFromFields<{
                          name: OptionalFieldType<(...)>;
                          offset: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  timeZone: true;
              };
          }, {
              component: {
                  attributes: {
                      ntpServerAvailable: Attribute<boolean, any>;
                  };
              };
              flags: {
                  ntpServer: true;
              };
          }];
          features: {
              ntpClient: BitFlag;
              ntpServer: BitFlag;
              timeSyncClient: BitFlag;
              timeZone: BitFlag;
          };
          id: 56;
          name: "TimeSynchronization";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          granularity: number;
          timeSource?: number;
          utcTime: null | number | bigint;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              granularity: Attribute<TimeSynchronization.Granularity, any>;
              timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
              utcTime: Attribute<null | number | bigint, any>;
          };
          commands: {
              setUtcTime: Command<TypeFromFields<{
                  granularity: FieldType<TimeSynchronization.Granularity>;
                  timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                  utcTime: FieldType<number | bigint>;
              }>, void, any>;
          };
          events: {
              timeFailure: Event<void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      trustedTimeSource: Attribute<null | TypeFromFields<{
                          endpoint: ...;
                          fabricIndex: ...;
                          nodeId: ...;
                      }>, any>;
                  };
                  commands: {
                      setTrustedTimeSource: Command<TypeFromFields<{
                          fabricIndex: FieldType<(...)>;
                          trustedTimeSource: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      missingTrustedTimeSource: Event<void, any>;
                  };
              };
              flags: {
                  timeSyncClient: true;
              };
          }, {
              component: {
                  attributes: {
                      defaultNtp: Attribute<null | string, any>;
                      supportsDnsResolve: FixedAttribute<boolean, any>;
                  };
                  commands: {
                      setDefaultNtp: Command<TypeFromFields<{
                          defaultNtp: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  ntpClient: true;
              };
          }, {
              component: {
                  attributes: {
                      dstOffset: Attribute<TypeFromFields<{
                          offset: ...;
                          validStarting: ...;
                          validUntil: ...;
                      }>[], any>;
                      dstOffsetListMaxSize: FixedAttribute<number, any>;
                      localTime: Attribute<null | number | bigint, any>;
                      timeZone: Attribute<TypeFromFields<{
                          name: ...;
                          offset: ...;
                          validAt: ...;
                      }>[], any>;
                      timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                      timeZoneListMaxSize: FixedAttribute<number, any>;
                  };
                  commands: {
                      setDstOffset: Command<TypeFromFields<{
                          dstOffset: FieldType<(...)>;
                      }>, void, any>;
                      setTimeZone: Command<TypeFromFields<{
                          timeZone: FieldType<(...)>;
                      }>, TypeFromFields<{
                          dstOffsetsRequired: FieldType<(...)>;
                      }>, any>;
                  };
                  events: {
                      dstStatus: Event<TypeFromFields<{
                          dstOffsetActive: FieldType<(...)>;
                      }>, any>;
                      dstTableEmpty: Event<void, any>;
                      timeZoneStatus: Event<TypeFromFields<{
                          name: OptionalFieldType<(...)>;
                          offset: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  timeZone: true;
              };
          }, {
              component: {
                  attributes: {
                      ntpServerAvailable: Attribute<boolean, any>;
                  };
              };
              flags: {
                  ntpServer: true;
              };
          }];
          features: {
              ntpClient: BitFlag;
              ntpServer: BitFlag;
              timeSyncClient: BitFlag;
              timeZone: BitFlag;
          };
          id: 56;
          name: "TimeSynchronization";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            timeFailure: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    trustedTimeSource: Attribute<null | TypeFromFields<{
                        endpoint: ...;
                        fabricIndex: ...;
                        nodeId: ...;
                    }>, any>;
                };
                commands: {
                    setTrustedTimeSource: Command<TypeFromFields<{
                        fabricIndex: FieldType<(...)>;
                        trustedTimeSource: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    missingTrustedTimeSource: Event<void, any>;
                };
            };
            flags: {
                timeSyncClient: true;
            };
        }, {
            component: {
                attributes: {
                    defaultNtp: Attribute<null | string, any>;
                    supportsDnsResolve: FixedAttribute<boolean, any>;
                };
                commands: {
                    setDefaultNtp: Command<TypeFromFields<{
                        defaultNtp: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                ntpClient: true;
            };
        }, {
            component: {
                attributes: {
                    dstOffset: Attribute<TypeFromFields<{
                        offset: ...;
                        validStarting: ...;
                        validUntil: ...;
                    }>[], any>;
                    dstOffsetListMaxSize: FixedAttribute<number, any>;
                    localTime: Attribute<null | number | bigint, any>;
                    timeZone: Attribute<TypeFromFields<{
                        name: ...;
                        offset: ...;
                        validAt: ...;
                    }>[], any>;
                    timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any>;
                    timeZoneListMaxSize: FixedAttribute<number, any>;
                };
                commands: {
                    setDstOffset: Command<TypeFromFields<{
                        dstOffset: FieldType<(...)>;
                    }>, void, any>;
                    setTimeZone: Command<TypeFromFields<{
                        timeZone: FieldType<(...)>;
                    }>, TypeFromFields<{
                        dstOffsetsRequired: FieldType<(...)>;
                    }>, any>;
                };
                events: {
                    dstStatus: Event<TypeFromFields<{
                        dstOffsetActive: FieldType<(...)>;
                    }>, any>;
                    dstTableEmpty: Event<void, any>;
                    timeZoneStatus: Event<TypeFromFields<{
                        name: OptionalFieldType<(...)>;
                        offset: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                timeZone: true;
            };
        }, {
            component: {
                attributes: {
                    ntpServerAvailable: Attribute<boolean, any>;
                };
            };
            flags: {
                ntpServer: true;
            };
        }];
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: 56;
        name: "TimeSynchronization";
        revision: 2;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods