import { DataEntity } from './types';
import { Name, Description } from './onvif';
import { Duration } from './basics';
import { ReferenceToken } from './common';
/** The physical state of a Door. */
export type DoorPhysicalState = 'Unknown' | 'Open' | 'Closed' | 'Fault';
/** The physical state of a Lock (including Double Lock). */
export type LockPhysicalState = 'Unknown' | 'Locked' | 'Unlocked' | 'Fault';
/** Describes the state of a Door with regard to alarms. */
export type DoorAlarmState = 'Normal' | 'DoorForcedOpen' | 'DoorOpenTooLong';
/** Describes the state of a Tamper detector. */
export type DoorTamperState = 'Unknown' | 'NotInTamper' | 'TamperDetected';
/** Describes the state of a Door fault. */
export type DoorFaultState = 'Unknown' | 'NotInFault' | 'FaultDetected';
/**
 * The DoorMode describe the mode of operation from a logical perspective.
 * Setting a door mode reflects the intent to set a door in a physical state.
 */
export type DoorMode = 'Unknown' | 'Locked' | 'Unlocked' | 'Accessed' | 'Blocked' | 'LockedDown' | 'LockedOpen' | 'DoubleLocked';
/**
 * ServiceCapabilities structure reflects optional functionality of a service.
 * The information is static and does not change during device operation.
 * The following capabilities are available:
 */
export interface ServiceCapabilities {
    /**
     * The maximum number of entries returned by a single Get<Entity>List or
     * Get<Entity> request. The device shall never return more than this number of entities
     * in a single response.
     */
    maxLimit: number;
    /** Indicates the maximum number of doors supported by the device. */
    maxDoors?: number;
    /**
     * Indicates that the client is allowed to supply the token when creating doors.
     * To enable the use of the command SetDoor, the value must be set to true.
     */
    clientSuppliedTokenSupported?: boolean;
    /**
     * Indicates that the client can perform CRUD operations (create, read, update and delete)
     * on doors. To enable the use of the commands GetDoors, GetDoorList, CreateDoor, ModifyDoor
     * and DeleteDoor, the value must be set to true.
     */
    doorManagementSupported?: boolean;
    [key: string]: unknown;
}
/** Used as extension base. */
export interface DoorInfoBase extends DataEntity {
    /** A user readable name. It shall be up to 64 characters. */
    name: Name;
    /** A user readable description. It shall be up to 1024 characters. */
    description?: Description;
}
/**
 * The DoorInfo type represents the Door as a physical object.
 * The structure contains information and capabilities of a specific door instance.
 * An ONVIF compliant device shall provide the following fields for each Door instance:
 */
export interface DoorInfo extends DoorInfoBase {
    /** The capabilities of the Door. */
    capabilities: DoorCapabilities;
    [key: string]: unknown;
}
/**
 * The door structure shall include all properties of the DoorInfo structure and also a timings
 * structure.
 */
export interface Door extends DoorInfoBase {
    /** The capabilities of the Door. */
    capabilities: DoorCapabilities;
    /**
     * The type of door. Is of type text. Can be either one of the following reserved
     * ONVIF types: "pt:Door", "pt:ManTrap", "pt:Turnstile", "pt:RevolvingDoor",
     * "pt:Barrier", or a custom defined type.
     */
    doorType: Name;
    /**
     * A structure defining times such as how long the door is unlocked when
     * accessed, extended grant time, etc.
     */
    timings: Timings;
    extension?: DoorExtension;
}
export interface DoorExtension {
    [key: string]: unknown;
}
/**
 * A structure defining times such as how long the door is unlocked when accessed,
 * extended grant time, etc.
 */
export interface Timings {
    /**
     * When access is granted (door mode becomes Accessed), the latch is unlocked.
     * ReleaseTime is the time from when the latch is unlocked until it is
     * relocked again (unless the door is physically opened).
     */
    releaseTime: Duration;
    /**
     * The time from when the door is physically opened until the door is set in the
     * DoorOpenTooLong alarm state.
     */
    openTime: Duration;
    /**
     * Some individuals need extra time to open the door before the latch relocks.
     * If supported, ExtendedReleaseTime shall be added to ReleaseTime if UseExtendedTime
     * is set to true in the AccessDoor command.
     */
    extendedReleaseTime?: Duration;
    /**
     * If the door is physically opened after access is granted,
     * then DelayTimeBeforeRelock is the time from when the door is physically
     * opened until the latch goes back to locked state.
     */
    delayTimeBeforeRelock?: Duration;
    /**
     * Some individuals need extra time to pass through the door. If supported,
     * ExtendedOpenTime shall be added to OpenTime if UseExtendedTime is set to true
     * in the AccessDoor command.
     */
    extendedOpenTime?: Duration;
    /**
     * Before a DoorOpenTooLong alarm state is generated, a signal will sound to indicate
     * that the door must be closed. PreAlarmTime defines how long before DoorOpenTooLong
     * the warning signal shall sound.
     */
    preAlarmTime?: Duration;
    extension?: TimingsExtension;
}
export interface TimingsExtension {
    [key: string]: unknown;
}
/**
 * DoorCapabilities reflect optional functionality of a particular physical entity.
 * Different door instances may have different set of capabilities.
 * This information may change during device operation, e.g. if hardware settings are changed.
 * The following capabilities are available:
 */
