Interface Complete

interface Complete {
    attributes: Merge<{
        acceptedCommandList: Attribute<CommandId[], never>;
        actuatorEnabled: Attribute<boolean, any>;
        alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            doorForcedOpen: BitFlag;
            frontEscutcheonRemoved: BitFlag;
            lockFactoryReset: BitFlag;
            lockJammed: BitFlag;
            lockRadioPowerCycled: BitFlag;
            na: BitFlag;
            wrongCodeEntryLimit: BitFlag;
        }>, any>;
        attributeList: Attribute<AttributeId[], never>;
        autoRelockTime: OptionalWritableAttribute<number, any>;
        clusterRevision: Attribute<number, never>;
        credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
            dual: BitFlag;
            single: BitFlag;
            tri: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
            autoRelockTime: BitFlag;
            keypadInterface: BitFlag;
            ledSettings: BitFlag;
            localProgramming: BitFlag;
            remoteInterface: BitFlag;
            soundVolume: BitFlag;
        }>, any>;
        doorClosedEvents: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                doorPositionSensor: boolean;
            }];
        };
        doorOpenEvents: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                doorPositionSensor: boolean;
            }];
        };
        doorState: Attribute<null | DoorLock.DoorState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                doorPositionSensor: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
        enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
        enableLogging: WritableAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                logging: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
        enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
        expiringUserTimeout: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                user: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            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;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        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> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
                pinCredential: boolean;
            }];
        };
        keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            pinAdded: BitFlag;
            pinChanged: BitFlag;
            pinCleared: BitFlag;
            pinCodeChanged: BitFlag;
            unknown: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
                pinCredential: boolean;
            }];
        };
        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>;
        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> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
            }];
        };
        maxPinCodeLength: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        maxRfidCodeLength: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        minPinCodeLength: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        minRfidCodeLength: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                holidaySchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfLogRecordsSupported: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                logging: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfPinUsersSupported: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfRfidUsersSupported: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfTotalUsersSupported: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                weekDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                yearDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        openPeriod: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                doorPositionSensor: boolean;
            }];
        };
        operatingMode: WritableAttribute<DoorLock.OperatingMode, 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> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
            }];
        };
        remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            pinAdded: BitFlag;
            pinChanged: BitFlag;
            pinCleared: BitFlag;
            rfidCodeAdded: BitFlag;
            rfidCodeCleared: BitFlag;
            unknown: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
            }];
        };
        requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                credentialOverTheAirAccess: boolean;
                pinCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
                rfidCredential: boolean;
            }];
        };
        rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            idAdded: BitFlag;
            idCleared: BitFlag;
            unknown: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
                rfidCredential: boolean;
            }];
        };
        sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                pinCredential: boolean;
                user: boolean;
            }];
        };
        soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
        supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
            noRemoteLockUnlock: BitFlag;
            normal: BitFlag;
            passage: BitFlag;
            privacy: BitFlag;
            vacation: BitFlag;
        }>, any>;
        userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
            }, {
                rfidCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wrongCodeEntryLimit: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
            }, {
                rfidCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, 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;
    }>>;
    base: undefined;
    commands: {
        clearAllPinCodes: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearAllRfidCodes: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearCredential: Command<TypeFromFields<{
            credential: FieldType<null | TypeFromFields<{
                credentialIndex: FieldType<number>;
                credentialType: FieldType<DoorLock.CredentialType>;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearHolidaySchedule: Command<TypeFromFields<{
            holidayIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                holidaySchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearPinCode: Command<TypeFromFields<{
            pinSlotIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearRfidCode: Command<TypeFromFields<{
            rfidSlotIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearUser: Command<TypeFromFields<{
            userIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearWeekDaySchedule: Command<TypeFromFields<{
            userIndexUserId: FieldType<number>;
            weekDayIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                weekDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearYearDaySchedule: Command<TypeFromFields<{
            userIndexUserId: FieldType<number>;
            yearDayIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                yearDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getCredentialStatus: Command<TypeFromFields<{
            credential: FieldType<TypeFromFields<{
                credentialIndex: FieldType<number>;
                credentialType: FieldType<DoorLock.CredentialType>;
            }>>;
        }>, TypeFromFields<{
            creatorFabricIndex: FieldType<null | FabricIndex>;
            credentialExists: FieldType<boolean>;
            lastModifiedFabricIndex: FieldType<null | FabricIndex>;
            nextCredentialIndex: OptionalFieldType<null | number>;
            userIndex: FieldType<null | number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                holidaySchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                logging: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getUser: Command<TypeFromFields<{
            userIndex: FieldType<number>;
        }>, TypeFromFields<{
            creatorFabricIndex: FieldType<null | FabricIndex>;
            credentialRule: FieldType<null | DoorLock.CredentialRule>;
            credentials: FieldType<null | TypeFromFields<{
                credentialIndex: FieldType<(...)>;
                credentialType: FieldType<(...)>;
            }>[]>;
            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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getUserStatus: OptionalCommand<TypeFromFields<{
            userId: FieldType<number>;
        }>, TypeFromFields<{
            userId: FieldType<number>;
            userStatus: FieldType<DoorLock.UserStatus>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                fingerCredentials: boolean;
                pinCredential: boolean;
                rfidCredential: boolean;
                user: boolean;
            }];
        };
        getUserType: OptionalCommand<TypeFromFields<{
            userId: FieldType<number>;
        }>, TypeFromFields<{
            userId: FieldType<number>;
            userType: FieldType<DoorLock.UserType>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                fingerCredentials: boolean;
                pinCredential: boolean;
                rfidCredential: boolean;
                user: boolean;
            }];
        };
        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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                weekDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                yearDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        lockDoor: Command<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
        }>, void, any>;
        setCredential: Command<TypeFromFields<{
            credential: FieldType<TypeFromFields<{
                credentialIndex: FieldType<number>;
                credentialType: FieldType<DoorLock.CredentialType>;
            }>>;
            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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setHolidaySchedule: Command<TypeFromFields<{
            holidayIndex: FieldType<number>;
            localEndTime: FieldType<number>;
            localStartTime: FieldType<number>;
            operatingMode: FieldType<DoorLock.OperatingMode>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                holidaySchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setPinCode: Command<TypeFromFields<{
            pin: FieldType<Uint8Array>;
            userId: FieldType<number>;
            userStatus: FieldType<null | DoorLock.UserStatus>;
            userType: FieldType<null | DoorLock.UserType>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setRfidCode: Command<TypeFromFields<{
            rfidCode: FieldType<Uint8Array>;
            userId: FieldType<number>;
            userStatus: FieldType<null | DoorLock.UserStatus>;
            userType: FieldType<null | DoorLock.UserType>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setUserStatus: OptionalCommand<TypeFromFields<{
            userId: FieldType<number>;
            userStatus: FieldType<DoorLock.UserStatus>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                fingerCredentials: boolean;
                pinCredential: boolean;
                rfidCredential: boolean;
                user: boolean;
            }];
        };
        setUserType: OptionalCommand<TypeFromFields<{
            userId: FieldType<number>;
            userType: FieldType<DoorLock.UserType>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                fingerCredentials: boolean;
                pinCredential: boolean;
                rfidCredential: boolean;
                user: boolean;
            }];
        };
        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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                weekDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setYearDaySchedule: Command<TypeFromFields<{
            localEndTime: FieldType<number>;
            localStartTime: FieldType<number>;
            userIndexUserId: FieldType<number>;
            yearDayIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                yearDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unboltDoor: Command<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                unbolting: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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>;
        doorStateChange: Event<TypeFromFields<{
            doorState: FieldType<DoorLock.DoorState>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                doorPositionSensor: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        lockOperation: Event<TypeFromFields<{
            credentials: OptionalFieldType<null | TypeFromFields<{
                credentialIndex: FieldType<number>;
                credentialType: FieldType<DoorLock.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: FieldType<number>;
                credentialType: FieldType<DoorLock.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>;
        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> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    extensions: undefined;
    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<Branded<257, "ClusterId">, "ClusterId">;
    name: "DoorLock";
    revision: 7;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                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;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            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>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, 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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        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;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                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;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            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>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, 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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        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;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                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;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            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>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, 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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        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;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                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;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            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>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, 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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        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;
    }>, SelectionT>;
}