This is the default server implementation of DoorLockBehavior.

Hierarchy (view full)

Constructors

Properties

[reference]: Datasource<StateType>
agent: Agent
cluster: never

The implemented cluster.

context: ActionContext
endpoint: Endpoint<Empty>
events: EventEmitter & Omit<ClusterEvents<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior>, never> & {
    actuatorEnabled$Changing: ClusterEvents.AttributeObservable<Attribute<boolean, any>>;
    lockState$Changing: ClusterEvents.AttributeObservable<Attribute<null | DoorLock.LockState, any>>;
    lockType$Changing: ClusterEvents.AttributeObservable<Attribute<DoorLock.LockType, any>>;
    operatingMode$Changing: ClusterEvents.AttributeObservable<WritableAttribute<DoorLock.OperatingMode, any>>;
    supportedOperatingModes$Changing: ClusterEvents.AttributeObservable<FixedAttribute<TypeFromPartialBitSchema<{
        noRemoteLockUnlock: BitFlag;
        normal: BitFlag;
        passage: BitFlag;
        privacy: BitFlag;
        vacation: BitFlag;
    }>, any>>;
} & {
    alarmMask$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<TypeFromPartialBitSchema<{
        doorForcedOpen: BitFlag;
        frontEscutcheonRemoved: BitFlag;
        lockFactoryReset: BitFlag;
        lockJammed: BitFlag;
        lockRadioPowerCycled: BitFlag;
        na: BitFlag;
        wrongCodeEntryLimit: BitFlag;
    }>, any>>;
    autoRelockTime$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<number, any>>;
    defaultConfigurationRegister$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<TypeFromPartialBitSchema<{
        autoRelockTime: BitFlag;
        keypadInterface: BitFlag;
        ledSettings: BitFlag;
        localProgramming: BitFlag;
        remoteInterface: BitFlag;
        soundVolume: BitFlag;
    }>, any>>;
    enableInsideStatusLed$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<boolean, any>>;
    enableLocalProgramming$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<boolean, any>>;
    enableOneTouchLocking$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<boolean, any>>;
    enablePrivacyModeButton$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<boolean, any>>;
    language$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<string, any>>;
    ledSettings$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<DoorLock.LedSetting, any>>;
    localProgrammingFeatures$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<TypeFromPartialBitSchema<{
        addUsersCredentialsSchedules: BitFlag;
        adjustSettings: BitFlag;
        clearUsersCredentialsSchedules: BitFlag;
        modifyUsersCredentialsSchedules: BitFlag;
    }>, any>>;
    soundVolume$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<DoorLock.SoundVolume, any>>;
} & {
    actuatorEnabled$Changed: ClusterEvents.AttributeObservable<Attribute<boolean, any>>;
    lockState$Changed: ClusterEvents.AttributeObservable<Attribute<null | DoorLock.LockState, any>>;
    lockType$Changed: ClusterEvents.AttributeObservable<Attribute<DoorLock.LockType, any>>;
    operatingMode$Changed: ClusterEvents.AttributeObservable<WritableAttribute<DoorLock.OperatingMode, any>>;
    supportedOperatingModes$Changed: ClusterEvents.AttributeObservable<FixedAttribute<TypeFromPartialBitSchema<{
        noRemoteLockUnlock: BitFlag;
        normal: BitFlag;
        passage: BitFlag;
        privacy: BitFlag;
        vacation: BitFlag;
    }>, any>>;
} & {
    alarmMask$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<TypeFromPartialBitSchema<{
        doorForcedOpen: BitFlag;
        frontEscutcheonRemoved: BitFlag;
        lockFactoryReset: BitFlag;
        lockJammed: BitFlag;
        lockRadioPowerCycled: BitFlag;
        na: BitFlag;
        wrongCodeEntryLimit: BitFlag;
    }>, any>>;
    autoRelockTime$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<number, any>>;
    defaultConfigurationRegister$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<TypeFromPartialBitSchema<{
        autoRelockTime: BitFlag;
        keypadInterface: BitFlag;
        ledSettings: BitFlag;
        localProgramming: BitFlag;
        remoteInterface: BitFlag;
        soundVolume: BitFlag;
    }>, any>>;
    enableInsideStatusLed$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<boolean, any>>;
    enableLocalProgramming$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<boolean, any>>;
    enableOneTouchLocking$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<boolean, any>>;
    enablePrivacyModeButton$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<boolean, any>>;
    language$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<string, any>>;
    ledSettings$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<DoorLock.LedSetting, any>>;
    localProgrammingFeatures$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<TypeFromPartialBitSchema<{
        addUsersCredentialsSchedules: BitFlag;
        adjustSettings: BitFlag;
        clearUsersCredentialsSchedules: BitFlag;
        modifyUsersCredentialsSchedules: BitFlag;
    }>, any>>;
    soundVolume$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<DoorLock.SoundVolume, any>>;
} & {
    doorLockAlarm: ClusterEvents.EventObservable<Event<TypeFromFields<{
        alarmCode: FieldType<DoorLock.AlarmCode>;
    }>, any>>;
    lockOperation: ClusterEvents.EventObservable<Event<TypeFromFields<{
        credentials: OptionalFieldType<null | TypeFromFields<{
            credentialIndex: ...;
            credentialType: ...;
        }>[]>;
        fabricIndex: FieldType<null | FabricIndex>;
        lockOperationType: FieldType<DoorLock.LockOperationType>;
        operationSource: FieldType<DoorLock.OperationSource>;
        sourceNode: FieldType<null | NodeId>;
        userIndex: FieldType<null | number>;
    }>, any>>;
    lockOperationError: ClusterEvents.EventObservable<Event<TypeFromFields<{
        credentials: OptionalFieldType<null | TypeFromFields<{
            credentialIndex: ...;
            credentialType: ...;
        }>[]>;
        fabricIndex: FieldType<null | FabricIndex>;
        lockOperationType: FieldType<DoorLock.LockOperationType>;
        operationError: FieldType<DoorLock.OperationError>;
        operationSource: FieldType<DoorLock.OperationSource>;
        sourceNode: FieldType<null | NodeId>;
        userIndex: FieldType<null | number>;
    }>, any>>;
} & {}