export interface DoorCapabilities {
    /**
     * Indicates whether or not this Door instance supports AccessDoor command to
     * perform momentary access.
     */
    access?: boolean;
    /**
     * Indicates that this Door instance supports overriding configured timing in the
     * AccessDoor command.
     */
    accessTimingOverride?: boolean;
    /**
     * Indicates that this Door instance supports LockDoor command to lock the
     * door.
     */
    lock?: boolean;
    /**
     * Indicates that this Door instance supports UnlockDoor command to unlock the
     * door.
     */
    unlock?: boolean;
    /**
     * Indicates that this Door instance supports BlockDoor command to block the
     * door.
     */
    block?: boolean;
    /**
     * Indicates that this Door instance supports DoubleLockDoor command to lock
     * multiple locks on the door.
     */
    doubleLock?: boolean;
    /**
     * Indicates that this Door instance supports LockDown (and LockDownRelease)
     * commands to lock the door and put it in LockedDown mode.
     */
    lockDown?: boolean;
    /**
     * Indicates that this Door instance supports LockOpen (and LockOpenRelease)
     * commands to unlock the door and put it in LockedOpen mode.
     */
    lockOpen?: boolean;
    /**
     * Indicates that this Door instance has a DoorMonitor and supports the
     * DoorPhysicalState event.
     */
    doorMonitor?: boolean;
    /**
     * Indicates that this Door instance has a LockMonitor and supports the
     * LockPhysicalState event.
     */
    lockMonitor?: boolean;
    /**
     * Indicates that this Door instance has a DoubleLockMonitor and supports the
     * DoubleLockPhysicalState event.
     */
    doubleLockMonitor?: boolean;
    /**
     * Indicates that this Door instance supports door alarm and the DoorAlarm
     * event.
     */
    alarm?: boolean;
    /**
     * Indicates that this Door instance has a Tamper detector and supports the
     * DoorTamper event.
     */
    tamper?: boolean;
    /**
     * Indicates that this Door instance supports door fault and the DoorFault
     * event.
     */
    fault?: boolean;
    [key: string]: unknown;
}
/** The DoorState structure contains current aggregate runtime status of Door. */
export interface DoorState {
    /**
     * Physical state of the Door; it is of type DoorPhysicalState. A device that
     * signals support for DoorMonitor capability for a particular door instance shall provide
     * this field.
     */
    doorPhysicalState?: DoorPhysicalState;
    /**
     * Physical state of the Lock; it is of type LockPhysicalState. A device that
     * signals support for LockMonitor capability for a particular door instance shall provide
     * this field.
     */
    lockPhysicalState?: LockPhysicalState;
    /**
     * Physical state of the DoubleLock; it is of type LockPhysicalState. A
     * device that signals support for DoubleLockMonitor capability for a particular door
     * instance shall provide this field.
     */
    doubleLockPhysicalState?: LockPhysicalState;
    /**
     * Alarm state of the door; it is of type DoorAlarmState. A device that
     * signals support for Alarm capability for a particular door instance shall provide this
     * field.
     */
    alarm?: DoorAlarmState;
    /**
     * Tampering state of the door; it is of type DoorTamper. A device that
     * signals support for Tamper capability for a particular door instance shall provide this
     * field.
     */
    tamper?: DoorTamper;
    /**
     * Fault information for door; it is of type DoorFault. A device that signals
     * support for Fault capability for a particular door instance shall provide this field.
     */
    fault?: DoorFault;
    /**
     * The logical operating mode of the door; it is of type DoorMode. An ONVIF
     * compatible device shall report current operating mode in this field.
     */
    doorMode: DoorMode;
    [key: string]: unknown;
}
/** Tampering information for a Door. */
export interface DoorTamper {
    /**
     * Optional field; Details describing tampering state change (e.g., reason,
     * place and time).
     * NOTE: All fields (including this one) which are designed to give
     * end-user prompts can be localized to the customer's native language.
     */
    reason?: string;
    /** State of the tamper detector; it is of type DoorTamperState. */
    state: DoorTamperState;
    [key: string]: unknown;
}
/**
 * Fault information for a Door.
 * This can be extended with optional attributes in the future.
 */
