Interface Cluster

interface Cluster {
    attributes: Pick<Merge<{
        actuatorEnabled: Attribute<boolean, any>;
        alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            doorForcedOpen: BitFlag;
            frontEscutcheonRemoved: BitFlag;
            lockFactoryReset: BitFlag;
            lockJammed: BitFlag;
            lockRadioPowerCycled: BitFlag;
            na: BitFlag;
            wrongCodeEntryLimit: BitFlag;
        }>, any>;
        autoRelockTime: OptionalWritableAttribute<number, any>;
        defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
            autoRelockTime: BitFlag;
            keypadInterface: BitFlag;
            ledSettings: BitFlag;
            localProgramming: BitFlag;
            remoteInterface: BitFlag;
            soundVolume: BitFlag;
        }>, any>;
        enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
        enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
        enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
        enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
        language: OptionalWritableAttribute<string, any>;
        ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
        localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            addUsersCredentialsSchedules: BitFlag;
            adjustSettings: BitFlag;
            clearUsersCredentialsSchedules: BitFlag;
            modifyUsersCredentialsSchedules: BitFlag;
        }>, any>;
        lockState: Attribute<null | DoorLock.LockState, any>;
        lockType: Attribute<DoorLock.LockType, any>;
        operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
        soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
        supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
            noRemoteLockUnlock: BitFlag;
            normal: BitFlag;
            passage: BitFlag;
            privacy: BitFlag;
            vacation: BitFlag;
        }>, any>;
    }, GlobalAttributes<{
        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;
    }>>,
        | "clusterRevision"
        | "featureMap"
        | "attributeList"
        | "acceptedCommandList"
        | "generatedCommandList"
        | "operatingMode"
        | "lockState"
        | "lockType"
        | "actuatorEnabled"
        | "language"
        | "ledSettings"
        | "autoRelockTime"
        | "soundVolume"
        | "supportedOperatingModes"
        | "defaultConfigurationRegister"
        | "enableLocalProgramming"
        | "enableOneTouchLocking"
        | "enableInsideStatusLed"
        | "enablePrivacyModeButton"
        | "localProgrammingFeatures"
        | "alarmMask"> & Omit<unknown,
        | "operatingMode"
        | "lockState"
        | "lockType"
        | "actuatorEnabled"
        | "language"
        | "ledSettings"
        | "autoRelockTime"
        | "soundVolume"
        | "supportedOperatingModes"
        | "defaultConfigurationRegister"
        | "enableLocalProgramming"
        | "enableOneTouchLocking"
        | "enableInsideStatusLed"
        | "enablePrivacyModeButton"
        | "localProgrammingFeatures"
        | "alarmMask"
        | (keyof GlobalAttributes<{ readonly pinCredential: BitFlag; readonly rfidCredential: BitFlag; readonly fingerCredentials: BitFlag; readonly logging: BitFlag; ... 8 more ...; readonly unbolting: BitFlag; }>)> & Omit<Merge<{
        actuatorEnabled: Attribute<boolean, any>;
        alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            doorForcedOpen: BitFlag;
            frontEscutcheonRemoved: BitFlag;
            lockFactoryReset: BitFlag;
            lockJammed: BitFlag;
            lockRadioPowerCycled: BitFlag;
            na: BitFlag;
            wrongCodeEntryLimit: BitFlag;
        }>, any>;
        autoRelockTime: OptionalWritableAttribute<number, any>;
        defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
            autoRelockTime: BitFlag;
            keypadInterface: BitFlag;
            ledSettings: BitFlag;
            localProgramming: BitFlag;
            remoteInterface: BitFlag;
            soundVolume: BitFlag;
        }>, any>;
        enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
        enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
        enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
        enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
        language: OptionalWritableAttribute<string, any>;
        ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
        localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            addUsersCredentialsSchedules: BitFlag;
            adjustSettings: BitFlag;
            clearUsersCredentialsSchedules: BitFlag;
            modifyUsersCredentialsSchedules: BitFlag;
        }>, any>;
        lockState: Attribute<null | DoorLock.LockState, any>;
        lockType: Attribute<DoorLock.LockType, any>;
        operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
        soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
        supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
            noRemoteLockUnlock: BitFlag;
            normal: BitFlag;
            passage: BitFlag;
            privacy: BitFlag;
            vacation: BitFlag;
        }>, any>;
    }, GlobalAttributes<{
        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;
    }>>,
        | "operatingMode"
        | "lockState"
        | "lockType"
        | "actuatorEnabled"
        | "language"
        | "ledSettings"
        | "autoRelockTime"
        | "soundVolume"
        | "supportedOperatingModes"
        | "defaultConfigurationRegister"
        | "enableLocalProgramming"
        | "enableOneTouchLocking"
        | "enableInsideStatusLed"
        | "enablePrivacyModeButton"
        | "localProgrammingFeatures"
        | "alarmMask"
        | (keyof GlobalAttributes<{ readonly pinCredential: BitFlag; readonly rfidCredential: BitFlag; readonly fingerCredentials: BitFlag; readonly logging: BitFlag; ... 8 more ...; readonly unbolting: BitFlag; }>)>;
    base: Of<{
        attributes: {
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
        };
        commands: {
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            lockOperation: 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: 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>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    doorClosedEvents: OptionalWritableAttribute<number, any>;
                    doorOpenEvents: OptionalWritableAttribute<number, any>;
                    doorState: Attribute<null | DoorLock.DoorState, any>;
                    openPeriod: OptionalWritableAttribute<number, any>;
                };
                events: {
                    doorStateChange: Event<TypeFromFields<{
                        doorState: FieldType<DoorLock.DoorState>;
                    }>, any>;
                };
            };
            flags: {
                doorPositionSensor: true;
            };
        }, {
            component: {
                attributes: {
                    enableLogging: WritableAttribute<boolean, any>;
                    numberOfLogRecordsSupported: FixedAttribute<number, any>;
                };
                commands: {
                    getLogRecord: Command<TypeFromFields<{
                        logIndex: FieldType<number>;
                    }>, TypeFromFields<{
                        eventId: FieldType<number>;
                        eventType: FieldType<DoorLock.EventType>;
                        logEntryId: FieldType<number>;
                        pin: FieldType<Uint8Array>;
                        source: FieldType<DoorLock.EventSource>;
                        timestamp: FieldType<number>;
                        userId: FieldType<number>;
                    }>, any>;
                };
            };
            flags: {
                logging: true;
            };
        }, {
            component: {
                attributes: {
                    credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        dual: BitFlag;
                        single: BitFlag;
                        tri: BitFlag;
                    }>, any>;
                    expiringUserTimeout: OptionalWritableAttribute<number, any>;
                    numberOfCredentialsSupportedPerUser: FixedAttribute<number, any>;
                    numberOfTotalUsersSupported: FixedAttribute<number, any>;
                };
                commands: {
                    clearCredential: Command<TypeFromFields<{
                        credential: FieldType<(...) | (...)>;
                    }>, void, any>;
                    clearUser: Command<TypeFromFields<{
                        userIndex: FieldType<number>;
                    }>, void, any>;
                    getCredentialStatus: Command<TypeFromFields<{
                        credential: FieldType<TypeFromFields<(...)>>;
                    }>, TypeFromFields<{
                        creatorFabricIndex: FieldType<(...) | (...)>;
                        credentialExists: FieldType<boolean>;
                        lastModifiedFabricIndex: FieldType<(...) | (...)>;
                        nextCredentialIndex: OptionalFieldType<(...) | (...)>;
                        userIndex: FieldType<(...) | (...)>;
                    }>, any>;
                    getUser: Command<TypeFromFields<{
                        userIndex: FieldType<number>;
                    }>, TypeFromFields<{
                        creatorFabricIndex: FieldType<(...) | (...)>;
                        credentialRule: FieldType<(...) | (...)>;
                        credentials: FieldType<(...) | (...)>;
                        lastModifiedFabricIndex: FieldType<(...) | (...)>;
                        nextUserIndex: FieldType<(...) | (...)>;
                        userIndex: FieldType<number>;
                        userName: FieldType<(...) | (...)>;
                        userStatus: FieldType<(...) | (...)>;
                        userType: FieldType<(...) | (...)>;
                        userUniqueId: FieldType<(...) | (...)>;
                    }>, any>;
                    setCredential: Command<TypeFromFields<{
                        credential: FieldType<TypeFromFields<(...)>>;
                        credentialData: FieldType<Uint8Array>;
                        operationType: FieldType<DoorLock.DataOperationType>;
                        userIndex: FieldType<(...) | (...)>;
                        userStatus: FieldType<(...) | (...)>;
                        userType: FieldType<(...) | (...)>;
                    }>, TypeFromFields<{
                        nextCredentialIndex: OptionalFieldType<(...) | (...)>;
                        status: FieldType<Status>;
                        userIndex: FieldType<(...) | (...)>;
                    }>, any>;
                    setUser: Command<TypeFromFields<{
                        credentialRule: FieldType<(...) | (...)>;
                        operationType: FieldType<DoorLock.DataOperationType>;
                        userIndex: FieldType<number>;
                        userName: FieldType<(...) | (...)>;
                        userStatus: FieldType<(...) | (...)>;
                        userType: FieldType<(...) | (...)>;
                        userUniqueId: FieldType<(...) | (...)>;
                    }>, void, any>;
                };
                events: {
                    lockUserChange: Event<TypeFromFields<{
                        dataIndex: FieldType<(...) | (...)>;
                        dataOperationType: FieldType<DoorLock.DataOperationType>;
                        fabricIndex: FieldType<(...) | (...)>;
                        lockDataType: FieldType<DoorLock.LockDataType>;
                        operationSource: FieldType<DoorLock.OperationSource>;
                        sourceNode: FieldType<(...) | (...)>;
                        userIndex: FieldType<(...) | (...)>;
                    }>, any>;
                };
            };
            flags: {
                user: true;
            };
        }, {
            component: {
                attributes: {
                    maxPinCodeLength: FixedAttribute<number, any>;
                    minPinCodeLength: FixedAttribute<number, any>;
                    numberOfPinUsersSupported: FixedAttribute<number, any>;
                };
            };
            flags: {
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    maxRfidCodeLength: FixedAttribute<number, any>;
                    minRfidCodeLength: FixedAttribute<number, any>;
                    numberOfRfidUsersSupported: FixedAttribute<number, any>;
                };
            };
            flags: {
                rfidCredential: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                };
                commands: {
                    clearWeekDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<number>;
                        weekDayIndex: FieldType<number>;
                    }>, void, any>;
                    getWeekDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<number>;
                        weekDayIndex: FieldType<number>;
                    }>, TypeFromFields<{
                        daysMask: OptionalFieldType<TypeFromPartialBitSchema<(...)>>;
                        endHour: OptionalFieldType<number>;
                        endMinute: OptionalFieldType<number>;
                        startHour: OptionalFieldType<number>;
                        startMinute: OptionalFieldType<number>;
                        status: FieldType<Status>;
                        userIndexUserId: FieldType<number>;
                        weekDayIndex: FieldType<number>;
                    }>, any>;
                    setWeekDaySchedule: Command<TypeFromFields<{
                        daysMask: FieldType<TypeFromPartialBitSchema<(...)>>;
                        endHour: FieldType<number>;
                        endMinute: FieldType<number>;
                        startHour: FieldType<number>;
                        startMinute: FieldType<number>;
                        userIndexUserId: FieldType<number>;
                        weekDayIndex: FieldType<number>;
                    }>, void, any>;
                };
            };
            flags: {
                weekDayAccessSchedules: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                };
                commands: {
                    clearYearDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<number>;
                        yearDayIndex: FieldType<number>;
                    }>, void, any>;
                    getYearDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<number>;
                        yearDayIndex: FieldType<number>;
                    }>, TypeFromFields<{
                        localEndTime: OptionalFieldType<number>;
                        localStartTime: OptionalFieldType<number>;
                        status: FieldType<Status>;
                        userIndexUserId: FieldType<number>;
                        yearDayIndex: FieldType<number>;
                    }>, any>;
                    setYearDaySchedule: Command<TypeFromFields<{
                        localEndTime: FieldType<number>;
                        localStartTime: FieldType<number>;
                        userIndexUserId: FieldType<number>;
                        yearDayIndex: FieldType<number>;
                    }>, void, any>;
                };
            };
            flags: {
                yearDayAccessSchedules: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfHolidaySchedulesSupported: FixedAttribute<number, any>;
                };
                commands: {
                    clearHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<number>;
                    }>, void, any>;
                    getHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<number>;
                    }>, TypeFromFields<{
                        holidayIndex: FieldType<number>;
                        localEndTime: OptionalFieldType<(...) | (...)>;
                        localStartTime: OptionalFieldType<(...) | (...)>;
                        operatingMode: OptionalFieldType<(...) | (...)>;
                        status: FieldType<Status>;
                    }>, any>;
                    setHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<number>;
                        localEndTime: FieldType<number>;
                        localStartTime: FieldType<number>;
                        operatingMode: FieldType<DoorLock.OperatingMode>;
                    }>, void, any>;
                };
            };
            flags: {
                holidaySchedules: true;
            };
        }, {
            component: {
                attributes: {
                    userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                    wrongCodeEntryLimit: WritableAttribute<number, any>;
                };
            };
            flags: {
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                    wrongCodeEntryLimit: WritableAttribute<number, any>;
                };
            };
            flags: {
                rfidCredential: true;
            };
        }, {
            component: {
                attributes: {
                    sendPinOverTheAir: OptionalWritableAttribute<boolean, any>;
                };
                commands: {
                    clearAllPinCodes: Command<void, void, any>;
                    clearPinCode: Command<TypeFromFields<{
                        pinSlotIndex: FieldType<number>;
                    }>, void, any>;
                    getPinCode: Command<TypeFromFields<{
                        userId: FieldType<number>;
                    }>, TypeFromFields<{
                        pinCode: FieldType<(...) | (...)>;
                        userId: FieldType<number>;
                        userStatus: FieldType<(...) | (...)>;
                        userType: FieldType<(...) | (...)>;
                    }>, any>;
                    setPinCode: Command<TypeFromFields<{
                        pin: FieldType<Uint8Array>;
                        userId: FieldType<number>;
                        userStatus: FieldType<(...) | (...)>;
                        userType: FieldType<(...) | (...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinCredential: true;
                user: false;
            };
        }, {
            component: {
                attributes: {
                    requirePinForRemoteOperation: WritableAttribute<boolean, any>;
                };
            };
            flags: {
                credentialOverTheAirAccess: true;
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        pinAdded: BitFlag;
                        pinChanged: BitFlag;
                        pinCleared: BitFlag;
                        pinCodeChanged: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        pinAdded: BitFlag;
                        pinChanged: BitFlag;
                        pinCleared: BitFlag;
                        rfidCodeAdded: BitFlag;
                        rfidCodeCleared: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
            };
        }, {
            component: {
                attributes: {
                    rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        idAdded: BitFlag;
                        idCleared: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
                rfidCredential: true;
            };
        }, {
            component: {
                commands: {
                    getUserStatus: OptionalCommand<TypeFromFields<{
                        userId: FieldType<number>;
                    }>, TypeFromFields<{
                        userId: FieldType<number>;
                        userStatus: FieldType<DoorLock.UserStatus>;
                    }>, any>;
                    getUserType: OptionalCommand<TypeFromFields<{
                        userId: FieldType<number>;
                    }>, TypeFromFields<{
                        userId: FieldType<number>;
                        userType: FieldType<DoorLock.UserType>;
                    }>, any>;
                    setUserStatus: OptionalCommand<TypeFromFields<{
                        userId: FieldType<number>;
                        userStatus: FieldType<DoorLock.UserStatus>;
                    }>, void, any>;
                    setUserType: OptionalCommand<TypeFromFields<{
                        userId: FieldType<number>;
                        userType: FieldType<DoorLock.UserType>;
                    }>, void, any>;
                };
            };
            flags: {
                fingerCredentials: true;
                pinCredential: true;
                rfidCredential: true;
                user: false;
            };
        }, {
            component: {};
            flags: {
                user: false;
            };
        }, {
            component: {
                commands: {
                    clearAllRfidCodes: Command<void, void, any>;
                    clearRfidCode: Command<TypeFromFields<{
                        rfidSlotIndex: FieldType<number>;
                    }>, void, any>;
                    getRfidCode: Command<TypeFromFields<{
                        userId: FieldType<number>;
                    }>, TypeFromFields<{
                        rfidCode: FieldType<(...) | (...)>;
                        userId: FieldType<number>;
                        userStatus: FieldType<(...) | (...)>;
                        userType: FieldType<(...) | (...)>;
                    }>, any>;
                    setRfidCode: Command<TypeFromFields<{
                        rfidCode: FieldType<Uint8Array>;
                        userId: FieldType<number>;
                        userStatus: FieldType<(...) | (...)>;
                        userType: FieldType<(...) | (...)>;
                    }>, void, any>;
                };
            };
            flags: {
                rfidCredential: true;
                user: false;
            };
        }, {
            component: {
                commands: {
                    unboltDoor: Command<TypeFromFields<{
                        pinCode: OptionalFieldType<Uint8Array>;
                    }>, void, any>;
                };
            };
            flags: {
                unbolting: true;
            };
        }, {
            component: false;
            flags: {
                faceCredentials: true;
                fingerCredentials: true;
                pinCredential: true;
                rfidCredential: true;
                user: true;
            };
        }];
        features: {
            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;
        };
        id: 257;
        name: "DoorLock";
        revision: 7;
    }>;
    commands: Pick<{
        lockDoor: Command<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
        }>, void, any>;
        unlockDoor: Command<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
        }>, void, any>;
        unlockWithTimeout: OptionalCommand<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
            timeout: FieldType<number>;
        }>, void, any>;
    }, "lockDoor" | "unlockDoor" | "unlockWithTimeout"> & Omit<unknown, "lockDoor" | "unlockDoor" | "unlockWithTimeout"> & Omit<{
        lockDoor: Command<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
        }>, void, any>;
        unlockDoor: Command<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
        }>, void, any>;
        unlockWithTimeout: OptionalCommand<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
            timeout: FieldType<number>;
        }>, void, any>;
    }, "lockDoor" | "unlockDoor" | "unlockWithTimeout">;
    events: Pick<{
        doorLockAlarm: Event<TypeFromFields<{
            alarmCode: FieldType<DoorLock.AlarmCode>;
        }>, any>;
        lockOperation: 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: 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>;
    }, "doorLockAlarm" | "lockOperation" | "lockOperationError"> & Omit<unknown, "doorLockAlarm" | "lockOperation" | "lockOperationError"> & Omit<{
        doorLockAlarm: Event<TypeFromFields<{
            alarmCode: FieldType<DoorLock.AlarmCode>;
        }>, any>;
        lockOperation: 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: 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>;
    }, "doorLockAlarm" | "lockOperation" | "lockOperationError">;
    extensions: readonly [{
        component: {
            attributes: {
                doorClosedEvents: OptionalWritableAttribute<number, any>;
                doorOpenEvents: OptionalWritableAttribute<number, any>;
                doorState: Attribute<null | DoorLock.DoorState, any>;
                openPeriod: OptionalWritableAttribute<number, any>;
            };
            events: {
                doorStateChange: Event<TypeFromFields<{
                    doorState: FieldType<DoorLock.DoorState>;
                }>, any>;
            };
        };
        flags: {
            doorPositionSensor: true;
        };
    }, {
        component: {
            attributes: {
                enableLogging: WritableAttribute<boolean, any>;
                numberOfLogRecordsSupported: FixedAttribute<number, any>;
            };
            commands: {
                getLogRecord: Command<TypeFromFields<{
                    logIndex: FieldType<number>;
                }>, TypeFromFields<{
                    eventId: FieldType<number>;
                    eventType: FieldType<DoorLock.EventType>;
                    logEntryId: FieldType<number>;
                    pin: FieldType<Uint8Array>;
                    source: FieldType<DoorLock.EventSource>;
                    timestamp: FieldType<number>;
                    userId: FieldType<number>;
                }>, any>;
            };
        };
        flags: {
            logging: true;
        };
    }, {
        component: {
            attributes: {
                credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                    dual: BitFlag;
                    single: BitFlag;
                    tri: BitFlag;
                }>, any>;
                expiringUserTimeout: OptionalWritableAttribute<number, any>;
                numberOfCredentialsSupportedPerUser: FixedAttribute<number, any>;
                numberOfTotalUsersSupported: FixedAttribute<number, any>;
            };
            commands: {
                clearCredential: Command<TypeFromFields<{
                    credential: FieldType<null | TypeFromFields<{
                        credentialIndex: ...;
                        credentialType: ...;
                    }>>;
                }>, void, any>;
                clearUser: Command<TypeFromFields<{
                    userIndex: FieldType<number>;
                }>, void, any>;
                getCredentialStatus: Command<TypeFromFields<{
                    credential: FieldType<TypeFromFields<{
                        credentialIndex: FieldType<(...)>;
                        credentialType: FieldType<(...)>;
                    }>>;
                }>, TypeFromFields<{
                    creatorFabricIndex: FieldType<null | FabricIndex>;
                    credentialExists: FieldType<boolean>;
                    lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                    nextCredentialIndex: OptionalFieldType<null | number>;
                    userIndex: FieldType<null | number>;
                }>, any>;
                getUser: Command<TypeFromFields<{
                    userIndex: FieldType<number>;
                }>, TypeFromFields<{
                    creatorFabricIndex: FieldType<null | FabricIndex>;
                    credentialRule: FieldType<null | DoorLock.CredentialRule>;
                    credentials: FieldType<null | TypeFromFields<(...)>[]>;
                    lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                    nextUserIndex: FieldType<null | number>;
                    userIndex: FieldType<number>;
                    userName: FieldType<null | string>;
                    userStatus: FieldType<null | DoorLock.UserStatus>;
                    userType: FieldType<null | DoorLock.UserType>;
                    userUniqueId: FieldType<null | number>;
                }>, any>;
                setCredential: Command<TypeFromFields<{
                    credential: FieldType<TypeFromFields<{
                        credentialIndex: FieldType<(...)>;
                        credentialType: FieldType<(...)>;
                    }>>;
                    credentialData: FieldType<Uint8Array>;
                    operationType: FieldType<DoorLock.DataOperationType>;
                    userIndex: FieldType<null | number>;
                    userStatus: FieldType<null | DoorLock.UserStatus>;
                    userType: FieldType<null | DoorLock.UserType>;
                }>, TypeFromFields<{
                    nextCredentialIndex: OptionalFieldType<null | number>;
                    status: FieldType<Status>;
                    userIndex: FieldType<null | number>;
                }>, any>;
                setUser: Command<TypeFromFields<{
                    credentialRule: FieldType<null | DoorLock.CredentialRule>;
                    operationType: FieldType<DoorLock.DataOperationType>;
                    userIndex: FieldType<number>;
                    userName: FieldType<null | string>;
                    userStatus: FieldType<null | DoorLock.UserStatus>;
                    userType: FieldType<null | DoorLock.UserType>;
                    userUniqueId: FieldType<null | number>;
                }>, void, any>;
            };
            events: {
                lockUserChange: Event<TypeFromFields<{
                    dataIndex: FieldType<null | number>;
                    dataOperationType: FieldType<DoorLock.DataOperationType>;
                    fabricIndex: FieldType<null | FabricIndex>;
                    lockDataType: FieldType<DoorLock.LockDataType>;
                    operationSource: FieldType<DoorLock.OperationSource>;
                    sourceNode: FieldType<null | NodeId>;
                    userIndex: FieldType<null | number>;
                }>, any>;
            };
        };
        flags: {
            user: true;
        };
    }, {
        component: {
            attributes: {
                maxPinCodeLength: FixedAttribute<number, any>;
                minPinCodeLength: FixedAttribute<number, any>;
                numberOfPinUsersSupported: FixedAttribute<number, any>;
            };
        };
        flags: {
            pinCredential: true;
        };
    }, {
        component: {
            attributes: {
                maxRfidCodeLength: FixedAttribute<number, any>;
                minRfidCodeLength: FixedAttribute<number, any>;
                numberOfRfidUsersSupported: FixedAttribute<number, any>;
            };
        };
        flags: {
            rfidCredential: true;
        };
    }, {
        component: {
            attributes: {
                numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
            };
            commands: {
                clearWeekDaySchedule: Command<TypeFromFields<{
                    userIndexUserId: FieldType<number>;
                    weekDayIndex: FieldType<number>;
                }>, void, any>;
                getWeekDaySchedule: Command<TypeFromFields<{
                    userIndexUserId: FieldType<number>;
                    weekDayIndex: FieldType<number>;
                }>, TypeFromFields<{
                    daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                        friday: BitFlag;
                        monday: BitFlag;
                        saturday: BitFlag;
                        sunday: BitFlag;
                        thursday: BitFlag;
                        tuesday: BitFlag;
                        wednesday: BitFlag;
                    }>>;
                    endHour: OptionalFieldType<number>;
                    endMinute: OptionalFieldType<number>;
                    startHour: OptionalFieldType<number>;
                    startMinute: OptionalFieldType<number>;
                    status: FieldType<Status>;
                    userIndexUserId: FieldType<number>;
                    weekDayIndex: FieldType<number>;
                }>, any>;
                setWeekDaySchedule: Command<TypeFromFields<{
                    daysMask: FieldType<TypeFromPartialBitSchema<{
                        friday: BitFlag;
                        monday: BitFlag;
                        saturday: BitFlag;
                        sunday: BitFlag;
                        thursday: BitFlag;
                        tuesday: BitFlag;
                        wednesday: BitFlag;
                    }>>;
                    endHour: FieldType<number>;
                    endMinute: FieldType<number>;
                    startHour: FieldType<number>;
                    startMinute: FieldType<number>;
                    userIndexUserId: FieldType<number>;
                    weekDayIndex: FieldType<number>;
                }>, void, any>;
            };
        };
        flags: {
            weekDayAccessSchedules: true;
        };
    }, {
        component: {
            attributes: {
                numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
            };
            commands: {
                clearYearDaySchedule: Command<TypeFromFields<{
                    userIndexUserId: FieldType<number>;
                    yearDayIndex: FieldType<number>;
                }>, void, any>;
                getYearDaySchedule: Command<TypeFromFields<{
                    userIndexUserId: FieldType<number>;
                    yearDayIndex: FieldType<number>;
                }>, TypeFromFields<{
                    localEndTime: OptionalFieldType<number>;
                    localStartTime: OptionalFieldType<number>;
                    status: FieldType<Status>;
                    userIndexUserId: FieldType<number>;
                    yearDayIndex: FieldType<number>;
                }>, any>;
                setYearDaySchedule: Command<TypeFromFields<{
                    localEndTime: FieldType<number>;
                    localStartTime: FieldType<number>;
                    userIndexUserId: FieldType<number>;
                    yearDayIndex: FieldType<number>;
                }>, void, any>;
            };
        };
        flags: {
            yearDayAccessSchedules: true;
        };
    }, {
        component: {
            attributes: {
                numberOfHolidaySchedulesSupported: FixedAttribute<number, any>;
            };
            commands: {
                clearHolidaySchedule: Command<TypeFromFields<{
                    holidayIndex: FieldType<number>;
                }>, void, any>;
                getHolidaySchedule: Command<TypeFromFields<{
                    holidayIndex: FieldType<number>;
                }>, TypeFromFields<{
                    holidayIndex: FieldType<number>;
                    localEndTime: OptionalFieldType<null | number>;
                    localStartTime: OptionalFieldType<null | number>;
                    operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                    status: FieldType<Status>;
                }>, any>;
                setHolidaySchedule: Command<TypeFromFields<{
                    holidayIndex: FieldType<number>;
                    localEndTime: FieldType<number>;
                    localStartTime: FieldType<number>;
                    operatingMode: FieldType<DoorLock.OperatingMode>;
                }>, void, any>;
            };
        };
        flags: {
            holidaySchedules: true;
        };
    }, {
        component: {
            attributes: {
                userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                wrongCodeEntryLimit: WritableAttribute<number, any>;
            };
        };
        flags: {
            pinCredential: true;
        };
    }, {
        component: {
            attributes: {
                userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                wrongCodeEntryLimit: WritableAttribute<number, any>;
            };
        };
        flags: {
            rfidCredential: true;
        };
    }, {
        component: {
            attributes: {
                sendPinOverTheAir: OptionalWritableAttribute<boolean, any>;
            };
            commands: {
                clearAllPinCodes: Command<void, void, any>;
                clearPinCode: Command<TypeFromFields<{
                    pinSlotIndex: FieldType<number>;
                }>, void, any>;
                getPinCode: Command<TypeFromFields<{
                    userId: FieldType<number>;
                }>, TypeFromFields<{
                    pinCode: FieldType<null | Uint8Array>;
                    userId: FieldType<number>;
                    userStatus: FieldType<null | DoorLock.UserStatus>;
                    userType: FieldType<null | DoorLock.UserType>;
                }>, any>;
                setPinCode: Command<TypeFromFields<{
                    pin: FieldType<Uint8Array>;
                    userId: FieldType<number>;
                    userStatus: FieldType<null | DoorLock.UserStatus>;
                    userType: FieldType<null | DoorLock.UserType>;
                }>, void, any>;
            };
        };
        flags: {
            pinCredential: true;
            user: false;
        };
    }, {
        component: {
            attributes: {
                requirePinForRemoteOperation: WritableAttribute<boolean, any>;
            };
        };
        flags: {
            credentialOverTheAirAccess: true;
            pinCredential: true;
        };
    }, {
        component: {
            attributes: {
                keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    bit0: BitFlag;
                    bit1: BitFlag;
                    bit10: BitFlag;
                    bit11: BitFlag;
                    bit12: BitFlag;
                    bit13: BitFlag;
                    bit14: BitFlag;
                    bit15: BitFlag;
                    bit2: BitFlag;
                    bit3: BitFlag;
                    bit4: BitFlag;
                    bit5: BitFlag;
                    bit6: BitFlag;
                    bit7: BitFlag;
                    bit8: BitFlag;
                    bit9: BitFlag;
                }>, any>;
                keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    pinAdded: BitFlag;
                    pinChanged: BitFlag;
                    pinCleared: BitFlag;
                    pinCodeChanged: BitFlag;
                    unknown: BitFlag;
                }>, any>;
            };
        };
        flags: {
            notification: true;
            pinCredential: true;
        };
    }, {
        component: {
            attributes: {
                manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    bit0: BitFlag;
                    bit1: BitFlag;
                    bit10: BitFlag;
                    bit11: BitFlag;
                    bit12: BitFlag;
                    bit13: BitFlag;
                    bit14: BitFlag;
                    bit15: BitFlag;
                    bit2: BitFlag;
                    bit3: BitFlag;
                    bit4: BitFlag;
                    bit5: BitFlag;
                    bit6: BitFlag;
                    bit7: BitFlag;
                    bit8: BitFlag;
                    bit9: BitFlag;
                }>, any>;
                remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    bit0: BitFlag;
                    bit1: BitFlag;
                    bit10: BitFlag;
                    bit11: BitFlag;
                    bit12: BitFlag;
                    bit13: BitFlag;
                    bit14: BitFlag;
                    bit15: BitFlag;
                    bit2: BitFlag;
                    bit3: BitFlag;
                    bit4: BitFlag;
                    bit5: BitFlag;
                    bit6: BitFlag;
                    bit7: BitFlag;
                    bit8: BitFlag;
                    bit9: BitFlag;
                }>, any>;
                remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    pinAdded: BitFlag;
                    pinChanged: BitFlag;
                    pinCleared: BitFlag;
                    rfidCodeAdded: BitFlag;
                    rfidCodeCleared: BitFlag;
                    unknown: BitFlag;
                }>, any>;
            };
        };
        flags: {
            notification: true;
        };
    }, {
        component: {
            attributes: {
                rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    bit0: BitFlag;
                    bit1: BitFlag;
                    bit10: BitFlag;
                    bit11: BitFlag;
                    bit12: BitFlag;
                    bit13: BitFlag;
                    bit14: BitFlag;
                    bit15: BitFlag;
                    bit2: BitFlag;
                    bit3: BitFlag;
                    bit4: BitFlag;
                    bit5: BitFlag;
                    bit6: BitFlag;
                    bit7: BitFlag;
                    bit8: BitFlag;
                    bit9: BitFlag;
                }>, any>;
                rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    idAdded: BitFlag;
                    idCleared: BitFlag;
                    unknown: BitFlag;
                }>, any>;
            };
        };
        flags: {
            notification: true;
            rfidCredential: true;
        };
    }, {
        component: {
            commands: {
                getUserStatus: OptionalCommand<TypeFromFields<{
                    userId: FieldType<number>;
                }>, TypeFromFields<{
                    userId: FieldType<number>;
                    userStatus: FieldType<DoorLock.UserStatus>;
                }>, any>;
                getUserType: OptionalCommand<TypeFromFields<{
                    userId: FieldType<number>;
                }>, TypeFromFields<{
                    userId: FieldType<number>;
                    userType: FieldType<DoorLock.UserType>;
                }>, any>;
                setUserStatus: OptionalCommand<TypeFromFields<{
                    userId: FieldType<number>;
                    userStatus: FieldType<DoorLock.UserStatus>;
                }>, void, any>;
                setUserType: OptionalCommand<TypeFromFields<{
                    userId: FieldType<number>;
                    userType: FieldType<DoorLock.UserType>;
                }>, void, any>;
            };
        };
        flags: {
            fingerCredentials: true;
            pinCredential: true;
            rfidCredential: true;
            user: false;
        };
    }, {
        component: {};
        flags: {
            user: false;
        };
    }, {
        component: {
            commands: {
                clearAllRfidCodes: Command<void, void, any>;
                clearRfidCode: Command<TypeFromFields<{
                    rfidSlotIndex: FieldType<number>;
                }>, void, any>;
                getRfidCode: Command<TypeFromFields<{
                    userId: FieldType<number>;
                }>, TypeFromFields<{
                    rfidCode: FieldType<null | Uint8Array>;
                    userId: FieldType<number>;
                    userStatus: FieldType<null | DoorLock.UserStatus>;
                    userType: FieldType<null | DoorLock.UserType>;
                }>, any>;
                setRfidCode: Command<TypeFromFields<{
                    rfidCode: FieldType<Uint8Array>;
                    userId: FieldType<number>;
                    userStatus: FieldType<null | DoorLock.UserStatus>;
                    userType: FieldType<null | DoorLock.UserType>;
                }>, void, any>;
            };
        };
        flags: {
            rfidCredential: true;
            user: false;
        };
    }, {
        component: {
            commands: {
                unboltDoor: Command<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                }>, void, any>;
            };
        };
        flags: {
            unbolting: true;
        };
    }, {
        component: false;
        flags: {
            faceCredentials: true;
            fingerCredentials: true;
            pinCredential: true;
            rfidCredential: true;
            user: true;
        };
    }];
    features: {
        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;
    };
    id: Branded<257, "ClusterId">;
    name: "DoorLock";
    revision: 7;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
        };
        base: Of<{
            attributes: {
                actuatorEnabled: Attribute<boolean, any>;
                alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    doorForcedOpen: BitFlag;
                    frontEscutcheonRemoved: BitFlag;
                    lockFactoryReset: BitFlag;
                    lockJammed: BitFlag;
                    lockRadioPowerCycled: BitFlag;
                    na: BitFlag;
                    wrongCodeEntryLimit: BitFlag;
                }>, any>;
                autoRelockTime: OptionalWritableAttribute<number, any>;
                defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                    autoRelockTime: BitFlag;
                    keypadInterface: BitFlag;
                    ledSettings: BitFlag;
                    localProgramming: BitFlag;
                    remoteInterface: BitFlag;
                    soundVolume: BitFlag;
                }>, any>;
                enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
                enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
                enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
                enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
                language: OptionalWritableAttribute<string, any>;
                ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
                localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    addUsersCredentialsSchedules: BitFlag;
                    adjustSettings: BitFlag;
                    clearUsersCredentialsSchedules: BitFlag;
                    modifyUsersCredentialsSchedules: BitFlag;
                }>, any>;
                lockState: Attribute<null | DoorLock.LockState, any>;
                lockType: Attribute<DoorLock.LockType, any>;
                operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
                soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
                supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                    noRemoteLockUnlock: BitFlag;
                    normal: BitFlag;
                    passage: BitFlag;
                    privacy: BitFlag;
                    vacation: BitFlag;
                }>, any>;
            };
            commands: {
                lockDoor: Command<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                }>, void, any>;
                unlockDoor: Command<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                }>, void, any>;
                unlockWithTimeout: OptionalCommand<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                    timeout: FieldType<number>;
                }>, void, any>;
            };
            events: {
                doorLockAlarm: Event<TypeFromFields<{
                    alarmCode: FieldType<DoorLock.AlarmCode>;
                }>, any>;
                lockOperation: Event<TypeFromFields<{
                    credentials: OptionalFieldType<(...) | (...)>;
                    fabricIndex: FieldType<(...) | (...)>;
                    lockOperationType: FieldType<DoorLock.LockOperationType>;
                    operationSource: FieldType<DoorLock.OperationSource>;
                    sourceNode: FieldType<(...) | (...)>;
                    userIndex: FieldType<(...) | (...)>;
                }>, any>;
                lockOperationError: Event<TypeFromFields<{
                    credentials: OptionalFieldType<(...) | (...)>;
                    fabricIndex: FieldType<(...) | (...)>;
                    lockOperationType: FieldType<DoorLock.LockOperationType>;
                    operationError: FieldType<DoorLock.OperationError>;
                    operationSource: FieldType<DoorLock.OperationSource>;
                    sourceNode: FieldType<(...) | (...)>;
                    userIndex: FieldType<(...) | (...)>;
                }>, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        doorClosedEvents: OptionalWritableAttribute<number, any>;
                        doorOpenEvents: OptionalWritableAttribute<number, any>;
                        doorState: Attribute<(...) | (...), any>;
                        openPeriod: OptionalWritableAttribute<number, any>;
                    };
                    events: {
                        doorStateChange: Event<TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    doorPositionSensor: true;
                };
            }, {
                component: {
                    attributes: {
                        enableLogging: WritableAttribute<boolean, any>;
                        numberOfLogRecordsSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        getLogRecord: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    logging: true;
                };
            }, {
                component: {
                    attributes: {
                        credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        expiringUserTimeout: OptionalWritableAttribute<number, any>;
                        numberOfCredentialsSupportedPerUser: FixedAttribute<number, any>;
                        numberOfTotalUsersSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearCredential: Command<TypeFromFields<(...)>, void, any>;
                        clearUser: Command<TypeFromFields<(...)>, void, any>;
                        getCredentialStatus: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        getUser: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setCredential: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setUser: Command<TypeFromFields<(...)>, void, any>;
                    };
                    events: {
                        lockUserChange: Event<TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    user: true;
                };
            }, {
                component: {
                    attributes: {
                        maxPinCodeLength: FixedAttribute<number, any>;
                        minPinCodeLength: FixedAttribute<number, any>;
                        numberOfPinUsersSupported: FixedAttribute<number, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        maxRfidCodeLength: FixedAttribute<number, any>;
                        minRfidCodeLength: FixedAttribute<number, any>;
                        numberOfRfidUsersSupported: FixedAttribute<number, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearWeekDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getWeekDaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setWeekDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    weekDayAccessSchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearYearDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getYearDaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setYearDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    yearDayAccessSchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfHolidaySchedulesSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearHolidaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getHolidaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setHolidaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    holidaySchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                        wrongCodeEntryLimit: WritableAttribute<number, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                        wrongCodeEntryLimit: WritableAttribute<number, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        sendPinOverTheAir: OptionalWritableAttribute<boolean, any>;
                    };
                    commands: {
                        clearAllPinCodes: Command<void, void, any>;
                        clearPinCode: Command<TypeFromFields<(...)>, void, any>;
                        getPinCode: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setPinCode: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                    user: false;
                };
            }, {
                component: {
                    attributes: {
                        requirePinForRemoteOperation: WritableAttribute<boolean, any>;
                    };
                };
                flags: {
                    credentialOverTheAirAccess: true;
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                };
            }, {
                component: {
                    attributes: {
                        rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                    rfidCredential: true;
                };
            }, {
                component: {
                    commands: {
                        getUserStatus: OptionalCommand<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        getUserType: OptionalCommand<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setUserStatus: OptionalCommand<TypeFromFields<(...)>, void, any>;
                        setUserType: OptionalCommand<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    fingerCredentials: true;
                    pinCredential: true;
                    rfidCredential: true;
                    user: false;
                };
            }, {
                component: {};
                flags: {
                    user: false;
                };
            }, {
                component: {
                    commands: {
                        clearAllRfidCodes: Command<void, void, any>;
                        clearRfidCode: Command<TypeFromFields<(...)>, void, any>;
                        getRfidCode: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setRfidCode: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                    user: false;
                };
            }, {
                component: {
                    commands: {
                        unboltDoor: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    unbolting: true;
                };
            }, {
                component: false;
                flags: {
                    faceCredentials: true;
                    fingerCredentials: true;
                    pinCredential: true;
                    rfidCredential: true;
                    user: true;
                };
            }];
            features: {
                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;
            };
            id: 257;
            name: "DoorLock";
            revision: 7;
        }>;
        commands: {
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                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>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    doorClosedEvents: OptionalWritableAttribute<number, any>;
                    doorOpenEvents: OptionalWritableAttribute<number, any>;
                    doorState: Attribute<null | DoorLock.DoorState, any>;
                    openPeriod: OptionalWritableAttribute<number, any>;
                };
                events: {
                    doorStateChange: Event<TypeFromFields<{
                        doorState: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                doorPositionSensor: true;
            };
        }, {
            component: {
                attributes: {
                    enableLogging: WritableAttribute<boolean, any>;
                    numberOfLogRecordsSupported: FixedAttribute<number, any>;
                };
                commands: {
                    getLogRecord: Command<TypeFromFields<{
                        logIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        eventId: FieldType<(...)>;
                        eventType: FieldType<(...)>;
                        logEntryId: FieldType<(...)>;
                        pin: FieldType<(...)>;
                        source: FieldType<(...)>;
                        timestamp: FieldType<(...)>;
                        userId: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                logging: true;
            };
        }, {
            component: {
                attributes: {
                    credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        dual: BitFlag;
                        single: BitFlag;
                        tri: BitFlag;
                    }>, any>;
                    expiringUserTimeout: OptionalWritableAttribute<number, any>;
                    numberOfCredentialsSupportedPerUser: FixedAttribute<number, any>;
                    numberOfTotalUsersSupported: FixedAttribute<number, any>;
                };
                commands: {
                    clearCredential: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                    }>, void, any>;
                    clearUser: Command<TypeFromFields<{
                        userIndex: FieldType<(...)>;
                    }>, void, any>;
                    getCredentialStatus: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                    }>, TypeFromFields<{
                        creatorFabricIndex: FieldType<(...)>;
                        credentialExists: FieldType<(...)>;
                        lastModifiedFabricIndex: FieldType<(...)>;
                        nextCredentialIndex: OptionalFieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                    getUser: Command<TypeFromFields<{
                        userIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        creatorFabricIndex: FieldType<(...)>;
                        credentialRule: FieldType<(...)>;
                        credentials: FieldType<(...)>;
                        lastModifiedFabricIndex: FieldType<(...)>;
                        nextUserIndex: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userName: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                        userUniqueId: FieldType<(...)>;
                    }>, any>;
                    setCredential: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                        credentialData: FieldType<(...)>;
                        operationType: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, TypeFromFields<{
                        nextCredentialIndex: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                    setUser: Command<TypeFromFields<{
                        credentialRule: FieldType<(...)>;
                        operationType: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userName: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                        userUniqueId: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    lockUserChange: Event<TypeFromFields<{
                        dataIndex: FieldType<(...)>;
                        dataOperationType: FieldType<(...)>;
                        fabricIndex: FieldType<(...)>;
                        lockDataType: FieldType<(...)>;
                        operationSource: FieldType<(...)>;
                        sourceNode: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                user: true;
            };
        }, {
            component: {
                attributes: {
                    maxPinCodeLength: FixedAttribute<number, any>;
                    minPinCodeLength: FixedAttribute<number, any>;
                    numberOfPinUsersSupported: FixedAttribute<number, any>;
                };
            };
            flags: {
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    maxRfidCodeLength: FixedAttribute<number, any>;
                    minRfidCodeLength: FixedAttribute<number, any>;
                    numberOfRfidUsersSupported: FixedAttribute<number, any>;
                };
            };
            flags: {
                rfidCredential: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                };
                commands: {
                    clearWeekDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getWeekDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        daysMask: OptionalFieldType<(...)>;
                        endHour: OptionalFieldType<(...)>;
                        endMinute: OptionalFieldType<(...)>;
                        startHour: OptionalFieldType<(...)>;
                        startMinute: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, any>;
                    setWeekDaySchedule: Command<TypeFromFields<{
                        daysMask: FieldType<(...)>;
                        endHour: FieldType<(...)>;
                        endMinute: FieldType<(...)>;
                        startHour: FieldType<(...)>;
                        startMinute: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                weekDayAccessSchedules: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                };
                commands: {
                    clearYearDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getYearDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        localEndTime: OptionalFieldType<(...)>;
                        localStartTime: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, any>;
                    setYearDaySchedule: Command<TypeFromFields<{
                        localEndTime: FieldType<(...)>;
                        localStartTime: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                yearDayAccessSchedules: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfHolidaySchedulesSupported: FixedAttribute<number, any>;
                };
                commands: {
                    clearHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                        localEndTime: OptionalFieldType<(...)>;
                        localStartTime: OptionalFieldType<(...)>;
                        operatingMode: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                    setHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                        localEndTime: FieldType<(...)>;
                        localStartTime: FieldType<(...)>;
                        operatingMode: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                holidaySchedules: true;
            };
        }, {
            component: {
                attributes: {
                    userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                    wrongCodeEntryLimit: WritableAttribute<number, any>;
                };
            };
            flags: {
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                    wrongCodeEntryLimit: WritableAttribute<number, any>;
                };
            };
            flags: {
                rfidCredential: true;
            };
        }, {
            component: {
                attributes: {
                    sendPinOverTheAir: OptionalWritableAttribute<boolean, any>;
                };
                commands: {
                    clearAllPinCodes: Command<void, void, any>;
                    clearPinCode: Command<TypeFromFields<{
                        pinSlotIndex: FieldType<(...)>;
                    }>, void, any>;
                    getPinCode: Command<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setPinCode: Command<TypeFromFields<{
                        pin: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinCredential: true;
                user: false;
            };
        }, {
            component: {
                attributes: {
                    requirePinForRemoteOperation: WritableAttribute<boolean, any>;
                };
            };
            flags: {
                credentialOverTheAirAccess: true;
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        pinAdded: BitFlag;
                        pinChanged: BitFlag;
                        pinCleared: BitFlag;
                        pinCodeChanged: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        pinAdded: BitFlag;
                        pinChanged: BitFlag;
                        pinCleared: BitFlag;
                        rfidCodeAdded: BitFlag;
                        rfidCodeCleared: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
            };
        }, {
            component: {
                attributes: {
                    rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        idAdded: BitFlag;
                        idCleared: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
                rfidCredential: true;
            };
        }, {
            component: {
                commands: {
                    getUserStatus: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                    }>, any>;
                    getUserType: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        userId: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setUserStatus: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                    }>, void, any>;
                    setUserType: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                fingerCredentials: true;
                pinCredential: true;
                rfidCredential: true;
                user: false;
            };
        }, {
            component: {};
            flags: {
                user: false;
            };
        }, {
            component: {
                commands: {
                    clearAllRfidCodes: Command<void, void, any>;
                    clearRfidCode: Command<TypeFromFields<{
                        rfidSlotIndex: FieldType<(...)>;
                    }>, void, any>;
                    getRfidCode: Command<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        rfidCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setRfidCode: Command<TypeFromFields<{
                        rfidCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                rfidCredential: true;
                user: false;
            };
        }, {
            component: {
                commands: {
                    unboltDoor: Command<TypeFromFields<{
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                unbolting: true;
            };
        }, {
            component: false;
            flags: {
                faceCredentials: true;
                fingerCredentials: true;
                pinCredential: true;
                rfidCredential: true;
                user: true;
            };
        }];
        features: {
            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;
        };
        id: 257;
        name: "DoorLock";
        revision: 7;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
        };
        base: Of<{
            attributes: {
                actuatorEnabled: Attribute<boolean, any>;
                alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    doorForcedOpen: BitFlag;
                    frontEscutcheonRemoved: BitFlag;
                    lockFactoryReset: BitFlag;
                    lockJammed: BitFlag;
                    lockRadioPowerCycled: BitFlag;
                    na: BitFlag;
                    wrongCodeEntryLimit: BitFlag;
                }>, any>;
                autoRelockTime: OptionalWritableAttribute<number, any>;
                defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                    autoRelockTime: BitFlag;
                    keypadInterface: BitFlag;
                    ledSettings: BitFlag;
                    localProgramming: BitFlag;
                    remoteInterface: BitFlag;
                    soundVolume: BitFlag;
                }>, any>;
                enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
                enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
                enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
                enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
                language: OptionalWritableAttribute<string, any>;
                ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
                localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    addUsersCredentialsSchedules: BitFlag;
                    adjustSettings: BitFlag;
                    clearUsersCredentialsSchedules: BitFlag;
                    modifyUsersCredentialsSchedules: BitFlag;
                }>, any>;
                lockState: Attribute<null | DoorLock.LockState, any>;
                lockType: Attribute<DoorLock.LockType, any>;
                operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
                soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
                supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                    noRemoteLockUnlock: BitFlag;
                    normal: BitFlag;
                    passage: BitFlag;
                    privacy: BitFlag;
                    vacation: BitFlag;
                }>, any>;
            };
            commands: {
                lockDoor: Command<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                }>, void, any>;
                unlockDoor: Command<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                }>, void, any>;
                unlockWithTimeout: OptionalCommand<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                    timeout: FieldType<number>;
                }>, void, any>;
            };
            events: {
                doorLockAlarm: Event<TypeFromFields<{
                    alarmCode: FieldType<DoorLock.AlarmCode>;
                }>, any>;
                lockOperation: Event<TypeFromFields<{
                    credentials: OptionalFieldType<(...) | (...)>;
                    fabricIndex: FieldType<(...) | (...)>;
                    lockOperationType: FieldType<DoorLock.LockOperationType>;
                    operationSource: FieldType<DoorLock.OperationSource>;
                    sourceNode: FieldType<(...) | (...)>;
                    userIndex: FieldType<(...) | (...)>;
                }>, any>;
                lockOperationError: Event<TypeFromFields<{
                    credentials: OptionalFieldType<(...) | (...)>;
                    fabricIndex: FieldType<(...) | (...)>;
                    lockOperationType: FieldType<DoorLock.LockOperationType>;
                    operationError: FieldType<DoorLock.OperationError>;
                    operationSource: FieldType<DoorLock.OperationSource>;
                    sourceNode: FieldType<(...) | (...)>;
                    userIndex: FieldType<(...) | (...)>;
                }>, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        doorClosedEvents: OptionalWritableAttribute<number, any>;
                        doorOpenEvents: OptionalWritableAttribute<number, any>;
                        doorState: Attribute<(...) | (...), any>;
                        openPeriod: OptionalWritableAttribute<number, any>;
                    };
                    events: {
                        doorStateChange: Event<TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    doorPositionSensor: true;
                };
            }, {
                component: {
                    attributes: {
                        enableLogging: WritableAttribute<boolean, any>;
                        numberOfLogRecordsSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        getLogRecord: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    logging: true;
                };
            }, {
                component: {
                    attributes: {
                        credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        expiringUserTimeout: OptionalWritableAttribute<number, any>;
                        numberOfCredentialsSupportedPerUser: FixedAttribute<number, any>;
                        numberOfTotalUsersSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearCredential: Command<TypeFromFields<(...)>, void, any>;
                        clearUser: Command<TypeFromFields<(...)>, void, any>;
                        getCredentialStatus: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        getUser: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setCredential: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setUser: Command<TypeFromFields<(...)>, void, any>;
                    };
                    events: {
                        lockUserChange: Event<TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    user: true;
                };
            }, {
                component: {
                    attributes: {
                        maxPinCodeLength: FixedAttribute<number, any>;
                        minPinCodeLength: FixedAttribute<number, any>;
                        numberOfPinUsersSupported: FixedAttribute<number, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        maxRfidCodeLength: FixedAttribute<number, any>;
                        minRfidCodeLength: FixedAttribute<number, any>;
                        numberOfRfidUsersSupported: FixedAttribute<number, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearWeekDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getWeekDaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setWeekDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    weekDayAccessSchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearYearDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getYearDaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setYearDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    yearDayAccessSchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfHolidaySchedulesSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearHolidaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getHolidaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setHolidaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    holidaySchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                        wrongCodeEntryLimit: WritableAttribute<number, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                        wrongCodeEntryLimit: WritableAttribute<number, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        sendPinOverTheAir: OptionalWritableAttribute<boolean, any>;
                    };
                    commands: {
                        clearAllPinCodes: Command<void, void, any>;
                        clearPinCode: Command<TypeFromFields<(...)>, void, any>;
                        getPinCode: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setPinCode: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                    user: false;
                };
            }, {
                component: {
                    attributes: {
                        requirePinForRemoteOperation: WritableAttribute<boolean, any>;
                    };
                };
                flags: {
                    credentialOverTheAirAccess: true;
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                };
            }, {
                component: {
                    attributes: {
                        rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                    rfidCredential: true;
                };
            }, {
                component: {
                    commands: {
                        getUserStatus: OptionalCommand<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        getUserType: OptionalCommand<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setUserStatus: OptionalCommand<TypeFromFields<(...)>, void, any>;
                        setUserType: OptionalCommand<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    fingerCredentials: true;
                    pinCredential: true;
                    rfidCredential: true;
                    user: false;
                };
            }, {
                component: {};
                flags: {
                    user: false;
                };
            }, {
                component: {
                    commands: {
                        clearAllRfidCodes: Command<void, void, any>;
                        clearRfidCode: Command<TypeFromFields<(...)>, void, any>;
                        getRfidCode: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setRfidCode: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                    user: false;
                };
            }, {
                component: {
                    commands: {
                        unboltDoor: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    unbolting: true;
                };
            }, {
                component: false;
                flags: {
                    faceCredentials: true;
                    fingerCredentials: true;
                    pinCredential: true;
                    rfidCredential: true;
                    user: true;
                };
            }];
            features: {
                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;
            };
            id: 257;
            name: "DoorLock";
            revision: 7;
        }>;
        commands: {
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                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>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    doorClosedEvents: OptionalWritableAttribute<number, any>;
                    doorOpenEvents: OptionalWritableAttribute<number, any>;
                    doorState: Attribute<null | DoorLock.DoorState, any>;
                    openPeriod: OptionalWritableAttribute<number, any>;
                };
                events: {
                    doorStateChange: Event<TypeFromFields<{
                        doorState: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                doorPositionSensor: true;
            };
        }, {
            component: {
                attributes: {
                    enableLogging: WritableAttribute<boolean, any>;
                    numberOfLogRecordsSupported: FixedAttribute<number, any>;
                };
                commands: {
                    getLogRecord: Command<TypeFromFields<{
                        logIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        eventId: FieldType<(...)>;
                        eventType: FieldType<(...)>;
                        logEntryId: FieldType<(...)>;
                        pin: FieldType<(...)>;
                        source: FieldType<(...)>;
                        timestamp: FieldType<(...)>;
                        userId: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                logging: true;
            };
        }, {
            component: {
                attributes: {
                    credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        dual: BitFlag;
                        single: BitFlag;
                        tri: BitFlag;
                    }>, any>;
                    expiringUserTimeout: OptionalWritableAttribute<number, any>;
                    numberOfCredentialsSupportedPerUser: FixedAttribute<number, any>;
                    numberOfTotalUsersSupported: FixedAttribute<number, any>;
                };
                commands: {
                    clearCredential: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                    }>, void, any>;
                    clearUser: Command<TypeFromFields<{
                        userIndex: FieldType<(...)>;
                    }>, void, any>;
                    getCredentialStatus: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                    }>, TypeFromFields<{
                        creatorFabricIndex: FieldType<(...)>;
                        credentialExists: FieldType<(...)>;
                        lastModifiedFabricIndex: FieldType<(...)>;
                        nextCredentialIndex: OptionalFieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                    getUser: Command<TypeFromFields<{
                        userIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        creatorFabricIndex: FieldType<(...)>;
                        credentialRule: FieldType<(...)>;
                        credentials: FieldType<(...)>;
                        lastModifiedFabricIndex: FieldType<(...)>;
                        nextUserIndex: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userName: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                        userUniqueId: FieldType<(...)>;
                    }>, any>;
                    setCredential: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                        credentialData: FieldType<(...)>;
                        operationType: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, TypeFromFields<{
                        nextCredentialIndex: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                    setUser: Command<TypeFromFields<{
                        credentialRule: FieldType<(...)>;
                        operationType: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userName: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                        userUniqueId: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    lockUserChange: Event<TypeFromFields<{
                        dataIndex: FieldType<(...)>;
                        dataOperationType: FieldType<(...)>;
                        fabricIndex: FieldType<(...)>;
                        lockDataType: FieldType<(...)>;
                        operationSource: FieldType<(...)>;
                        sourceNode: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                user: true;
            };
        }, {
            component: {
                attributes: {
                    maxPinCodeLength: FixedAttribute<number, any>;
                    minPinCodeLength: FixedAttribute<number, any>;
                    numberOfPinUsersSupported: FixedAttribute<number, any>;
                };
            };
            flags: {
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    maxRfidCodeLength: FixedAttribute<number, any>;
                    minRfidCodeLength: FixedAttribute<number, any>;
                    numberOfRfidUsersSupported: FixedAttribute<number, any>;
                };
            };
            flags: {
                rfidCredential: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                };
                commands: {
                    clearWeekDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getWeekDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        daysMask: OptionalFieldType<(...)>;
                        endHour: OptionalFieldType<(...)>;
                        endMinute: OptionalFieldType<(...)>;
                        startHour: OptionalFieldType<(...)>;
                        startMinute: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, any>;
                    setWeekDaySchedule: Command<TypeFromFields<{
                        daysMask: FieldType<(...)>;
                        endHour: FieldType<(...)>;
                        endMinute: FieldType<(...)>;
                        startHour: FieldType<(...)>;
                        startMinute: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                weekDayAccessSchedules: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                };
                commands: {
                    clearYearDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getYearDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        localEndTime: OptionalFieldType<(...)>;
                        localStartTime: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, any>;
                    setYearDaySchedule: Command<TypeFromFields<{
                        localEndTime: FieldType<(...)>;
                        localStartTime: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                yearDayAccessSchedules: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfHolidaySchedulesSupported: FixedAttribute<number, any>;
                };
                commands: {
                    clearHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                        localEndTime: OptionalFieldType<(...)>;
                        localStartTime: OptionalFieldType<(...)>;
                        operatingMode: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                    setHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                        localEndTime: FieldType<(...)>;
                        localStartTime: FieldType<(...)>;
                        operatingMode: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                holidaySchedules: true;
            };
        }, {
            component: {
                attributes: {
                    userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                    wrongCodeEntryLimit: WritableAttribute<number, any>;
                };
            };
            flags: {
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                    wrongCodeEntryLimit: WritableAttribute<number, any>;
                };
            };
            flags: {
                rfidCredential: true;
            };
        }, {
            component: {
                attributes: {
                    sendPinOverTheAir: OptionalWritableAttribute<boolean, any>;
                };
                commands: {
                    clearAllPinCodes: Command<void, void, any>;
                    clearPinCode: Command<TypeFromFields<{
                        pinSlotIndex: FieldType<(...)>;
                    }>, void, any>;
                    getPinCode: Command<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setPinCode: Command<TypeFromFields<{
                        pin: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinCredential: true;
                user: false;
            };
        }, {
            component: {
                attributes: {
                    requirePinForRemoteOperation: WritableAttribute<boolean, any>;
                };
            };
            flags: {
                credentialOverTheAirAccess: true;
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        pinAdded: BitFlag;
                        pinChanged: BitFlag;
                        pinCleared: BitFlag;
                        pinCodeChanged: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        pinAdded: BitFlag;
                        pinChanged: BitFlag;
                        pinCleared: BitFlag;
                        rfidCodeAdded: BitFlag;
                        rfidCodeCleared: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
            };
        }, {
            component: {
                attributes: {
                    rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        idAdded: BitFlag;
                        idCleared: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
                rfidCredential: true;
            };
        }, {
            component: {
                commands: {
                    getUserStatus: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                    }>, any>;
                    getUserType: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        userId: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setUserStatus: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                    }>, void, any>;
                    setUserType: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                fingerCredentials: true;
                pinCredential: true;
                rfidCredential: true;
                user: false;
            };
        }, {
            component: {};
            flags: {
                user: false;
            };
        }, {
            component: {
                commands: {
                    clearAllRfidCodes: Command<void, void, any>;
                    clearRfidCode: Command<TypeFromFields<{
                        rfidSlotIndex: FieldType<(...)>;
                    }>, void, any>;
                    getRfidCode: Command<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        rfidCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setRfidCode: Command<TypeFromFields<{
                        rfidCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                rfidCredential: true;
                user: false;
            };
        }, {
            component: {
                commands: {
                    unboltDoor: Command<TypeFromFields<{
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                unbolting: true;
            };
        }, {
            component: false;
            flags: {
                faceCredentials: true;
                fingerCredentials: true;
                pinCredential: true;
                rfidCredential: true;
                user: true;
            };
        }];
        features: {
            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;
        };
        id: 257;
        name: "DoorLock";
        revision: 7;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
        };
        base: Of<{
            attributes: {
                actuatorEnabled: Attribute<boolean, any>;
                alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    doorForcedOpen: BitFlag;
                    frontEscutcheonRemoved: BitFlag;
                    lockFactoryReset: BitFlag;
                    lockJammed: BitFlag;
                    lockRadioPowerCycled: BitFlag;
                    na: BitFlag;
                    wrongCodeEntryLimit: BitFlag;
                }>, any>;
                autoRelockTime: OptionalWritableAttribute<number, any>;
                defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                    autoRelockTime: BitFlag;
                    keypadInterface: BitFlag;
                    ledSettings: BitFlag;
                    localProgramming: BitFlag;
                    remoteInterface: BitFlag;
                    soundVolume: BitFlag;
                }>, any>;
                enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
                enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
                enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
                enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
                language: OptionalWritableAttribute<string, any>;
                ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
                localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    addUsersCredentialsSchedules: BitFlag;
                    adjustSettings: BitFlag;
                    clearUsersCredentialsSchedules: BitFlag;
                    modifyUsersCredentialsSchedules: BitFlag;
                }>, any>;
                lockState: Attribute<null | DoorLock.LockState, any>;
                lockType: Attribute<DoorLock.LockType, any>;
                operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
                soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
                supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                    noRemoteLockUnlock: BitFlag;
                    normal: BitFlag;
                    passage: BitFlag;
                    privacy: BitFlag;
                    vacation: BitFlag;
                }>, any>;
            };
            commands: {
                lockDoor: Command<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                }>, void, any>;
                unlockDoor: Command<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                }>, void, any>;
                unlockWithTimeout: OptionalCommand<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                    timeout: FieldType<number>;
                }>, void, any>;
            };
            events: {
                doorLockAlarm: Event<TypeFromFields<{
                    alarmCode: FieldType<DoorLock.AlarmCode>;
                }>, any>;
                lockOperation: Event<TypeFromFields<{
                    credentials: OptionalFieldType<(...) | (...)>;
                    fabricIndex: FieldType<(...) | (...)>;
                    lockOperationType: FieldType<DoorLock.LockOperationType>;
                    operationSource: FieldType<DoorLock.OperationSource>;
                    sourceNode: FieldType<(...) | (...)>;
                    userIndex: FieldType<(...) | (...)>;
                }>, any>;
                lockOperationError: Event<TypeFromFields<{
                    credentials: OptionalFieldType<(...) | (...)>;
                    fabricIndex: FieldType<(...) | (...)>;
                    lockOperationType: FieldType<DoorLock.LockOperationType>;
                    operationError: FieldType<DoorLock.OperationError>;
                    operationSource: FieldType<DoorLock.OperationSource>;
                    sourceNode: FieldType<(...) | (...)>;
                    userIndex: FieldType<(...) | (...)>;
                }>, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        doorClosedEvents: OptionalWritableAttribute<number, any>;
                        doorOpenEvents: OptionalWritableAttribute<number, any>;
                        doorState: Attribute<(...) | (...), any>;
                        openPeriod: OptionalWritableAttribute<number, any>;
                    };
                    events: {
                        doorStateChange: Event<TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    doorPositionSensor: true;
                };
            }, {
                component: {
                    attributes: {
                        enableLogging: WritableAttribute<boolean, any>;
                        numberOfLogRecordsSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        getLogRecord: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    logging: true;
                };
            }, {
                component: {
                    attributes: {
                        credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        expiringUserTimeout: OptionalWritableAttribute<number, any>;
                        numberOfCredentialsSupportedPerUser: FixedAttribute<number, any>;
                        numberOfTotalUsersSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearCredential: Command<TypeFromFields<(...)>, void, any>;
                        clearUser: Command<TypeFromFields<(...)>, void, any>;
                        getCredentialStatus: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        getUser: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setCredential: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setUser: Command<TypeFromFields<(...)>, void, any>;
                    };
                    events: {
                        lockUserChange: Event<TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    user: true;
                };
            }, {
                component: {
                    attributes: {
                        maxPinCodeLength: FixedAttribute<number, any>;
                        minPinCodeLength: FixedAttribute<number, any>;
                        numberOfPinUsersSupported: FixedAttribute<number, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        maxRfidCodeLength: FixedAttribute<number, any>;
                        minRfidCodeLength: FixedAttribute<number, any>;
                        numberOfRfidUsersSupported: FixedAttribute<number, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearWeekDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getWeekDaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setWeekDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    weekDayAccessSchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearYearDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getYearDaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setYearDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    yearDayAccessSchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfHolidaySchedulesSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearHolidaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getHolidaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setHolidaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    holidaySchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                        wrongCodeEntryLimit: WritableAttribute<number, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                        wrongCodeEntryLimit: WritableAttribute<number, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        sendPinOverTheAir: OptionalWritableAttribute<boolean, any>;
                    };
                    commands: {
                        clearAllPinCodes: Command<void, void, any>;
                        clearPinCode: Command<TypeFromFields<(...)>, void, any>;
                        getPinCode: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setPinCode: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                    user: false;
                };
            }, {
                component: {
                    attributes: {
                        requirePinForRemoteOperation: WritableAttribute<boolean, any>;
                    };
                };
                flags: {
                    credentialOverTheAirAccess: true;
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                };
            }, {
                component: {
                    attributes: {
                        rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                    rfidCredential: true;
                };
            }, {
                component: {
                    commands: {
                        getUserStatus: OptionalCommand<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        getUserType: OptionalCommand<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setUserStatus: OptionalCommand<TypeFromFields<(...)>, void, any>;
                        setUserType: OptionalCommand<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    fingerCredentials: true;
                    pinCredential: true;
                    rfidCredential: true;
                    user: false;
                };
            }, {
                component: {};
                flags: {
                    user: false;
                };
            }, {
                component: {
                    commands: {
                        clearAllRfidCodes: Command<void, void, any>;
                        clearRfidCode: Command<TypeFromFields<(...)>, void, any>;
                        getRfidCode: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setRfidCode: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                    user: false;
                };
            }, {
                component: {
                    commands: {
                        unboltDoor: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    unbolting: true;
                };
            }, {
                component: false;
                flags: {
                    faceCredentials: true;
                    fingerCredentials: true;
                    pinCredential: true;
                    rfidCredential: true;
                    user: true;
                };
            }];
            features: {
                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;
            };
            id: 257;
            name: "DoorLock";
            revision: 7;
        }>;
        commands: {
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                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>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    doorClosedEvents: OptionalWritableAttribute<number, any>;
                    doorOpenEvents: OptionalWritableAttribute<number, any>;
                    doorState: Attribute<null | DoorLock.DoorState, any>;
                    openPeriod: OptionalWritableAttribute<number, any>;
                };
                events: {
                    doorStateChange: Event<TypeFromFields<{
                        doorState: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                doorPositionSensor: true;
            };
        }, {
            component: {
                attributes: {
                    enableLogging: WritableAttribute<boolean, any>;
                    numberOfLogRecordsSupported: FixedAttribute<number, any>;
                };
                commands: {
                    getLogRecord: Command<TypeFromFields<{
                        logIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        eventId: FieldType<(...)>;
                        eventType: FieldType<(...)>;
                        logEntryId: FieldType<(...)>;
                        pin: FieldType<(...)>;
                        source: FieldType<(...)>;
                        timestamp: FieldType<(...)>;
                        userId: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                logging: true;
            };
        }, {
            component: {
                attributes: {
                    credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        dual: BitFlag;
                        single: BitFlag;
                        tri: BitFlag;
                    }>, any>;
                    expiringUserTimeout: OptionalWritableAttribute<number, any>;
                    numberOfCredentialsSupportedPerUser: FixedAttribute<number, any>;
                    numberOfTotalUsersSupported: FixedAttribute<number, any>;
                };
                commands: {
                    clearCredential: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                    }>, void, any>;
                    clearUser: Command<TypeFromFields<{
                        userIndex: FieldType<(...)>;
                    }>, void, any>;
                    getCredentialStatus: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                    }>, TypeFromFields<{
                        creatorFabricIndex: FieldType<(...)>;
                        credentialExists: FieldType<(...)>;
                        lastModifiedFabricIndex: FieldType<(...)>;
                        nextCredentialIndex: OptionalFieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                    getUser: Command<TypeFromFields<{
                        userIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        creatorFabricIndex: FieldType<(...)>;
                        credentialRule: FieldType<(...)>;
                        credentials: FieldType<(...)>;
                        lastModifiedFabricIndex: FieldType<(...)>;
                        nextUserIndex: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userName: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                        userUniqueId: FieldType<(...)>;
                    }>, any>;
                    setCredential: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                        credentialData: FieldType<(...)>;
                        operationType: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, TypeFromFields<{
                        nextCredentialIndex: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                    setUser: Command<TypeFromFields<{
                        credentialRule: FieldType<(...)>;
                        operationType: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userName: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                        userUniqueId: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    lockUserChange: Event<TypeFromFields<{
                        dataIndex: FieldType<(...)>;
                        dataOperationType: FieldType<(...)>;
                        fabricIndex: FieldType<(...)>;
                        lockDataType: FieldType<(...)>;
                        operationSource: FieldType<(...)>;
                        sourceNode: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                user: true;
            };
        }, {
            component: {
                attributes: {
                    maxPinCodeLength: FixedAttribute<number, any>;
                    minPinCodeLength: FixedAttribute<number, any>;
                    numberOfPinUsersSupported: FixedAttribute<number, any>;
                };
            };
            flags: {
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    maxRfidCodeLength: FixedAttribute<number, any>;
                    minRfidCodeLength: FixedAttribute<number, any>;
                    numberOfRfidUsersSupported: FixedAttribute<number, any>;
                };
            };
            flags: {
                rfidCredential: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                };
                commands: {
                    clearWeekDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getWeekDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        daysMask: OptionalFieldType<(...)>;
                        endHour: OptionalFieldType<(...)>;
                        endMinute: OptionalFieldType<(...)>;
                        startHour: OptionalFieldType<(...)>;
                        startMinute: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, any>;
                    setWeekDaySchedule: Command<TypeFromFields<{
                        daysMask: FieldType<(...)>;
                        endHour: FieldType<(...)>;
                        endMinute: FieldType<(...)>;
                        startHour: FieldType<(...)>;
                        startMinute: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                weekDayAccessSchedules: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                };
                commands: {
                    clearYearDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getYearDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        localEndTime: OptionalFieldType<(...)>;
                        localStartTime: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, any>;
                    setYearDaySchedule: Command<TypeFromFields<{
                        localEndTime: FieldType<(...)>;
                        localStartTime: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                yearDayAccessSchedules: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfHolidaySchedulesSupported: FixedAttribute<number, any>;
                };
                commands: {
                    clearHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                        localEndTime: OptionalFieldType<(...)>;
                        localStartTime: OptionalFieldType<(...)>;
                        operatingMode: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                    setHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                        localEndTime: FieldType<(...)>;
                        localStartTime: FieldType<(...)>;
                        operatingMode: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                holidaySchedules: true;
            };
        }, {
            component: {
                attributes: {
                    userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                    wrongCodeEntryLimit: WritableAttribute<number, any>;
                };
            };
            flags: {
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                    wrongCodeEntryLimit: WritableAttribute<number, any>;
                };
            };
            flags: {
                rfidCredential: true;
            };
        }, {
            component: {
                attributes: {
                    sendPinOverTheAir: OptionalWritableAttribute<boolean, any>;
                };
                commands: {
                    clearAllPinCodes: Command<void, void, any>;
                    clearPinCode: Command<TypeFromFields<{
                        pinSlotIndex: FieldType<(...)>;
                    }>, void, any>;
                    getPinCode: Command<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setPinCode: Command<TypeFromFields<{
                        pin: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinCredential: true;
                user: false;
            };
        }, {
            component: {
                attributes: {
                    requirePinForRemoteOperation: WritableAttribute<boolean, any>;
                };
            };
            flags: {
                credentialOverTheAirAccess: true;
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        pinAdded: BitFlag;
                        pinChanged: BitFlag;
                        pinCleared: BitFlag;
                        pinCodeChanged: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        pinAdded: BitFlag;
                        pinChanged: BitFlag;
                        pinCleared: BitFlag;
                        rfidCodeAdded: BitFlag;
                        rfidCodeCleared: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
            };
        }, {
            component: {
                attributes: {
                    rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        idAdded: BitFlag;
                        idCleared: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
                rfidCredential: true;
            };
        }, {
            component: {
                commands: {
                    getUserStatus: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                    }>, any>;
                    getUserType: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        userId: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setUserStatus: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                    }>, void, any>;
                    setUserType: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                fingerCredentials: true;
                pinCredential: true;
                rfidCredential: true;
                user: false;
            };
        }, {
            component: {};
            flags: {
                user: false;
            };
        }, {
            component: {
                commands: {
                    clearAllRfidCodes: Command<void, void, any>;
                    clearRfidCode: Command<TypeFromFields<{
                        rfidSlotIndex: FieldType<(...)>;
                    }>, void, any>;
                    getRfidCode: Command<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        rfidCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setRfidCode: Command<TypeFromFields<{
                        rfidCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                rfidCredential: true;
                user: false;
            };
        }, {
            component: {
                commands: {
                    unboltDoor: Command<TypeFromFields<{
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                unbolting: true;
            };
        }, {
            component: false;
            flags: {
                faceCredentials: true;
                fingerCredentials: true;
                pinCredential: true;
                rfidCredential: true;
                user: true;
            };
        }];
        features: {
            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;
        };
        id: 257;
        name: "DoorLock";
        revision: 7;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
        };
        base: Of<{
            attributes: {
                actuatorEnabled: Attribute<boolean, any>;
                alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    doorForcedOpen: BitFlag;
                    frontEscutcheonRemoved: BitFlag;
                    lockFactoryReset: BitFlag;
                    lockJammed: BitFlag;
                    lockRadioPowerCycled: BitFlag;
                    na: BitFlag;
                    wrongCodeEntryLimit: BitFlag;
                }>, any>;
                autoRelockTime: OptionalWritableAttribute<number, any>;
                defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                    autoRelockTime: BitFlag;
                    keypadInterface: BitFlag;
                    ledSettings: BitFlag;
                    localProgramming: BitFlag;
                    remoteInterface: BitFlag;
                    soundVolume: BitFlag;
                }>, any>;
                enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
                enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
                enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
                enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
                language: OptionalWritableAttribute<string, any>;
                ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
                localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                    addUsersCredentialsSchedules: BitFlag;
                    adjustSettings: BitFlag;
                    clearUsersCredentialsSchedules: BitFlag;
                    modifyUsersCredentialsSchedules: BitFlag;
                }>, any>;
                lockState: Attribute<null | DoorLock.LockState, any>;
                lockType: Attribute<DoorLock.LockType, any>;
                operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
                soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
                supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                    noRemoteLockUnlock: BitFlag;
                    normal: BitFlag;
                    passage: BitFlag;
                    privacy: BitFlag;
                    vacation: BitFlag;
                }>, any>;
            };
            commands: {
                lockDoor: Command<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                }>, void, any>;
                unlockDoor: Command<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                }>, void, any>;
                unlockWithTimeout: OptionalCommand<TypeFromFields<{
                    pinCode: OptionalFieldType<Uint8Array>;
                    timeout: FieldType<number>;
                }>, void, any>;
            };
            events: {
                doorLockAlarm: Event<TypeFromFields<{
                    alarmCode: FieldType<DoorLock.AlarmCode>;
                }>, any>;
                lockOperation: Event<TypeFromFields<{
                    credentials: OptionalFieldType<(...) | (...)>;
                    fabricIndex: FieldType<(...) | (...)>;
                    lockOperationType: FieldType<DoorLock.LockOperationType>;
                    operationSource: FieldType<DoorLock.OperationSource>;
                    sourceNode: FieldType<(...) | (...)>;
                    userIndex: FieldType<(...) | (...)>;
                }>, any>;
                lockOperationError: Event<TypeFromFields<{
                    credentials: OptionalFieldType<(...) | (...)>;
                    fabricIndex: FieldType<(...) | (...)>;
                    lockOperationType: FieldType<DoorLock.LockOperationType>;
                    operationError: FieldType<DoorLock.OperationError>;
                    operationSource: FieldType<DoorLock.OperationSource>;
                    sourceNode: FieldType<(...) | (...)>;
                    userIndex: FieldType<(...) | (...)>;
                }>, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        doorClosedEvents: OptionalWritableAttribute<number, any>;
                        doorOpenEvents: OptionalWritableAttribute<number, any>;
                        doorState: Attribute<(...) | (...), any>;
                        openPeriod: OptionalWritableAttribute<number, any>;
                    };
                    events: {
                        doorStateChange: Event<TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    doorPositionSensor: true;
                };
            }, {
                component: {
                    attributes: {
                        enableLogging: WritableAttribute<boolean, any>;
                        numberOfLogRecordsSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        getLogRecord: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    logging: true;
                };
            }, {
                component: {
                    attributes: {
                        credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        expiringUserTimeout: OptionalWritableAttribute<number, any>;
                        numberOfCredentialsSupportedPerUser: FixedAttribute<number, any>;
                        numberOfTotalUsersSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearCredential: Command<TypeFromFields<(...)>, void, any>;
                        clearUser: Command<TypeFromFields<(...)>, void, any>;
                        getCredentialStatus: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        getUser: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setCredential: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setUser: Command<TypeFromFields<(...)>, void, any>;
                    };
                    events: {
                        lockUserChange: Event<TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    user: true;
                };
            }, {
                component: {
                    attributes: {
                        maxPinCodeLength: FixedAttribute<number, any>;
                        minPinCodeLength: FixedAttribute<number, any>;
                        numberOfPinUsersSupported: FixedAttribute<number, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        maxRfidCodeLength: FixedAttribute<number, any>;
                        minRfidCodeLength: FixedAttribute<number, any>;
                        numberOfRfidUsersSupported: FixedAttribute<number, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearWeekDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getWeekDaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setWeekDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    weekDayAccessSchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearYearDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getYearDaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setYearDaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    yearDayAccessSchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfHolidaySchedulesSupported: FixedAttribute<number, any>;
                    };
                    commands: {
                        clearHolidaySchedule: Command<TypeFromFields<(...)>, void, any>;
                        getHolidaySchedule: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setHolidaySchedule: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    holidaySchedules: true;
                };
            }, {
                component: {
                    attributes: {
                        userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                        wrongCodeEntryLimit: WritableAttribute<number, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                        wrongCodeEntryLimit: WritableAttribute<number, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        sendPinOverTheAir: OptionalWritableAttribute<boolean, any>;
                    };
                    commands: {
                        clearAllPinCodes: Command<void, void, any>;
                        clearPinCode: Command<TypeFromFields<(...)>, void, any>;
                        getPinCode: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setPinCode: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    pinCredential: true;
                    user: false;
                };
            }, {
                component: {
                    attributes: {
                        requirePinForRemoteOperation: WritableAttribute<boolean, any>;
                    };
                };
                flags: {
                    credentialOverTheAirAccess: true;
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                    pinCredential: true;
                };
            }, {
                component: {
                    attributes: {
                        manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                };
            }, {
                component: {
                    attributes: {
                        rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                        rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<(...)>, any>;
                    };
                };
                flags: {
                    notification: true;
                    rfidCredential: true;
                };
            }, {
                component: {
                    commands: {
                        getUserStatus: OptionalCommand<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        getUserType: OptionalCommand<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setUserStatus: OptionalCommand<TypeFromFields<(...)>, void, any>;
                        setUserType: OptionalCommand<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    fingerCredentials: true;
                    pinCredential: true;
                    rfidCredential: true;
                    user: false;
                };
            }, {
                component: {};
                flags: {
                    user: false;
                };
            }, {
                component: {
                    commands: {
                        clearAllRfidCodes: Command<void, void, any>;
                        clearRfidCode: Command<TypeFromFields<(...)>, void, any>;
                        getRfidCode: Command<TypeFromFields<(...)>, TypeFromFields<(...)>, any>;
                        setRfidCode: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    rfidCredential: true;
                    user: false;
                };
            }, {
                component: {
                    commands: {
                        unboltDoor: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    unbolting: true;
                };
            }, {
                component: false;
                flags: {
                    faceCredentials: true;
                    fingerCredentials: true;
                    pinCredential: true;
                    rfidCredential: true;
                    user: true;
                };
            }];
            features: {
                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;
            };
            id: 257;
            name: "DoorLock";
            revision: 7;
        }>;
        commands: {
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                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>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    doorClosedEvents: OptionalWritableAttribute<number, any>;
                    doorOpenEvents: OptionalWritableAttribute<number, any>;
                    doorState: Attribute<null | DoorLock.DoorState, any>;
                    openPeriod: OptionalWritableAttribute<number, any>;
                };
                events: {
                    doorStateChange: Event<TypeFromFields<{
                        doorState: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                doorPositionSensor: true;
            };
        }, {
            component: {
                attributes: {
                    enableLogging: WritableAttribute<boolean, any>;
                    numberOfLogRecordsSupported: FixedAttribute<number, any>;
                };
                commands: {
                    getLogRecord: Command<TypeFromFields<{
                        logIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        eventId: FieldType<(...)>;
                        eventType: FieldType<(...)>;
                        logEntryId: FieldType<(...)>;
                        pin: FieldType<(...)>;
                        source: FieldType<(...)>;
                        timestamp: FieldType<(...)>;
                        userId: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                logging: true;
            };
        }, {
            component: {
                attributes: {
                    credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        dual: BitFlag;
                        single: BitFlag;
                        tri: BitFlag;
                    }>, any>;
                    expiringUserTimeout: OptionalWritableAttribute<number, any>;
                    numberOfCredentialsSupportedPerUser: FixedAttribute<number, any>;
                    numberOfTotalUsersSupported: FixedAttribute<number, any>;
                };
                commands: {
                    clearCredential: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                    }>, void, any>;
                    clearUser: Command<TypeFromFields<{
                        userIndex: FieldType<(...)>;
                    }>, void, any>;
                    getCredentialStatus: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                    }>, TypeFromFields<{
                        creatorFabricIndex: FieldType<(...)>;
                        credentialExists: FieldType<(...)>;
                        lastModifiedFabricIndex: FieldType<(...)>;
                        nextCredentialIndex: OptionalFieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                    getUser: Command<TypeFromFields<{
                        userIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        creatorFabricIndex: FieldType<(...)>;
                        credentialRule: FieldType<(...)>;
                        credentials: FieldType<(...)>;
                        lastModifiedFabricIndex: FieldType<(...)>;
                        nextUserIndex: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userName: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                        userUniqueId: FieldType<(...)>;
                    }>, any>;
                    setCredential: Command<TypeFromFields<{
                        credential: FieldType<(...)>;
                        credentialData: FieldType<(...)>;
                        operationType: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, TypeFromFields<{
                        nextCredentialIndex: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                    setUser: Command<TypeFromFields<{
                        credentialRule: FieldType<(...)>;
                        operationType: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                        userName: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                        userUniqueId: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    lockUserChange: Event<TypeFromFields<{
                        dataIndex: FieldType<(...)>;
                        dataOperationType: FieldType<(...)>;
                        fabricIndex: FieldType<(...)>;
                        lockDataType: FieldType<(...)>;
                        operationSource: FieldType<(...)>;
                        sourceNode: FieldType<(...)>;
                        userIndex: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                user: true;
            };
        }, {
            component: {
                attributes: {
                    maxPinCodeLength: FixedAttribute<number, any>;
                    minPinCodeLength: FixedAttribute<number, any>;
                    numberOfPinUsersSupported: FixedAttribute<number, any>;
                };
            };
            flags: {
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    maxRfidCodeLength: FixedAttribute<number, any>;
                    minRfidCodeLength: FixedAttribute<number, any>;
                    numberOfRfidUsersSupported: FixedAttribute<number, any>;
                };
            };
            flags: {
                rfidCredential: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                };
                commands: {
                    clearWeekDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getWeekDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        daysMask: OptionalFieldType<(...)>;
                        endHour: OptionalFieldType<(...)>;
                        endMinute: OptionalFieldType<(...)>;
                        startHour: OptionalFieldType<(...)>;
                        startMinute: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, any>;
                    setWeekDaySchedule: Command<TypeFromFields<{
                        daysMask: FieldType<(...)>;
                        endHour: FieldType<(...)>;
                        endMinute: FieldType<(...)>;
                        startHour: FieldType<(...)>;
                        startMinute: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        weekDayIndex: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                weekDayAccessSchedules: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any>;
                };
                commands: {
                    clearYearDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getYearDaySchedule: Command<TypeFromFields<{
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        localEndTime: OptionalFieldType<(...)>;
                        localStartTime: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, any>;
                    setYearDaySchedule: Command<TypeFromFields<{
                        localEndTime: FieldType<(...)>;
                        localStartTime: FieldType<(...)>;
                        userIndexUserId: FieldType<(...)>;
                        yearDayIndex: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                yearDayAccessSchedules: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfHolidaySchedulesSupported: FixedAttribute<number, any>;
                };
                commands: {
                    clearHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                    }>, void, any>;
                    getHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                    }>, TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                        localEndTime: OptionalFieldType<(...)>;
                        localStartTime: OptionalFieldType<(...)>;
                        operatingMode: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                    setHolidaySchedule: Command<TypeFromFields<{
                        holidayIndex: FieldType<(...)>;
                        localEndTime: FieldType<(...)>;
                        localStartTime: FieldType<(...)>;
                        operatingMode: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                holidaySchedules: true;
            };
        }, {
            component: {
                attributes: {
                    userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                    wrongCodeEntryLimit: WritableAttribute<number, any>;
                };
            };
            flags: {
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    userCodeTemporaryDisableTime: WritableAttribute<number, any>;
                    wrongCodeEntryLimit: WritableAttribute<number, any>;
                };
            };
            flags: {
                rfidCredential: true;
            };
        }, {
            component: {
                attributes: {
                    sendPinOverTheAir: OptionalWritableAttribute<boolean, any>;
                };
                commands: {
                    clearAllPinCodes: Command<void, void, any>;
                    clearPinCode: Command<TypeFromFields<{
                        pinSlotIndex: FieldType<(...)>;
                    }>, void, any>;
                    getPinCode: Command<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        pinCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setPinCode: Command<TypeFromFields<{
                        pin: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                pinCredential: true;
                user: false;
            };
        }, {
            component: {
                attributes: {
                    requirePinForRemoteOperation: WritableAttribute<boolean, any>;
                };
            };
            flags: {
                credentialOverTheAirAccess: true;
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        pinAdded: BitFlag;
                        pinChanged: BitFlag;
                        pinCleared: BitFlag;
                        pinCodeChanged: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
                pinCredential: true;
            };
        }, {
            component: {
                attributes: {
                    manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        pinAdded: BitFlag;
                        pinChanged: BitFlag;
                        pinCleared: BitFlag;
                        rfidCodeAdded: BitFlag;
                        rfidCodeCleared: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
            };
        }, {
            component: {
                attributes: {
                    rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        bit0: BitFlag;
                        bit1: BitFlag;
                        bit10: BitFlag;
                        bit11: BitFlag;
                        bit12: BitFlag;
                        bit13: BitFlag;
                        bit14: BitFlag;
                        bit15: BitFlag;
                        bit2: BitFlag;
                        bit3: BitFlag;
                        bit4: BitFlag;
                        bit5: BitFlag;
                        bit6: BitFlag;
                        bit7: BitFlag;
                        bit8: BitFlag;
                        bit9: BitFlag;
                    }>, any>;
                    rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                        idAdded: BitFlag;
                        idCleared: BitFlag;
                        unknown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                notification: true;
                rfidCredential: true;
            };
        }, {
            component: {
                commands: {
                    getUserStatus: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                    }>, any>;
                    getUserType: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        userId: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setUserStatus: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                    }>, void, any>;
                    setUserType: OptionalCommand<TypeFromFields<{
                        userId: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                fingerCredentials: true;
                pinCredential: true;
                rfidCredential: true;
                user: false;
            };
        }, {
            component: {};
            flags: {
                user: false;
            };
        }, {
            component: {
                commands: {
                    clearAllRfidCodes: Command<void, void, any>;
                    clearRfidCode: Command<TypeFromFields<{
                        rfidSlotIndex: FieldType<(...)>;
                    }>, void, any>;
                    getRfidCode: Command<TypeFromFields<{
                        userId: FieldType<(...)>;
                    }>, TypeFromFields<{
                        rfidCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, any>;
                    setRfidCode: Command<TypeFromFields<{
                        rfidCode: FieldType<(...)>;
                        userId: FieldType<(...)>;
                        userStatus: FieldType<(...)>;
                        userType: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                rfidCredential: true;
                user: false;
            };
        }, {
            component: {
                commands: {
                    unboltDoor: Command<TypeFromFields<{
                        pinCode: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                unbolting: true;
            };
        }, {
            component: false;
            flags: {
                faceCredentials: true;
                fingerCredentials: true;
                pinCredential: true;
                rfidCredential: true;
                user: true;
            };
        }];
        features: {
            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;
        };
        id: 257;
        name: "DoorLock";
        revision: 7;
    }>, SelectionT>;
}