Access the behavior's events.

Type declaration

  • ReadonlydoorLockAlarm: ClusterEvents.EventObservable<Event<TypeFromFields<{
        alarmCode: FieldType<DoorLock.AlarmCode>;
    }>, any>>

    The door lock server provides several alarms which can be sent when there is a critical state on the door lock. The alarms available for the door lock server are listed in AlarmCodeEnum.

    MatterSpecification.v13.Cluster § 5.2.11.1

  • ReadonlylockOperation: ClusterEvents.EventObservable<Event<TypeFromFields<{
        credentials: OptionalFieldType<null | TypeFromFields<{
            credentialIndex: ...;
            credentialType: ...;
        }>[]>;
        fabricIndex: FieldType<null | FabricIndex>;
        lockOperationType: FieldType<DoorLock.LockOperationType>;
        operationSource: FieldType<DoorLock.OperationSource>;
        sourceNode: FieldType<null | NodeId>;
        userIndex: FieldType<null | number>;
    }>, any>>

    The door lock server sends out a LockOperation event when the event is triggered by the various lock operation sources.

    • If the door lock server supports the Unbolt Door command, it shall generate a LockOperation event with LockOperationType set to Unlock after an Unbolt Door command succeeds.

    • If the door lock server supports the Unbolting feature and an Unlock Door command is performed, it shall generate a LockOperation event with LockOperationType set to Unlatch when the unlatched state is reached and a LockOperation event with LockOperationType set to Unlock when the lock successfully completes the unlock → hold latch → release latch and return to unlock state operation.

    • If the command fails during holding or releasing the latch but after passing the unlocked state, the door lock server shall generate a LockOperationError event with LockOperationType set to Unlatch and a LockOperation event with LockOperationType set to Unlock.

    ◦ If it fails before reaching the unlocked state, the door lock server shall generate only a
      LockOperationError event with LockOperationType set to Unlock.
    

    • Upon manual actuation, a door lock server that supports the Unbolting feature:

    ◦ shall generate a LockOperation event of LockOperationType Unlatch when it is actuated from the
      outside.
    
    ◦ may generate a LockOperation event of LockOperationType Unlatch when it is actuated from the
      inside.
    

    MatterSpecification.v13.Cluster § 5.2.11.3

  • ReadonlylockOperationError: ClusterEvents.EventObservable<Event<TypeFromFields<{
        credentials: OptionalFieldType<null | TypeFromFields<{
            credentialIndex: ...;
            credentialType: ...;
        }>[]>;
        fabricIndex: FieldType<null | FabricIndex>;
        lockOperationType: FieldType<DoorLock.LockOperationType>;
        operationError: FieldType<DoorLock.OperationError>;
        operationSource: FieldType<DoorLock.OperationSource>;
        sourceNode: FieldType<null | NodeId>;
        userIndex: FieldType<null | number>;
    }>, any>>

    The door lock server sends out a LockOperationError event when a lock operation fails for various reasons.

    MatterSpecification.v13.Cluster § 5.2.11.4