export interface DoorFault {
    /** Optional reason for fault. */
    reason?: string;
    /**
     * Overall fault state for the door; it is of type DoorFaultState. If there
     * are any faults, the value shall be: FaultDetected. Details of the detected fault shall
     * be found in the Reason field, and/or the various DoorState fields and/or in extensions
     * to this structure.
     */
    state: DoorFaultState;
    [key: string]: unknown;
}
/** Extension for the AccessDoor command. */
export interface AccessDoorExtension {
    [key: string]: unknown;
}
export interface Capabilities extends ServiceCapabilities {
}
export interface GetServiceCapabilities {
}
export interface GetServiceCapabilitiesResponse {
    /**
     * The capability response message contains the requested DoorControl
     * service capabilities using a hierarchical XML capability structure.
     */
    capabilities: ServiceCapabilities;
}
export interface GetDoorInfoList {
    /**
     * Maximum number of entries to return. If Limit is omitted or if the
     * value of Limit is higher than what the device supports, then the device shall
     * return its maximum amount of entries.
     */
    limit?: number;
    /**
     * Start returning entries from this start reference. If not specified,
     * entries shall start from the beginning of the dataset.
     */
    startReference?: string;
}
export interface GetDoorInfoListResponse {
    /**
     * StartReference to use in next call to get the following items. If
     * absent, no more items to get.
     */
    nextStartReference?: string;
    /** List of DoorInfo items. */
    doorInfo?: DoorInfo[];
}
export interface GetDoorInfo {
    /** Tokens of DoorInfo items to get. */
    token?: ReferenceToken[];
}
export interface GetDoorInfoResponse {
    /** List of DoorInfo items. */
    doorInfo?: DoorInfo[];
}
export interface GetDoorList {
    /**
     * Maximum number of entries to return. If not specified, less than one
     * or higher than what the device supports, the number of items is determined by the
     * device.
     */
    limit?: number;
    /**
     * Start returning entries from this start reference. If not specified,
     * entries shall start from the beginning of the dataset.
     */
    startReference?: string;
}
export interface GetDoorListResponse {
    /**
     * StartReference to use in next call to get the following items. If
     * absent, no more items to get.
     */
    nextStartReference?: string;
    /** List of Door items. */
    door?: Door[];
}
export interface GetDoors {
    /** Tokens of Door items to get. */
    token?: ReferenceToken[];
}
export interface GetDoorsResponse {
    /** List of Door items. */
    door?: Door[];
}
export interface CreateDoor {
    /** Door item to create */
    door: Door;
}
export interface CreateDoorResponse {
    /** Token of created Door item */
    token: ReferenceToken;
}
export interface SetDoor {
    /** The Door item to create or modify */
    door: Door;
}
export interface SetDoorResponse {
}
export interface ModifyDoor {
    /** The details of the door */
    door: Door;
}
export interface ModifyDoorResponse {
}
export interface DeleteDoor {
    /** The Token of the door to delete. */
    token: ReferenceToken;
}
export interface DeleteDoorResponse {
}
export interface GetDoorState {
    /** Token of the Door instance to get the state for. */
    token: ReferenceToken;
}
export interface GetDoorStateResponse {
    /** The state of the door. */
    doorState: DoorState;
}
export interface AccessDoor {
    /** Token of the Door instance to control. */
    token: ReferenceToken;
    /**
     * Optional - Indicates that the configured extended time should be
     * used.
     */
    useExtendedTime?: boolean;
    /** Optional - overrides ReleaseTime if specified. */
    accessTime?: Duration;
    /** Optional - overrides OpenTime if specified. */
    openTooLongTime?: Duration;
    /** Optional - overrides PreAlarmTime if specified. */
    preAlarmTime?: Duration;
    /** Future extension. */
    extension?: AccessDoorExtension;
}
export interface AccessDoorResponse {
}
export interface LockDoor {
    /** Token of the Door instance to control. */
    token: ReferenceToken;
}
export interface LockDoorResponse {
}
export interface UnlockDoor {
    /** Token of the Door instance to control. */
    token: ReferenceToken;
}
export interface UnlockDoorResponse {
}
export interface BlockDoor {
    /** Token of the Door instance to control. */
    token: ReferenceToken;
}
export interface BlockDoorResponse {
}
export interface LockDownDoor {
    /** Token of the Door instance to control. */
    token: ReferenceToken;
}
export interface LockDownDoorResponse {
}
export interface LockDownReleaseDoor {
    /** Token of the Door instance to control. */
    token: ReferenceToken;
}
export interface LockDownReleaseDoorResponse {
}
export interface LockOpenDoor {
    /** Token of the Door instance to control. */
    token: ReferenceToken;
}
export interface LockOpenDoorResponse {
}
export interface LockOpenReleaseDoor {
    /** Token of the Door instance to control. */
    token: ReferenceToken;
}
export interface LockOpenReleaseDoorResponse {
}
export interface DoubleLockDoor {
    /** Token of the Door instance to control. */
    token: ReferenceToken;
}
export interface DoubleLockDoorResponse {
}