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)

Identity<typeof TimeSynchronization.ClusterInstance>
- Cluster

Index

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

revision

supportedFeatures

supportedFeatures: {}

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
- alterations: AlterationsT
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>
Inherited from Identity.alter
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:82

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
- flags: FlagsT
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>
Inherited from Identity.enable
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:96

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
- values: ValuesT
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>
Inherited from Identity.set
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:89

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
- Rest...selection: SelectionT
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>
Inherited from Identity.with
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:75

Interface Cluster

See

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

Type declaration

Readonlygranularity: Attribute<TimeSynchronization.Granularity, any>

See

ReadonlytimeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>

See

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

See

base

commands

Type declaration

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

See

events

Type declaration

ReadonlytimeFailure: Event<void, any>

See

extensions

features

Type declaration

ReadonlyntpClient: BitFlag

See

ReadonlyntpServer: BitFlag

See

ReadonlytimeSyncClient: BitFlag

See

ReadonlytimeZone: BitFlag

See

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page

`Readonly`granularity: Attribute<TimeSynchronization.Granularity, any>

`Readonly`timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>

`Readonly`utcTime: Attribute<null | number | bigint, any>

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

`Readonly`timeFailure: Event<void, any>

`Readonly`ntpClient: BitFlag

`Readonly`ntpServer: BitFlag

`Readonly`timeSyncClient: BitFlag

`Readonly`timeZone: BitFlag