features: TypeFromBitSchema<{}> & TypeFromBitSchema<{
    credentialOverTheAirAccess: BitFlag;
    doorPositionSensor: BitFlag;
    faceCredentials: BitFlag;
    fingerCredentials: BitFlag;
    holidaySchedules: BitFlag;
    logging: BitFlag;
    notification: BitFlag;
    pinCredential: BitFlag;
    rfidCredential: BitFlag;
    unbolting: BitFlag;
    user: BitFlag;
    weekDayAccessSchedules: BitFlag;
    yearDayAccessSchedules: BitFlag;
}>

Supported features as a flag object.

session: SecureSession
state: Omit<ClusterState.Type<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior>, never> & {
    actuatorEnabled: boolean;
    lockState: null | DoorLock.LockState;
    lockType: DoorLock.LockType;
    operatingMode: DoorLock.OperatingMode;
} & {
    alarmMask?: TypeFromPartialBitSchema<{
        doorForcedOpen: BitFlag;
        frontEscutcheonRemoved: BitFlag;
        lockFactoryReset: BitFlag;
        lockJammed: BitFlag;
        lockRadioPowerCycled: BitFlag;
        na: BitFlag;
        wrongCodeEntryLimit: BitFlag;
    }>;
    autoRelockTime?: number;
    defaultConfigurationRegister?: TypeFromPartialBitSchema<{
        autoRelockTime: BitFlag;
        keypadInterface: BitFlag;
        ledSettings: BitFlag;
        localProgramming: BitFlag;
        remoteInterface: BitFlag;
        soundVolume: BitFlag;
    }>;
    enableInsideStatusLed?: boolean;
    enableLocalProgramming?: boolean;
    enableOneTouchLocking?: boolean;
    enablePrivacyModeButton?: boolean;
    language?: string;
    ledSettings?: DoorLock.LedSetting;
    localProgrammingFeatures?: TypeFromPartialBitSchema<{
        addUsersCredentialsSchedules: BitFlag;
        adjustSettings: BitFlag;
        clearUsersCredentialsSchedules: BitFlag;
        modifyUsersCredentialsSchedules: BitFlag;
    }>;
    soundVolume?: DoorLock.SoundVolume;
} & {
    supportedOperatingModes: TypeFromPartialBitSchema<{
        noRemoteLockUnlock: BitFlag;
        normal: BitFlag;
        passage: BitFlag;
        privacy: BitFlag;
        vacation: BitFlag;
    }>;
} & {}

Access the behavior's state.

Type declaration

  • ReadonlyactuatorEnabled: boolean

    Indicates if the lock is currently able to (Enabled) or not able to (Disabled) process remote Lock, Unlock, or Unlock with Timeout commands.

    MatterSpecification.v13.Cluster § 5.2.9.4

  • ReadonlylockState: null | DoorLock.LockState

    This attribute may be NULL if the lock hardware does not currently know the status of the locking mechanism. For example, a lock may not know the LockState status after a power cycle until the first lock actuation is completed.

    The Not Fully Locked value is used by a lock to indicate that the state of the lock is somewhere between Locked and Unlocked so it is only partially secured. For example, a deadbolt could be partially extended and not in a dead latched state.

    MatterSpecification.v13.Cluster § 5.2.9.2

  • ReadonlylockType: DoorLock.LockType

    Indicates the type of door lock as defined in LockTypeEnum.

    MatterSpecification.v13.Cluster § 5.2.9.3

  • ReadonlyoperatingMode: DoorLock.OperatingMode

    Indicates the current operating mode of the lock as defined in OperatingModeEnum.

    MatterSpecification.v13.Cluster § 5.2.9.27

