Interface Complete

This cluster supports all TimeSynchronization features. It may support illegal feature combinations.

If you use this cluster you must manually specify which features are active and ensure the set of active features is legal per the Matter specification.

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

Type declaration

  • ReadonlyacceptedCommandList: Attribute<CommandId[], never>

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

  • ReadonlyattributeList: Attribute<AttributeId[], never>

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

  • ReadonlyclusterRevision: Attribute<number, never>

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

  • ReadonlydefaultNtp: Attribute<null | string, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            ntpClient: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlydstOffset: Attribute<TypeFromFields<{
        offset: FieldType<number>;
        validStarting: FieldType<number | bigint>;
        validUntil: FieldType<null | number | bigint>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlydstOffsetListMaxSize: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{
        ntpClient: BitFlag;
        ntpServer: BitFlag;
        timeSyncClient: BitFlag;
        timeZone: BitFlag;
    }>, never>

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

  • ReadonlygeneratedCommandList: Attribute<CommandId[], never>

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

  • Readonlygranularity: Attribute<TimeSynchronization.Granularity, any>

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

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

    See

    MatterSpecification.v13.Core § 11.17.8.2

  • ReadonlylocalTime: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyntpServerAvailable: Attribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            ntpServer: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlysupportsDnsResolve: FixedAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            ntpClient: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlytimeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>

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

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

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

    See

    MatterSpecification.v13.Core § 11.17.8.3

  • ReadonlytimeZone: Attribute<TypeFromFields<{
        name: OptionalFieldType<string>;
        offset: FieldType<number>;
        validAt: FieldType<number | bigint>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlytimeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlytimeZoneListMaxSize: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlytrustedTimeSource: Attribute<null | TypeFromFields<{
        endpoint: FieldType<EndpointNumber>;
        fabricIndex: FieldType<FabricIndex>;
        nodeId: FieldType<NodeId>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeSyncClient: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyutcTime: Attribute<null | number | bigint, any>

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

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

    See

    MatterSpecification.v13.Core § 11.17.8.1

base

base: undefined

commands

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

Type declaration

  • ReadonlysetDefaultNtp: Command<TypeFromFields<{
        defaultNtp: FieldType<null | string>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            ntpClient: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlysetDstOffset: Command<TypeFromFields<{
        dstOffset: FieldType<TypeFromFields<{
            offset: FieldType<number>;
            validStarting: FieldType<(...) | (...)>;
            validUntil: FieldType<(...) | (...) | (...)>;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlysetTimeZone: Command<TypeFromFields<{
        timeZone: FieldType<TypeFromFields<{
            name: OptionalFieldType<string>;
            offset: FieldType<number>;
            validAt: FieldType<(...) | (...)>;
        }>[]>;
    }>, TypeFromFields<{
        dstOffsetsRequired: FieldType<boolean>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeZone: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlysetTrustedTimeSource: Command<TypeFromFields<{
        fabricIndex: FieldType<FabricIndex>;
        trustedTimeSource: FieldType<null | TypeFromFields<{
            endpoint: FieldType<EndpointNumber>;
            nodeId: FieldType<NodeId>;
        }>>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeSyncClient: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlysetUtcTime: Command<TypeFromFields<{
        granularity: FieldType<TimeSynchronization.Granularity>;
        timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
        utcTime: FieldType<number | bigint>;
    }>, void, any>

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

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

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

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

    See

    MatterSpecification.v13.Core § 11.17.9.1

events

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

Type declaration

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

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

    See

    MatterSpecification.v13.Core § 11.17.10.4

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

extensions

extensions: undefined

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<Branded<56, "ClusterId">, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            defaultNtp: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffset: Attribute<TypeFromFields<{
                offset: FieldType<number>;
                validStarting: FieldType<(...) | (...)>;
                validUntil: FieldType<(...) | (...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffsetListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                ntpClient: BitFlag;
                ntpServer: BitFlag;
                timeSyncClient: BitFlag;
                timeZone: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            localTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            ntpServerAvailable: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpServer: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportsDnsResolve: FixedAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            timeZone: Attribute<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
                validAt: FieldType<(...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            trustedTimeSource: Attribute<null | TypeFromFields<{
                endpoint: FieldType<EndpointNumber>;
                fabricIndex: FieldType<FabricIndex>;
                nodeId: FieldType<NodeId>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setDefaultNtp: Command<TypeFromFields<{
                defaultNtp: FieldType<null | string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setDstOffset: Command<TypeFromFields<{
                dstOffset: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTimeZone: Command<TypeFromFields<{
                timeZone: FieldType<TypeFromFields<(...)>[]>;
            }>, TypeFromFields<{
                dstOffsetsRequired: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTrustedTimeSource: Command<TypeFromFields<{
                fabricIndex: FieldType<FabricIndex>;
                trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            dstStatus: Event<TypeFromFields<{
                dstOffsetActive: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstTableEmpty: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            missingTrustedTimeSource: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeFailure: Event<void, any>;
            timeZoneStatus: Event<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: Branded<56, "ClusterId">;
        name: "TimeSynchronization";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              defaultNtp: Attribute<null | string, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              dstOffset: Attribute<TypeFromFields<{
                  offset: FieldType<number>;
                  validStarting: FieldType<(...) | (...)>;
                  validUntil: FieldType<(...) | (...) | (...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              dstOffsetListMaxSize: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  ntpClient: BitFlag;
                  ntpServer: BitFlag;
                  timeSyncClient: BitFlag;
                  timeZone: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              granularity: Attribute<TimeSynchronization.Granularity, any>;
              localTime: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              ntpServerAvailable: Attribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpServer: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportsDnsResolve: FixedAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
              timeZone: Attribute<TypeFromFields<{
                  name: OptionalFieldType<string>;
                  offset: FieldType<number>;
                  validAt: FieldType<(...) | (...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeZoneListMaxSize: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              trustedTimeSource: Attribute<null | TypeFromFields<{
                  endpoint: FieldType<EndpointNumber>;
                  fabricIndex: FieldType<FabricIndex>;
                  nodeId: FieldType<NodeId>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeSyncClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              utcTime: Attribute<null | number | bigint, any>;
          };
          commands: {
              setDefaultNtp: Command<TypeFromFields<{
                  defaultNtp: FieldType<null | string>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setDstOffset: Command<TypeFromFields<{
                  dstOffset: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setTimeZone: Command<TypeFromFields<{
                  timeZone: FieldType<TypeFromFields<(...)>[]>;
              }>, TypeFromFields<{
                  dstOffsetsRequired: FieldType<boolean>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setTrustedTimeSource: Command<TypeFromFields<{
                  fabricIndex: FieldType<FabricIndex>;
                  trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeSyncClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setUtcTime: Command<TypeFromFields<{
                  granularity: FieldType<TimeSynchronization.Granularity>;
                  timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                  utcTime: FieldType<number | bigint>;
              }>, void, any>;
          };
          events: {
              dstStatus: Event<TypeFromFields<{
                  dstOffsetActive: FieldType<boolean>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              dstTableEmpty: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              missingTrustedTimeSource: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeSyncClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeFailure: Event<void, any>;
              timeZoneStatus: Event<TypeFromFields<{
                  name: OptionalFieldType<string>;
                  offset: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              ntpClient: BitFlag;
              ntpServer: BitFlag;
              timeSyncClient: BitFlag;
              timeZone: BitFlag;
          };
          id: Branded<56, "ClusterId">;
          name: "TimeSynchronization";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            defaultNtp: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffset: Attribute<TypeFromFields<{
                offset: FieldType<number>;
                validStarting: FieldType<(...) | (...)>;
                validUntil: FieldType<(...) | (...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffsetListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                ntpClient: BitFlag;
                ntpServer: BitFlag;
                timeSyncClient: BitFlag;
                timeZone: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            localTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            ntpServerAvailable: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpServer: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportsDnsResolve: FixedAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            timeZone: Attribute<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
                validAt: FieldType<(...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            trustedTimeSource: Attribute<null | TypeFromFields<{
                endpoint: FieldType<EndpointNumber>;
                fabricIndex: FieldType<FabricIndex>;
                nodeId: FieldType<NodeId>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setDefaultNtp: Command<TypeFromFields<{
                defaultNtp: FieldType<null | string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setDstOffset: Command<TypeFromFields<{
                dstOffset: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTimeZone: Command<TypeFromFields<{
                timeZone: FieldType<TypeFromFields<(...)>[]>;
            }>, TypeFromFields<{
                dstOffsetsRequired: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTrustedTimeSource: Command<TypeFromFields<{
                fabricIndex: FieldType<FabricIndex>;
                trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            dstStatus: Event<TypeFromFields<{
                dstOffsetActive: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstTableEmpty: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            missingTrustedTimeSource: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeFailure: Event<void, any>;
            timeZoneStatus: Event<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: Branded<56, "ClusterId">;
        name: "TimeSynchronization";
        revision: 2;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            defaultNtp: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffset: Attribute<TypeFromFields<{
                offset: FieldType<number>;
                validStarting: FieldType<(...) | (...)>;
                validUntil: FieldType<(...) | (...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffsetListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                ntpClient: BitFlag;
                ntpServer: BitFlag;
                timeSyncClient: BitFlag;
                timeZone: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            localTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            ntpServerAvailable: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpServer: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportsDnsResolve: FixedAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            timeZone: Attribute<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
                validAt: FieldType<(...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            trustedTimeSource: Attribute<null | TypeFromFields<{
                endpoint: FieldType<EndpointNumber>;
                fabricIndex: FieldType<FabricIndex>;
                nodeId: FieldType<NodeId>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setDefaultNtp: Command<TypeFromFields<{
                defaultNtp: FieldType<null | string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setDstOffset: Command<TypeFromFields<{
                dstOffset: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTimeZone: Command<TypeFromFields<{
                timeZone: FieldType<TypeFromFields<(...)>[]>;
            }>, TypeFromFields<{
                dstOffsetsRequired: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTrustedTimeSource: Command<TypeFromFields<{
                fabricIndex: FieldType<FabricIndex>;
                trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            dstStatus: Event<TypeFromFields<{
                dstOffsetActive: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstTableEmpty: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            missingTrustedTimeSource: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeFailure: Event<void, any>;
            timeZoneStatus: Event<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: Branded<56, "ClusterId">;
        name: "TimeSynchronization";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              defaultNtp: Attribute<null | string, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              dstOffset: Attribute<TypeFromFields<{
                  offset: FieldType<number>;
                  validStarting: FieldType<(...) | (...)>;
                  validUntil: FieldType<(...) | (...) | (...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              dstOffsetListMaxSize: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  ntpClient: BitFlag;
                  ntpServer: BitFlag;
                  timeSyncClient: BitFlag;
                  timeZone: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              granularity: Attribute<TimeSynchronization.Granularity, any>;
              localTime: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              ntpServerAvailable: Attribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpServer: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportsDnsResolve: FixedAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
              timeZone: Attribute<TypeFromFields<{
                  name: OptionalFieldType<string>;
                  offset: FieldType<number>;
                  validAt: FieldType<(...) | (...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeZoneListMaxSize: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              trustedTimeSource: Attribute<null | TypeFromFields<{
                  endpoint: FieldType<EndpointNumber>;
                  fabricIndex: FieldType<FabricIndex>;
                  nodeId: FieldType<NodeId>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeSyncClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              utcTime: Attribute<null | number | bigint, any>;
          };
          commands: {
              setDefaultNtp: Command<TypeFromFields<{
                  defaultNtp: FieldType<null | string>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setDstOffset: Command<TypeFromFields<{
                  dstOffset: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setTimeZone: Command<TypeFromFields<{
                  timeZone: FieldType<TypeFromFields<(...)>[]>;
              }>, TypeFromFields<{
                  dstOffsetsRequired: FieldType<boolean>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setTrustedTimeSource: Command<TypeFromFields<{
                  fabricIndex: FieldType<FabricIndex>;
                  trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeSyncClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setUtcTime: Command<TypeFromFields<{
                  granularity: FieldType<TimeSynchronization.Granularity>;
                  timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                  utcTime: FieldType<number | bigint>;
              }>, void, any>;
          };
          events: {
              dstStatus: Event<TypeFromFields<{
                  dstOffsetActive: FieldType<boolean>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              dstTableEmpty: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              missingTrustedTimeSource: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeSyncClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeFailure: Event<void, any>;
              timeZoneStatus: Event<TypeFromFields<{
                  name: OptionalFieldType<string>;
                  offset: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              ntpClient: BitFlag;
              ntpServer: BitFlag;
              timeSyncClient: BitFlag;
              timeZone: BitFlag;
          };
          id: Branded<56, "ClusterId">;
          name: "TimeSynchronization";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            defaultNtp: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffset: Attribute<TypeFromFields<{
                offset: FieldType<number>;
                validStarting: FieldType<(...) | (...)>;
                validUntil: FieldType<(...) | (...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffsetListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                ntpClient: BitFlag;
                ntpServer: BitFlag;
                timeSyncClient: BitFlag;
                timeZone: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            localTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            ntpServerAvailable: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpServer: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportsDnsResolve: FixedAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            timeZone: Attribute<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
                validAt: FieldType<(...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            trustedTimeSource: Attribute<null | TypeFromFields<{
                endpoint: FieldType<EndpointNumber>;
                fabricIndex: FieldType<FabricIndex>;
                nodeId: FieldType<NodeId>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setDefaultNtp: Command<TypeFromFields<{
                defaultNtp: FieldType<null | string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setDstOffset: Command<TypeFromFields<{
                dstOffset: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTimeZone: Command<TypeFromFields<{
                timeZone: FieldType<TypeFromFields<(...)>[]>;
            }>, TypeFromFields<{
                dstOffsetsRequired: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTrustedTimeSource: Command<TypeFromFields<{
                fabricIndex: FieldType<FabricIndex>;
                trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            dstStatus: Event<TypeFromFields<{
                dstOffsetActive: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstTableEmpty: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            missingTrustedTimeSource: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeFailure: Event<void, any>;
            timeZoneStatus: Event<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: Branded<56, "ClusterId">;
        name: "TimeSynchronization";
        revision: 2;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            defaultNtp: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffset: Attribute<TypeFromFields<{
                offset: FieldType<number>;
                validStarting: FieldType<(...) | (...)>;
                validUntil: FieldType<(...) | (...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffsetListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                ntpClient: BitFlag;
                ntpServer: BitFlag;
                timeSyncClient: BitFlag;
                timeZone: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            localTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            ntpServerAvailable: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpServer: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportsDnsResolve: FixedAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            timeZone: Attribute<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
                validAt: FieldType<(...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            trustedTimeSource: Attribute<null | TypeFromFields<{
                endpoint: FieldType<EndpointNumber>;
                fabricIndex: FieldType<FabricIndex>;
                nodeId: FieldType<NodeId>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setDefaultNtp: Command<TypeFromFields<{
                defaultNtp: FieldType<null | string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setDstOffset: Command<TypeFromFields<{
                dstOffset: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTimeZone: Command<TypeFromFields<{
                timeZone: FieldType<TypeFromFields<(...)>[]>;
            }>, TypeFromFields<{
                dstOffsetsRequired: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTrustedTimeSource: Command<TypeFromFields<{
                fabricIndex: FieldType<FabricIndex>;
                trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            dstStatus: Event<TypeFromFields<{
                dstOffsetActive: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstTableEmpty: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            missingTrustedTimeSource: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeFailure: Event<void, any>;
            timeZoneStatus: Event<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: Branded<56, "ClusterId">;
        name: "TimeSynchronization";
        revision: 2;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          defaultNtp?: null | string;
          dstOffset?: {
              offset: number;
              validStarting: number | bigint;
              validUntil: null | number | bigint;
          }[];
          dstOffsetListMaxSize?: number;
          granularity: number;
          localTime?: null | number | bigint;
          ntpServerAvailable?: boolean;
          supportsDnsResolve?: boolean;
          timeSource?: number;
          timeZone?: {
              name?: string;
              offset: number;
              validAt: number | bigint;
          }[];
          timeZoneDatabase?: number;
          timeZoneListMaxSize?: number;
          trustedTimeSource?: null | {
              endpoint: number;
              fabricIndex: number;
              nodeId: bigint;
          };
          utcTime: null | number | bigint;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            defaultNtp: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffset: Attribute<TypeFromFields<{
                offset: FieldType<number>;
                validStarting: FieldType<(...) | (...)>;
                validUntil: FieldType<(...) | (...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffsetListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                ntpClient: BitFlag;
                ntpServer: BitFlag;
                timeSyncClient: BitFlag;
                timeZone: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            localTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            ntpServerAvailable: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpServer: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportsDnsResolve: FixedAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            timeZone: Attribute<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
                validAt: FieldType<(...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            trustedTimeSource: Attribute<null | TypeFromFields<{
                endpoint: FieldType<EndpointNumber>;
                fabricIndex: FieldType<FabricIndex>;
                nodeId: FieldType<NodeId>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setDefaultNtp: Command<TypeFromFields<{
                defaultNtp: FieldType<null | string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setDstOffset: Command<TypeFromFields<{
                dstOffset: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTimeZone: Command<TypeFromFields<{
                timeZone: FieldType<TypeFromFields<(...)>[]>;
            }>, TypeFromFields<{
                dstOffsetsRequired: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTrustedTimeSource: Command<TypeFromFields<{
                fabricIndex: FieldType<FabricIndex>;
                trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            dstStatus: Event<TypeFromFields<{
                dstOffsetActive: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstTableEmpty: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            missingTrustedTimeSource: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeFailure: Event<void, any>;
            timeZoneStatus: Event<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: Branded<56, "ClusterId">;
        name: "TimeSynchronization";
        revision: 2;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            defaultNtp: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffset: Attribute<TypeFromFields<{
                offset: FieldType<number>;
                validStarting: FieldType<(...) | (...)>;
                validUntil: FieldType<(...) | (...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffsetListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                ntpClient: BitFlag;
                ntpServer: BitFlag;
                timeSyncClient: BitFlag;
                timeZone: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            localTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            ntpServerAvailable: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpServer: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportsDnsResolve: FixedAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            timeZone: Attribute<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
                validAt: FieldType<(...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            trustedTimeSource: Attribute<null | TypeFromFields<{
                endpoint: FieldType<EndpointNumber>;
                fabricIndex: FieldType<FabricIndex>;
                nodeId: FieldType<NodeId>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setDefaultNtp: Command<TypeFromFields<{
                defaultNtp: FieldType<null | string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setDstOffset: Command<TypeFromFields<{
                dstOffset: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTimeZone: Command<TypeFromFields<{
                timeZone: FieldType<TypeFromFields<(...)>[]>;
            }>, TypeFromFields<{
                dstOffsetsRequired: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTrustedTimeSource: Command<TypeFromFields<{
                fabricIndex: FieldType<FabricIndex>;
                trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            dstStatus: Event<TypeFromFields<{
                dstOffsetActive: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstTableEmpty: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            missingTrustedTimeSource: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeFailure: Event<void, any>;
            timeZoneStatus: Event<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: Branded<56, "ClusterId">;
        name: "TimeSynchronization";
        revision: 2;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              defaultNtp: Attribute<null | string, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              dstOffset: Attribute<TypeFromFields<{
                  offset: FieldType<number>;
                  validStarting: FieldType<(...) | (...)>;
                  validUntil: FieldType<(...) | (...) | (...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              dstOffsetListMaxSize: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  ntpClient: BitFlag;
                  ntpServer: BitFlag;
                  timeSyncClient: BitFlag;
                  timeZone: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              granularity: Attribute<TimeSynchronization.Granularity, any>;
              localTime: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              ntpServerAvailable: Attribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpServer: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportsDnsResolve: FixedAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
              timeZone: Attribute<TypeFromFields<{
                  name: OptionalFieldType<string>;
                  offset: FieldType<number>;
                  validAt: FieldType<(...) | (...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeZoneListMaxSize: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              trustedTimeSource: Attribute<null | TypeFromFields<{
                  endpoint: FieldType<EndpointNumber>;
                  fabricIndex: FieldType<FabricIndex>;
                  nodeId: FieldType<NodeId>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeSyncClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              utcTime: Attribute<null | number | bigint, any>;
          };
          commands: {
              setDefaultNtp: Command<TypeFromFields<{
                  defaultNtp: FieldType<null | string>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      ntpClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setDstOffset: Command<TypeFromFields<{
                  dstOffset: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setTimeZone: Command<TypeFromFields<{
                  timeZone: FieldType<TypeFromFields<(...)>[]>;
              }>, TypeFromFields<{
                  dstOffsetsRequired: FieldType<boolean>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setTrustedTimeSource: Command<TypeFromFields<{
                  fabricIndex: FieldType<FabricIndex>;
                  trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeSyncClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setUtcTime: Command<TypeFromFields<{
                  granularity: FieldType<TimeSynchronization.Granularity>;
                  timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                  utcTime: FieldType<number | bigint>;
              }>, void, any>;
          };
          events: {
              dstStatus: Event<TypeFromFields<{
                  dstOffsetActive: FieldType<boolean>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              dstTableEmpty: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              missingTrustedTimeSource: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeSyncClient: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              timeFailure: Event<void, any>;
              timeZoneStatus: Event<TypeFromFields<{
                  name: OptionalFieldType<string>;
                  offset: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      timeZone: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              ntpClient: BitFlag;
              ntpServer: BitFlag;
              timeSyncClient: BitFlag;
              timeZone: BitFlag;
          };
          id: Branded<56, "ClusterId">;
          name: "TimeSynchronization";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            defaultNtp: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffset: Attribute<TypeFromFields<{
                offset: FieldType<number>;
                validStarting: FieldType<(...) | (...)>;
                validUntil: FieldType<(...) | (...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstOffsetListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                ntpClient: BitFlag;
                ntpServer: BitFlag;
                timeSyncClient: BitFlag;
                timeZone: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            granularity: Attribute<TimeSynchronization.Granularity, any>;
            localTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            ntpServerAvailable: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpServer: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportsDnsResolve: FixedAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeSource: OptionalAttribute<TimeSynchronization.TimeSource, any>;
            timeZone: Attribute<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
                validAt: FieldType<(...) | (...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneDatabase: FixedAttribute<TimeSynchronization.TimeZoneDatabase, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeZoneListMaxSize: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            trustedTimeSource: Attribute<null | TypeFromFields<{
                endpoint: FieldType<EndpointNumber>;
                fabricIndex: FieldType<FabricIndex>;
                nodeId: FieldType<NodeId>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            utcTime: Attribute<null | number | bigint, any>;
        };
        commands: {
            setDefaultNtp: Command<TypeFromFields<{
                defaultNtp: FieldType<null | string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    ntpClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setDstOffset: Command<TypeFromFields<{
                dstOffset: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTimeZone: Command<TypeFromFields<{
                timeZone: FieldType<TypeFromFields<(...)>[]>;
            }>, TypeFromFields<{
                dstOffsetsRequired: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTrustedTimeSource: Command<TypeFromFields<{
                fabricIndex: FieldType<FabricIndex>;
                trustedTimeSource: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUtcTime: Command<TypeFromFields<{
                granularity: FieldType<TimeSynchronization.Granularity>;
                timeSource: OptionalFieldType<TimeSynchronization.TimeSource>;
                utcTime: FieldType<number | bigint>;
            }>, void, any>;
        };
        events: {
            dstStatus: Event<TypeFromFields<{
                dstOffsetActive: FieldType<boolean>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            dstTableEmpty: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            missingTrustedTimeSource: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSyncClient: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            timeFailure: Event<void, any>;
            timeZoneStatus: Event<TypeFromFields<{
                name: OptionalFieldType<string>;
                offset: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeZone: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ntpClient: BitFlag;
            ntpServer: BitFlag;
            timeSyncClient: BitFlag;
            timeZone: BitFlag;
        };
        id: Branded<56, "ClusterId">;
        name: "TimeSynchronization";
        revision: 2;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods