Variable CompleteInstanceConst

Type declaration

• Readonlyattributes: {
      acceptedCommandList: Attribute<.[], never>;
      actuatorEnabled: Attribute<boolean, any>;
      alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any>;
      attributeList: Attribute<.[], never>;
      autoRelockTime: OptionalWritableAttribute<number, any>;
      clusterRevision: Attribute<number, never>;
      credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema, any>;
      doorClosedEvents: OptionalWritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              doorPositionSensor: boolean;
          }];
      };
      doorOpenEvents: OptionalWritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              doorPositionSensor: boolean;
          }];
      };
      doorState: Attribute<DoorLock.DoorState | null, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              doorPositionSensor: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
      enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
      enableLogging: WritableAttribute<boolean, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              logging: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
      enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
      expiringUserTimeout: OptionalWritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              user: boolean;
          }];
      };
      featureMap: Attribute<TypeFromPartialBitSchema, never>;
      generatedCommandList: Attribute<.[], never>;
      keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              notification: boolean;
              pinCredential: boolean;
          }];
      };
      keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              notification: boolean;
              pinCredential: boolean;
          }];
      };
      language: OptionalWritableAttribute<string, any>;
      ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
      localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema, any>;
      lockState: Attribute<DoorLock.LockState | null, any>;
      lockType: Attribute<DoorLock.LockType, any>;
      manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              notification: boolean;
          }];
      };
      maxPinCodeLength: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              pinCredential: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      maxRfidCodeLength: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              rfidCredential: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      minPinCodeLength: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              pinCredential: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      minRfidCodeLength: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              rfidCredential: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              holidaySchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      numberOfLogRecordsSupported: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              logging: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      numberOfPinUsersSupported: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              pinCredential: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      numberOfRfidUsersSupported: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              rfidCredential: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      numberOfTotalUsersSupported: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              weekDayAccessSchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              yearDayAccessSchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      openPeriod: OptionalWritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              doorPositionSensor: boolean;
          }];
      };
      operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
      remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              notification: boolean;
          }];
      };
      remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              notification: boolean;
          }];
      };
      requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              credentialOverTheAirAccess: boolean;
              pinCredential: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              notification: boolean;
              rfidCredential: boolean;
          }];
      };
      rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              notification: boolean;
              rfidCredential: boolean;
          }];
      };
      sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              pinCredential: boolean;
              user: boolean;
          }];
      };
      soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
      supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema, any>;
      userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              pinCredential: boolean;
          }, {
              rfidCredential: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      wrongCodeEntryLimit: WritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              pinCredential: boolean;
          }, {
              rfidCredential: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
  }

  • ReadonlyacceptedCommandList: Attribute<.[], never>

  • ReadonlyactuatorEnabled: Attribute<boolean, any>

  • ReadonlyalarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any>

  • ReadonlyattributeList: Attribute<.[], never>

  • ReadonlyautoRelockTime: OptionalWritableAttribute<number, any>

  • ReadonlyclusterRevision: Attribute<number, never>

  • ReadonlycredentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlydefaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema, any>

  • ReadonlydoorClosedEvents: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            doorPositionSensor: boolean;
        }];
    }

  • ReadonlydoorOpenEvents: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            doorPositionSensor: boolean;
        }];
    }

  • ReadonlydoorState: Attribute<DoorLock.DoorState | null, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            doorPositionSensor: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyenableInsideStatusLed: OptionalWritableAttribute<boolean, any>

  • ReadonlyenableLocalProgramming: OptionalWritableAttribute<boolean, any>

  • ReadonlyenableLogging: WritableAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            logging: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyenableOneTouchLocking: OptionalWritableAttribute<boolean, any>

  • ReadonlyenablePrivacyModeButton: OptionalWritableAttribute<boolean, any>

  • ReadonlyexpiringUserTimeout: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            user: boolean;
        }];
    }

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema, never>

  • ReadonlygeneratedCommandList: Attribute<.[], never>

  • ReadonlykeypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            pinCredential: boolean;
        }];
    }

  • ReadonlykeypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            pinCredential: boolean;
        }];
    }

  • Readonlylanguage: OptionalWritableAttribute<string, any>

  • ReadonlyledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>

  • ReadonlylocalProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema, any>

  • ReadonlylockState: Attribute<DoorLock.LockState | null, any>

  • ReadonlylockType: Attribute<DoorLock.LockType, any>

  • ReadonlymanualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
        }];
    }

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

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

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

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

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

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

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

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

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

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

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

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

  • ReadonlyopenPeriod: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            doorPositionSensor: boolean;
        }];
    }

  • ReadonlyoperatingMode: WritableAttribute<DoorLock.OperatingMode, any>

  • ReadonlyremoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
        }];
    }

  • ReadonlyremoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
        }];
    }

  • ReadonlyrequirePinForRemoteOperation: WritableAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            credentialOverTheAirAccess: boolean;
            pinCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyrfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            rfidCredential: boolean;
        }];
    }

  • ReadonlyrfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            rfidCredential: boolean;
        }];
    }

  • ReadonlysendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
    }

  • ReadonlysoundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>

  • ReadonlysupportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema, any>

  • ReadonlyuserCodeTemporaryDisableTime: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }, {
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlywrongCodeEntryLimit: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }, {
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

• Readonlycommands: {
      clearAllPinCodes: Command<void, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              pinCredential: boolean;
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      clearAllRfidCodes: Command<void, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              rfidCredential: boolean;
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      clearCredential: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      clearHolidaySchedule: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              holidaySchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      clearPinCode: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              pinCredential: boolean;
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      clearRfidCode: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              rfidCredential: boolean;
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      clearUser: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      clearWeekDaySchedule: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              weekDayAccessSchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      clearYearDaySchedule: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              yearDayAccessSchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      getCredentialStatus: Command<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      getHolidaySchedule: Command<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              holidaySchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      getLogRecord: Command<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              logging: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      getPinCode: Command<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              pinCredential: boolean;
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      getRfidCode: Command<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              rfidCredential: boolean;
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      getUser: Command<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      getUserStatus: OptionalCommand<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              fingerCredentials: boolean;
              pinCredential: boolean;
              rfidCredential: boolean;
              user: boolean;
          }];
      };
      getUserType: OptionalCommand<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              fingerCredentials: boolean;
              pinCredential: boolean;
              rfidCredential: boolean;
              user: boolean;
          }];
      };
      getWeekDaySchedule: Command<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              weekDayAccessSchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      getYearDaySchedule: Command<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              yearDayAccessSchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      lockDoor: Command<TypeFromFields, void, any>;
      setCredential: Command<TypeFromFields, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      setHolidaySchedule: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              holidaySchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      setPinCode: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              pinCredential: boolean;
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      setRfidCode: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              rfidCredential: boolean;
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      setUser: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      setUserStatus: OptionalCommand<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              fingerCredentials: boolean;
              pinCredential: boolean;
              rfidCredential: boolean;
              user: boolean;
          }];
      };
      setUserType: OptionalCommand<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              fingerCredentials: boolean;
              pinCredential: boolean;
              rfidCredential: boolean;
              user: boolean;
          }];
      };
      setWeekDaySchedule: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              weekDayAccessSchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      setYearDaySchedule: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              yearDayAccessSchedules: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      unboltDoor: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              unbolting: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      unlockDoor: Command<TypeFromFields, void, any>;
      unlockWithTimeout: OptionalCommand<TypeFromFields, void, any>;
  }

  • ReadonlyclearAllPinCodes: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyclearAllRfidCodes: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyclearCredential: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyclearHolidaySchedule: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            holidaySchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyclearPinCode: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyclearRfidCode: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyclearUser: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyclearWeekDaySchedule: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            weekDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyclearYearDaySchedule: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            yearDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlygetCredentialStatus: Command<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlygetHolidaySchedule: Command<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            holidaySchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlygetLogRecord: Command<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            logging: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlygetPinCode: Command<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlygetRfidCode: Command<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlygetUser: Command<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlygetUserStatus: OptionalCommand<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            fingerCredentials: boolean;
            pinCredential: boolean;
            rfidCredential: boolean;
            user: boolean;
        }];
    }

  • ReadonlygetUserType: OptionalCommand<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            fingerCredentials: boolean;
            pinCredential: boolean;
            rfidCredential: boolean;
            user: boolean;
        }];
    }

  • ReadonlygetWeekDaySchedule: Command<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            weekDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlygetYearDaySchedule: Command<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            yearDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlylockDoor: Command<TypeFromFields, void, any>

  • ReadonlysetCredential: Command<TypeFromFields, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlysetHolidaySchedule: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            holidaySchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlysetPinCode: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlysetRfidCode: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlysetUser: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlysetUserStatus: OptionalCommand<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            fingerCredentials: boolean;
            pinCredential: boolean;
            rfidCredential: boolean;
            user: boolean;
        }];
    }

  • ReadonlysetUserType: OptionalCommand<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            fingerCredentials: boolean;
            pinCredential: boolean;
            rfidCredential: boolean;
            user: boolean;
        }];
    }

  • ReadonlysetWeekDaySchedule: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            weekDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlysetYearDaySchedule: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            yearDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyunboltDoor: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            unbolting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyunlockDoor: Command<TypeFromFields, void, any>

  • ReadonlyunlockWithTimeout: OptionalCommand<TypeFromFields, void, any>