Type declaration

  • Optional ReadonlyalarmMask?: TypeFromPartialBitSchema<{
        doorForcedOpen: BitFlag;
        frontEscutcheonRemoved: BitFlag;
        lockFactoryReset: BitFlag;
        lockJammed: BitFlag;
        lockRadioPowerCycled: BitFlag;
        na: BitFlag;
        wrongCodeEntryLimit: BitFlag;
    }>

    This attribute is only supported if the Alarms cluster is on the same endpoint. The alarm mask is used to turn on/off alarms for particular functions. Alarms for an alarm group are enabled if the associated alarm mask bit is set. Each bit represents a group of alarms. Entire alarm groups can be turned on or off by setting or clearing the associated bit in the alarm mask.

    This mask DOES NOT apply to the Events mechanism of this cluster.

    MatterSpecification.v13.Cluster § 5.2.9.40

  • Optional ReadonlyautoRelockTime?: number

    Indicates the number of seconds to wait after unlocking a lock before it automatically locks again. 0=disabled. If set, unlock operations from any source will be timed. For one time unlock with timeout use the specific command.

    MatterSpecification.v13.Cluster § 5.2.9.25

  • Optional ReadonlydefaultConfigurationRegister?: TypeFromPartialBitSchema<{
        autoRelockTime: BitFlag;
        keypadInterface: BitFlag;
        ledSettings: BitFlag;
        localProgramming: BitFlag;
        remoteInterface: BitFlag;
        soundVolume: BitFlag;
    }>

    Indicates the default configurations as they are physically set on the device (example: hardware dip switch setting, etc…) and represents the default setting for some of the attributes within this cluster (for example: LED, Auto Lock, Sound Volume, and Operating Mode attributes).

    This is a read-only attribute and is intended to allow clients to determine what changes may need to be made without having to query all the included attributes. It may be beneficial for the clients to know what the device’s original settings were in the event that the device needs to be restored to factory default settings.

    If the Client device would like to query and modify the door lock server’s operating settings, it SHOULD send read and write attribute requests to the specific attributes.

    For example, the Sound Volume attribute default value is Silent Mode. However, it is possible that the current Sound Volume is High Volume. Therefore, if the client wants to query/modify the current Sound Volume setting on the server, the client SHOULD read/write to the Sound Volume attribute.

    MatterSpecification.v13.Cluster § 5.2.9.29

  • Optional ReadonlyenableInsideStatusLed?: boolean

    This attribute shall enable/disable an inside LED that allows the user to see at a glance if the door is locked.

    MatterSpecification.v13.Cluster § 5.2.9.32

  • Optional ReadonlyenableLocalProgramming?: boolean

    This attribute shall enable/disable local programming on the door lock of certain features (see LocalProgrammingFeatures attribute). If this value is set to TRUE then local programming is enabled on the door lock for all features. If it is set to FALSE then local programming is disabled on the door lock for those features whose bit is set to 0 in the LocalProgrammingFeatures attribute. Local programming shall be enabled by default.

    MatterSpecification.v13.Cluster § 5.2.9.30

  • Optional ReadonlyenableOneTouchLocking?: boolean

    This attribute shall enable/disable the ability to lock the door lock with a single touch on the door lock.

    MatterSpecification.v13.Cluster § 5.2.9.31

  • Optional ReadonlyenablePrivacyModeButton?: boolean

    This attribute shall enable/disable a button inside the door that is used to put the lock into privacy mode. When the lock is in privacy mode it cannot be manipulated from the outside.

    MatterSpecification.v13.Cluster § 5.2.9.33

  • Optional Readonlylanguage?: string

    Indicates the language for the on-screen or audible user interface using a 2- byte language code from ISO-639-1.

    MatterSpecification.v13.Cluster § 5.2.9.23

  • Optional ReadonlyledSettings?: DoorLock.LedSetting

    Indicates the settings for the LED support, as defined by LEDSettingEnum.

    MatterSpecification.v13.Cluster § 5.2.9.24

  • Optional ReadonlylocalProgrammingFeatures?: TypeFromPartialBitSchema<{
        addUsersCredentialsSchedules: BitFlag;
        adjustSettings: BitFlag;
        clearUsersCredentialsSchedules: BitFlag;
        modifyUsersCredentialsSchedules: BitFlag;
    }>

    Indicates the local programming features that will be disabled when EnableLocalProgramming attribute is set to False. If a door lock doesn’t support disabling one aspect of local programming it shall return CONSTRAINT_ERROR during a write operation of this attribute. If the EnableLocalProgramming attribute is set to True then all local programming features shall be enabled regardless of the bits set to 0 in this attribute.

    The features that can be disabled from local programming are defined in LocalProgrammingFeaturesBitmap.

    MatterSpecification.v13.Cluster § 5.2.9.34

  • Optional ReadonlysoundVolume?: DoorLock.SoundVolume

    Indicates the sound volume on a door lock as defined by SoundVolumeEnum.

    MatterSpecification.v13.Cluster § 5.2.9.26

Type declaration

  • ReadonlysupportedOperatingModes: TypeFromPartialBitSchema<{
        noRemoteLockUnlock: BitFlag;
        normal: BitFlag;
        passage: BitFlag;
        privacy: BitFlag;
        vacation: BitFlag;
    }>

    This attribute shall contain a bitmap with all operating bits of the OperatingMode attribute supported by the lock. All operating modes NOT supported by a lock shall be set to one. The value of the OperatingMode enumeration defines the related bit to be set.

    MatterSpecification.v13.Cluster § 5.2.9.28

cluster: DoorLock.Cluster

Base cluster state include all attribute values but may be extended by subclasses.

defaults: ClusterState.Type<DoorLock.Cluster, Type<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior, DoorLockInterface>>
dependencies?: Iterable<Type, any, any>
early: boolean
Events: ClusterEvents.Type<DoorLock.Cluster, Type<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior, DoorLockInterface>>
ExtensionInterface: {}
id

The behavior ID for ClusterBehaviors is the name of the cluster.

Internal: (new () => {})
name: string
schema?: Schema
State: (new () => ClusterState.Type<DoorLock.Cluster, Type<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior, DoorLockInterface>>)
supervisor: RootSupervisor
supports: ((other: Type) => boolean)

Type declaration

    • (other): boolean
    • Does this behavior support functionality of a specific implementation?

      Parameters

      Returns boolean

Methods

  • Create a generic callback function that has the same properties as a Reactor.

    Like a reactor, the callback's "this" will be bound to an active Behavior instance. Because of this: The reactor MUST be a real JS function - arrow functions will not work!

    Type Parameters

    • A extends any[]
    • R

    Parameters

    Returns ((...args: A) => undefined | R)

      • (...args): undefined | R
      • Parameters

        • Rest...args: A

        Returns undefined | R

  • This command causes the lock device to lock the door. This command includes an optional code for the lock. The door lock may require a PIN depending on the value of the RequirePINForRemoteOperation attribute.

    † The PIN/RFID Code is an obsolete field name, use PINCode instead.

    Returns void

    MatterSpecification.v13.Cluster § 5.2.10.1

  • This command causes the lock device to unlock the door. This command includes an optional code for the lock. The door lock may require a code depending on the value of the RequirePINForRemoteOperation attribute.

    NOTE

    If the attribute AutoRelockTime is supported the lock will transition to the locked state when the auto relock time has expired.

    † The PIN/RFID Code is an obsolete field name, use PINCode instead.

    Returns void

    MatterSpecification.v13.Cluster § 5.2.10.2

  • This command causes the lock device to unlock the door with a timeout parameter. After the time in seconds specified in the timeout field, the lock device will relock itself automatically. This timeout parameter is only temporary for this message transition and overrides the default relock time

    as specified in the AutoRelockTime attribute. If the door lock device is not capable of or does not want to support temporary Relock Timeout, it SHOULD NOT support this optional command.

    † The PIN/RFID Code is an obsolete field name, use PINCode instead.

    Returns MaybePromise

    MatterSpecification.v13.Cluster § 5.2.10.3