• Readonlyevents: {
      doorLockAlarm: Event<TypeFromFields, any>;
      doorStateChange: Event<TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              doorPositionSensor: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      lockOperation: Event<TypeFromFields, any>;
      lockOperationError: Event<TypeFromFields, any>;
      lockUserChange: Event<TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              user: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
  }

  • ReadonlydoorLockAlarm: Event<TypeFromFields, any>

  • ReadonlydoorStateChange: Event<TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            doorPositionSensor: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlylockOperation: Event<TypeFromFields, any>

  • ReadonlylockOperationError: Event<TypeFromFields, any>

  • ReadonlylockUserChange: Event<TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

• Readonlyfeatures: {
      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;
  }

  • ReadonlycredentialOverTheAirAccess: BitFlag

    CredentialOverTheAirAccess

    If this feature is supported then the lock supports the ability to verify a credential provided in a lock/unlock command. Currently the cluster only supports providing the PIN credential to the lock/unlock commands. If this feature is supported then the PIN Credential feature shall also be supported.

    See

    MatterSpecification.v13.Cluster § 5.2.4.8

  • ReadonlydoorPositionSensor: BitFlag

    DoorPositionSensor

    If this feature is supported this indicates that the lock has the ability to determine the position of the door which is separate from the state of the lock.

    See

    MatterSpecification.v13.Cluster § 5.2.4.6

  • ReadonlyfaceCredentials: BitFlag

    FaceCredentials

    Currently the cluster only defines the metadata format for notifications when a face recognition, iris, or retina credential is used to access the lock and doesn’t describe how to create face recognition, iris, or retina credentials. If the Users feature is also supported then the User that a face recognition, iris, or retina credential is associated with can also have its UserType, UserStatus and Schedule modified.

    A lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User and not directly with a credential.

    See

    MatterSpecification.v13.Cluster § 5.2.4.7

  • ReadonlyfingerCredentials: BitFlag

    FingerCredentials

    Currently the cluster only defines the metadata format for notifications when a fingerprint/ finger vein credential is used to access the lock and doesn’t describe how to create fingerprint/finger vein credentials. If the Users feature is also supported then the User that a fingerprint/finger vein is associated with can also have its UserType, UserStatus and Schedule modified.

    A lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User index and not directly with a Finger index. A User Index may have several credentials associated with it.

    See

    MatterSpecification.v13.Cluster § 5.2.4.3

  • ReadonlyholidaySchedules: BitFlag

    HolidaySchedules

    This feature is used to setup Holiday Schedule in the lock device. A Holiday Schedule sets a start and stop end date/time for the lock to use the specified operating mode set by the Holiday Schedule.

    See

    MatterSpecification.v13.Cluster § 5.2.4.12

  • Readonlylogging: BitFlag

    Logging

    If Events are not supported the logging feature shall replace the Event reporting structure. If Events are supported the logging feature shall NOT be supported.

    See

    MatterSpecification.v13.Cluster § 5.2.4.4

  • Readonlynotification: BitFlag

    Notification

    This is a feature used before support of events. This feature supports notification commands and masks used to filter these notifications.

    See

    MatterSpecification.v13.Cluster § 5.2.4.10

  • ReadonlypinCredential: BitFlag

    PinCredential

    If the User Feature is also supported then any PIN Code stored in the lock shall be associated with a User.

    A lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User index and not directly with a PIN index. A User index may have several credentials associated with it.

    See

    MatterSpecification.v13.Cluster § 5.2.4.1

  • ReadonlyrfidCredential: BitFlag

    RfidCredential

    If the User Feature is also supported then any RFID credential stored in the lock shall be associated with a User.

    A lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User index and not directly with a RFID index. A User

    Index may have several credentials associated with it.

    See

    MatterSpecification.v13.Cluster § 5.2.4.2

  • Readonlyunbolting: BitFlag

    Unbolting

    Locks that support this feature differentiate between unbolting and unlocking. The Unbolt Door command retracts the bolt without pulling the latch. The Unlock Door command fully unlocks the door by retracting the bolt and briefly pulling the latch. While the latch is pulled, the lock state changes to Unlatched. Locks without unbolting support don’t differentiate between unbolting and unlocking and perform the same operation for both commands.

    See

    MatterSpecification.v13.Cluster § 5.2.4.13

  • Readonlyuser: BitFlag

    User

    If the User Feature is supported then a lock employs a User database. A User within the User database is used to associate credentials and schedules to single user record within the lock. This also means the UserType and UserStatus fields are associated with a User and not a credential.

    See

    MatterSpecification.v13.Cluster § 5.2.4.9

  • ReadonlyweekDayAccessSchedules: BitFlag

    WeekDayAccessSchedules

    If the User feature is supported then Week Day Schedules are applied to a User and not a credential.

    Week Day Schedules are used to restrict access to a specified time window on certain days of the week. The schedule is repeated each week. When a schedule is cleared this clears the access restrictions and grants unrestricted access to the user. The lock may automatically adjust the UserType when a schedule is created or cleared.

    See

    MatterSpecification.v13.Cluster § 5.2.4.5

  • ReadonlyyearDayAccessSchedules: BitFlag

    YearDayAccessSchedules

    If the User feature is supported then Year Day Schedules are applied to a User and not a credential.

    Year Day Schedules are used to restrict access to a specified date and time window. When a schedule is cleared this clears the access restrictions and grants unrestricted access to the user. The lock may automatically adjust the UserType when a schedule is created or cleared.

    See

    MatterSpecification.v13.Cluster § 5.2.4.11

• Readonlyid: @matter/general

• Readonlyname: "DoorLock"

• Readonlyrevision: 7