@doordeck/doordeck-headless-sdk 0.114.0 → 0.116.0

package/kotlin/doordeck-sdk.d.ts

@@ -1,4 +1,5 @@
 type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
 export declare namespace kotlin.collections {
     interface KtList<E> /* extends kotlin.collections.Collection<E> */ {
         asJsReadonlyArrayView(): ReadonlyArray<E>;
@@ -6,18 +7,32 @@ export declare namespace kotlin.collections {
             readonly "kotlin.collections.KtList": unique symbol;
         };
     }
-    const KtList: {
-        fromJsArray<E>(array: ReadonlyArray<E>): kotlin.collections.KtList<E>;
-    };
+    abstract class KtList<E> extends KtSingleton<KtList.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace KtList.$metadata$ {
+        abstract class constructor {
+            fromJsArray<E>(array: ReadonlyArray<E>): kotlin.collections.KtList<E>;
+            private constructor();
+        }
+    }
     interface KtMap<K, V> {
         asJsReadonlyMapView(): ReadonlyMap<K, V>;
         readonly __doNotUseOrImplementIt: {
             readonly "kotlin.collections.KtMap": unique symbol;
         };
     }
-    const KtMap: {
-        fromJsMap<K, V>(map: ReadonlyMap<K, V>): kotlin.collections.KtMap<K, V>;
-    };
+    abstract class KtMap<K, V> extends KtSingleton<KtMap.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace KtMap.$metadata$ {
+        abstract class constructor {
+            fromJsMap<K, V>(map: ReadonlyMap<K, V>): kotlin.collections.KtMap<K, V>;
+            private constructor();
+        }
+    }
 }
 export declare namespace io.ktor.client.engine.js {
     /** @deprecated  */
@@ -32,9 +47,16 @@ export declare namespace com.doordeck.multiplatform.sdk {
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk {
-    const KDoordeckFactory: {
-        initialize(sdkConfig: com.doordeck.multiplatform.sdk.config.SdkConfig): com.doordeck.multiplatform.sdk.Doordeck;
-    };
+    abstract class KDoordeckFactory extends KtSingleton<KDoordeckFactory.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace KDoordeckFactory.$metadata$ {
+        abstract class constructor {
+            initialize(sdkConfig: com.doordeck.multiplatform.sdk.config.SdkConfig): com.doordeck.multiplatform.sdk.Doordeck;
+            private constructor();
+        }
+    }
 }
 export declare namespace com.doordeck.multiplatform.sdk.config {
     class SdkConfig {
@@ -50,6 +72,10 @@ export declare namespace com.doordeck.multiplatform.sdk.config {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace SdkConfig.$metadata$ {
+        const constructor: abstract new () => SdkConfig;
+    }
     namespace SdkConfig {
         class Builder {
             constructor();
@@ -61,6 +87,10 @@ export declare namespace com.doordeck.multiplatform.sdk.config {
             setDebugLogging(enabled: Nullable<boolean>): com.doordeck.multiplatform.sdk.config.SdkConfig.Builder;
             build(): com.doordeck.multiplatform.sdk.config.SdkConfig;
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Builder.$metadata$ {
+            const constructor: abstract new () => Builder;
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.context {
@@ -97,59 +127,127 @@ export declare namespace com.doordeck.multiplatform.sdk.context {
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.exceptions {
-    class BadRequestException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    class BadRequestException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class UnauthorizedException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace BadRequestException.$metadata$ {
+        const constructor: abstract new () => BadRequestException;
+    }
+    class UnauthorizedException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class ForbiddenException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace UnauthorizedException.$metadata$ {
+        const constructor: abstract new () => UnauthorizedException;
+    }
+    class ForbiddenException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class NotFoundException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ForbiddenException.$metadata$ {
+        const constructor: abstract new () => ForbiddenException;
+    }
+    class NotFoundException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class MethodNotAllowedException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace NotFoundException.$metadata$ {
+        const constructor: abstract new () => NotFoundException;
+    }
+    class MethodNotAllowedException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class NotAcceptableException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace MethodNotAllowedException.$metadata$ {
+        const constructor: abstract new () => MethodNotAllowedException;
+    }
+    class NotAcceptableException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class ConflictException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace NotAcceptableException.$metadata$ {
+        const constructor: abstract new () => NotAcceptableException;
+    }
+    class ConflictException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class GoneException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ConflictException.$metadata$ {
+        const constructor: abstract new () => ConflictException;
+    }
+    class GoneException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class LockedException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GoneException.$metadata$ {
+        const constructor: abstract new () => GoneException;
+    }
+    class LockedException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class TooEarlyException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LockedException.$metadata$ {
+        const constructor: abstract new () => LockedException;
+    }
+    class TooEarlyException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class TooManyRequestsException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TooEarlyException.$metadata$ {
+        const constructor: abstract new () => TooEarlyException;
+    }
+    class TooManyRequestsException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class InternalServerErrorException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TooManyRequestsException.$metadata$ {
+        const constructor: abstract new () => TooManyRequestsException;
+    }
+    class InternalServerErrorException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class ServiceUnavailableException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace InternalServerErrorException.$metadata$ {
+        const constructor: abstract new () => InternalServerErrorException;
+    }
+    class ServiceUnavailableException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class GatewayTimeoutException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ServiceUnavailableException.$metadata$ {
+        const constructor: abstract new () => ServiceUnavailableException;
+    }
+    class GatewayTimeoutException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GatewayTimeoutException.$metadata$ {
+        const constructor: abstract new () => GatewayTimeoutException;
+    }
 }
 export declare namespace com.doordeck.multiplatform.sdk.exceptions {
     class SdkException /* extends kotlin.Exception */ {
         constructor(message: string, exception?: Nullable<Error>);
     }
-    class MissingContextFieldException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace SdkException.$metadata$ {
+        const constructor: abstract new () => SdkException;
+    }
+    class MissingContextFieldException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string);
     }
-    class BatchShareFailedException extends com.doordeck.multiplatform.sdk.exceptions.SdkException {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace MissingContextFieldException.$metadata$ {
+        const constructor: abstract new () => MissingContextFieldException;
+    }
+    class BatchShareFailedException extends com.doordeck.multiplatform.sdk.exceptions.SdkException.$metadata$.constructor {
         constructor(message: string, userIds: kotlin.collections.KtList<string>);
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace BatchShareFailedException.$metadata$ {
+        const constructor: abstract new () => BatchShareFailedException;
+    }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.common {
     abstract class AuditEvent {
@@ -218,8 +316,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.common {
         get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14;
         static values(): Array<com.doordeck.multiplatform.sdk.model.common.AuditEvent>;
         static valueOf(value: string): com.doordeck.multiplatform.sdk.model.common.AuditEvent;
-        static get Companion(): {
-        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace AuditEvent.$metadata$ {
+        const constructor: abstract new () => AuditEvent;
+    }
+    namespace AuditEvent {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.common {
@@ -237,8 +348,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.common {
         get ordinal(): 0 | 1;
         static values(): Array<com.doordeck.multiplatform.sdk.model.common.CapabilityStatus>;
         static valueOf(value: string): com.doordeck.multiplatform.sdk.model.common.CapabilityStatus;
-        static get Companion(): {
-        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CapabilityStatus.$metadata$ {
+        const constructor: abstract new () => CapabilityStatus;
+    }
+    namespace CapabilityStatus {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
     abstract class CapabilityType {
         private constructor();
@@ -258,8 +382,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.common {
         get ordinal(): 0 | 1 | 2;
         static values(): Array<com.doordeck.multiplatform.sdk.model.common.CapabilityType>;
         static valueOf(value: string): com.doordeck.multiplatform.sdk.model.common.CapabilityType;
-        static get Companion(): {
-        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CapabilityType.$metadata$ {
+        const constructor: abstract new () => CapabilityType;
+    }
+    namespace CapabilityType {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.common {
@@ -281,8 +418,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.common {
         get ordinal(): 0 | 1 | 2;
         static values(): Array<com.doordeck.multiplatform.sdk.model.common.TwoFactorMethod>;
         static valueOf(value: string): com.doordeck.multiplatform.sdk.model.common.TwoFactorMethod;
-        static get Companion(): {
-        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TwoFactorMethod.$metadata$ {
+        const constructor: abstract new () => TwoFactorMethod;
+    }
+    namespace TwoFactorMethod {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.common {
@@ -300,8 +450,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.common {
         get ordinal(): 0 | 1;
         static values(): Array<com.doordeck.multiplatform.sdk.model.common.UserRole>;
         static valueOf(value: string): com.doordeck.multiplatform.sdk.model.common.UserRole;
-        static get Companion(): {
-        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace UserRole.$metadata$ {
+        const constructor: abstract new () => UserRole;
+    }
+    namespace UserRole {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.data {
@@ -325,9 +488,13 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
         static values(): Array<com.doordeck.multiplatform.sdk.model.data.ApiEnvironment>;
         static valueOf(value: string): com.doordeck.multiplatform.sdk.model.data.ApiEnvironment;
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ApiEnvironment.$metadata$ {
+        const constructor: abstract new () => ApiEnvironment;
+    }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.data {
-    abstract class Crypto {
+    abstract class Crypto extends KtSingleton<Crypto.$metadata$.constructor>() {
         private constructor();
     }
     namespace Crypto {
@@ -340,6 +507,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace KeyPair.$metadata$ {
+            const constructor: abstract new () => KeyPair;
+        }
         class EncodedKeyPair {
             constructor(_private: string, _public: string);
             get private(): string;
@@ -348,13 +519,32 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             toString(): string;
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace EncodedKeyPair.$metadata$ {
+            const constructor: abstract new () => EncodedKeyPair;
+        }
+        namespace EncodedKeyPair {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
+        }
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Crypto.$metadata$ {
+        abstract class constructor {
+            private constructor();
         }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.data {
-    abstract class Fusion {
+    abstract class Fusion extends KtSingleton<Fusion.$metadata$.constructor>() {
         private constructor();
     }
     namespace Fusion {
@@ -363,8 +553,15 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 readonly "com.doordeck.multiplatform.sdk.model.data.Fusion.LockController": unique symbol;
             };
         }
-        const LockController: {
-        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+        abstract class LockController extends KtSingleton<LockController.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace LockController.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
         class AlpetaController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(username: string, password: string, doorId: number, baseUrl?: Nullable<string>);
             get username(): string;
@@ -376,8 +573,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace AlpetaController.$metadata$ {
+            const constructor: abstract new () => AlpetaController;
+        }
+        namespace AlpetaController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class AmagController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(username: string, password: string, doorId: number, baseUrl?: Nullable<string>);
@@ -390,8 +600,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace AmagController.$metadata$ {
+            const constructor: abstract new () => AmagController;
+        }
+        namespace AmagController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class AssaAbloyController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(baseUrl: string, doorId: string);
@@ -402,8 +625,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace AssaAbloyController.$metadata$ {
+            const constructor: abstract new () => AssaAbloyController;
+        }
+        namespace AssaAbloyController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class AvigilonController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(baseUrl: string, username: string, password: string, doorId: string);
@@ -416,8 +652,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace AvigilonController.$metadata$ {
+            const constructor: abstract new () => AvigilonController;
+        }
+        namespace AvigilonController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class AxisController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(baseUrl: string, doorIdentifier: string);
@@ -428,8 +677,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace AxisController.$metadata$ {
+            const constructor: abstract new () => AxisController;
+        }
+        namespace AxisController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class CCureController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(baseUrl: string, username: string, password: string, doorType: string, doorId: number);
@@ -443,8 +705,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace CCureController.$metadata$ {
+            const constructor: abstract new () => CCureController;
+        }
+        namespace CCureController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class DemoController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(port?: number);
@@ -454,8 +729,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace DemoController.$metadata$ {
+            const constructor: abstract new () => DemoController;
+        }
+        namespace DemoController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class GallagherController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(baseUrl: Nullable<string> | undefined, apiKey: string, doorId: string);
@@ -467,8 +755,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace GallagherController.$metadata$ {
+            const constructor: abstract new () => GallagherController;
+        }
+        namespace GallagherController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class GenetecController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(baseUrl: string, username: string, password: string, doorId: string);
@@ -481,8 +782,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace GenetecController.$metadata$ {
+            const constructor: abstract new () => GenetecController;
+        }
+        namespace GenetecController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class LenelController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(baseUrl: string, username: string, password: string, directoryId: string, panelId: string, readerId: string);
@@ -497,8 +811,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace LenelController.$metadata$ {
+            const constructor: abstract new () => LenelController;
+        }
+        namespace LenelController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class MitrefinchController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(host: string, output: number);
@@ -509,8 +836,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace MitrefinchController.$metadata$ {
+            const constructor: abstract new () => MitrefinchController;
+        }
+        namespace MitrefinchController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class PaxtonNet2Controller implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(host: string, username: Nullable<string> | undefined, password: Nullable<string> | undefined, address: string, output: number);
@@ -524,8 +864,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace PaxtonNet2Controller.$metadata$ {
+            const constructor: abstract new () => PaxtonNet2Controller;
+        }
+        namespace PaxtonNet2Controller {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class Paxton10Controller implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(baseUrl: string, username: string, password: string, applianceId: number);
@@ -538,8 +891,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Paxton10Controller.$metadata$ {
+            const constructor: abstract new () => Paxton10Controller;
+        }
+        namespace Paxton10Controller {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class IntegraV1Controller implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(username: string, password: string, controllerId: number);
@@ -551,8 +917,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace IntegraV1Controller.$metadata$ {
+            const constructor: abstract new () => IntegraV1Controller;
+        }
+        namespace IntegraV1Controller {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class IntegraV2Controller implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(baseUrl: string, sessionId: string, controllerId: number, cardholderId: number, pinCode?: Nullable<number>);
@@ -566,8 +945,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace IntegraV2Controller.$metadata$ {
+            const constructor: abstract new () => IntegraV2Controller;
+        }
+        namespace IntegraV2Controller {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class PacController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(dataSource: com.doordeck.multiplatform.sdk.model.data.Fusion.DataSource, outputChannel: number, controllerSerial: number);
@@ -579,8 +971,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace PacController.$metadata$ {
+            const constructor: abstract new () => PacController;
+        }
+        namespace PacController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class DataSource {
             constructor(driverClass: string, url: string, user: string, password: string);
@@ -592,8 +997,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             toString(): string;
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace DataSource.$metadata$ {
+            const constructor: abstract new () => DataSource;
+        }
+        namespace DataSource {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class TdsiExgardeController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(dbUrl: Nullable<string> | undefined, username: string, password: string, doorId: number);
@@ -606,8 +1024,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace TdsiExgardeController.$metadata$ {
+            const constructor: abstract new () => TdsiExgardeController;
+        }
+        namespace TdsiExgardeController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class TdsiGardisController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(host: string, username: string, password: string, doorId: number);
@@ -620,8 +1051,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace TdsiGardisController.$metadata$ {
+            const constructor: abstract new () => TdsiGardisController;
+        }
+        namespace TdsiGardisController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         class ZktecoController implements com.doordeck.multiplatform.sdk.model.data.Fusion.LockController {
             constructor(clientSecret: string, doorId: string, baseUrl: Nullable<string> | undefined, entityType: com.doordeck.multiplatform.sdk.model.data.Fusion.ZktecoEntityType);
@@ -634,8 +1078,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController["__doNotUseOrImplementIt"];
-            static get Companion(): {
-            };
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace ZktecoController.$metadata$ {
+            const constructor: abstract new () => ZktecoController;
+        }
+        namespace ZktecoController {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor {
+                    private constructor();
+                }
+            }
         }
         abstract class ZktecoEntityType {
             private constructor();
@@ -651,13 +1108,32 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             get ordinal(): 0 | 1;
             static values(): Array<com.doordeck.multiplatform.sdk.model.data.Fusion.ZktecoEntityType>;
             static valueOf(value: string): com.doordeck.multiplatform.sdk.model.data.Fusion.ZktecoEntityType;
-            static get Companion(): {
-            } & any/* kotlinx.serialization.internal.SerializerFactory */;
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace ZktecoEntityType.$metadata$ {
+            const constructor: abstract new () => ZktecoEntityType;
+        }
+        namespace ZktecoEntityType {
+            abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+                private constructor();
+            }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Companion.$metadata$ {
+                abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                    private constructor();
+                }
+            }
+        }
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Fusion.$metadata$ {
+        abstract class constructor {
+            private constructor();
         }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.data {
-    abstract class LockOperations {
+    abstract class LockOperations extends KtSingleton<LockOperations.$metadata$.constructor>() {
         private constructor();
     }
     namespace LockOperations {
@@ -672,6 +1148,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace TimeRequirement.$metadata$ {
+            const constructor: abstract new () => TimeRequirement;
+        }
         namespace TimeRequirement {
             class Builder {
                 constructor();
@@ -681,6 +1161,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setDays(days: kotlin.collections.KtList<string>): com.doordeck.multiplatform.sdk.model.data.LockOperations.TimeRequirement.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.TimeRequirement;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class LocationRequirement {
             constructor(latitude: number, longitude: number, enabled?: boolean, radius?: number, accuracy?: number);
@@ -694,6 +1178,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace LocationRequirement.$metadata$ {
+            const constructor: abstract new () => LocationRequirement;
+        }
         namespace LocationRequirement {
             class Builder {
                 constructor();
@@ -704,6 +1192,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setAccuracy(accuracy: number): com.doordeck.multiplatform.sdk.model.data.LockOperations.LocationRequirement.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.LocationRequirement;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class UnlockBetween {
             constructor(start: string, end: string, timezone: string, days: kotlin.collections.KtList<string>, exceptions?: Nullable<kotlin.collections.KtList<string>>);
@@ -717,6 +1209,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace UnlockBetween.$metadata$ {
+            const constructor: abstract new () => UnlockBetween;
+        }
         namespace UnlockBetween {
             class Builder {
                 constructor();
@@ -727,6 +1223,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setExceptions(exceptions: Nullable<kotlin.collections.KtList<string>>): com.doordeck.multiplatform.sdk.model.data.LockOperations.UnlockBetween.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.UnlockBetween;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class UnlockOperation implements com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation {
             constructor(baseOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.BaseOperation, directAccessEndpoints?: Nullable<kotlin.collections.KtList<string>>);
@@ -738,6 +1238,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation["__doNotUseOrImplementIt"];
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace UnlockOperation.$metadata$ {
+            const constructor: abstract new () => UnlockOperation;
+        }
         namespace UnlockOperation {
             class Builder {
                 constructor();
@@ -745,6 +1249,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setDirectAccessEndpoints(directAccessEndpoints: Nullable<kotlin.collections.KtList<string>>): com.doordeck.multiplatform.sdk.model.data.LockOperations.UnlockOperation.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.UnlockOperation;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class ShareLockOperation implements com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation {
             constructor(baseOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.BaseOperation, shareLock: com.doordeck.multiplatform.sdk.model.data.LockOperations.ShareLock);
@@ -756,6 +1264,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation["__doNotUseOrImplementIt"];
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace ShareLockOperation.$metadata$ {
+            const constructor: abstract new () => ShareLockOperation;
+        }
         namespace ShareLockOperation {
             class Builder {
                 constructor();
@@ -763,6 +1275,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setShareLock(shareLock: com.doordeck.multiplatform.sdk.model.data.LockOperations.ShareLock): com.doordeck.multiplatform.sdk.model.data.LockOperations.ShareLockOperation.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.ShareLockOperation;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class ShareLock {
             constructor(targetUserId: string, targetUserRole: com.doordeck.multiplatform.sdk.model.common.UserRole, targetUserPublicKey: Int8Array, start?: Nullable<number>, end?: Nullable<number>);
@@ -776,6 +1292,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace ShareLock.$metadata$ {
+            const constructor: abstract new () => ShareLock;
+        }
         namespace ShareLock {
             class Builder {
                 constructor();
@@ -786,6 +1306,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setEnd(end: Nullable<number>): com.doordeck.multiplatform.sdk.model.data.LockOperations.ShareLock.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.ShareLock;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class BatchShareLockOperation implements com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation {
             constructor(baseOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.BaseOperation, users: kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.data.LockOperations.ShareLock>);
@@ -797,6 +1321,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation["__doNotUseOrImplementIt"];
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace BatchShareLockOperation.$metadata$ {
+            const constructor: abstract new () => BatchShareLockOperation;
+        }
         namespace BatchShareLockOperation {
             class Builder {
                 constructor();
@@ -804,6 +1332,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setUsers(users: kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.data.LockOperations.ShareLock>): com.doordeck.multiplatform.sdk.model.data.LockOperations.BatchShareLockOperation.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.BatchShareLockOperation;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class RevokeAccessToLockOperation implements com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation {
             constructor(baseOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.BaseOperation, users: kotlin.collections.KtList<string>);
@@ -815,6 +1347,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation["__doNotUseOrImplementIt"];
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace RevokeAccessToLockOperation.$metadata$ {
+            const constructor: abstract new () => RevokeAccessToLockOperation;
+        }
         namespace RevokeAccessToLockOperation {
             class Builder {
                 constructor();
@@ -822,6 +1358,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setUsers(users: kotlin.collections.KtList<string>): com.doordeck.multiplatform.sdk.model.data.LockOperations.RevokeAccessToLockOperation.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.RevokeAccessToLockOperation;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class UpdateSecureSettingUnlockDuration implements com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation {
             constructor(baseOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.BaseOperation, unlockDuration: number);
@@ -833,6 +1373,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation["__doNotUseOrImplementIt"];
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace UpdateSecureSettingUnlockDuration.$metadata$ {
+            const constructor: abstract new () => UpdateSecureSettingUnlockDuration;
+        }
         namespace UpdateSecureSettingUnlockDuration {
             class Builder {
                 constructor();
@@ -840,6 +1384,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setUnlockDuration(unlockDuration: number): com.doordeck.multiplatform.sdk.model.data.LockOperations.UpdateSecureSettingUnlockDuration.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.UpdateSecureSettingUnlockDuration;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class UpdateSecureSettingUnlockBetween implements com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation {
             constructor(baseOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.BaseOperation, unlockBetween?: Nullable<com.doordeck.multiplatform.sdk.model.data.LockOperations.UnlockBetween>);
@@ -851,6 +1399,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.LockOperations.Operation["__doNotUseOrImplementIt"];
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace UpdateSecureSettingUnlockBetween.$metadata$ {
+            const constructor: abstract new () => UpdateSecureSettingUnlockBetween;
+        }
         namespace UpdateSecureSettingUnlockBetween {
             class Builder {
                 constructor();
@@ -858,6 +1410,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setUnlockBetween(unlockBetween: Nullable<com.doordeck.multiplatform.sdk.model.data.LockOperations.UnlockBetween>): com.doordeck.multiplatform.sdk.model.data.LockOperations.UpdateSecureSettingUnlockBetween.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.UpdateSecureSettingUnlockBetween;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class BaseOperation {
             constructor(userId: Nullable<string> | undefined, userCertificateChain: Nullable<kotlin.collections.KtList<string>> | undefined, userPrivateKey: Nullable<Int8Array> | undefined, lockId: string, notBefore?: number, issuedAt?: number, expiresAt?: number, jti?: string);
@@ -874,6 +1430,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace BaseOperation.$metadata$ {
+            const constructor: abstract new () => BaseOperation;
+        }
         namespace BaseOperation {
             class Builder {
                 constructor();
@@ -887,6 +1447,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setJti(jti: string): com.doordeck.multiplatform.sdk.model.data.LockOperations.BaseOperation.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.LockOperations.BaseOperation;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         interface Operation {
             readonly __doNotUseOrImplementIt: {
@@ -894,9 +1458,15 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             };
         }
     }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LockOperations.$metadata$ {
+        abstract class constructor {
+            private constructor();
+        }
+    }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.data {
-    abstract class Platform {
+    abstract class Platform extends KtSingleton<Platform.$metadata$.constructor>() {
         private constructor();
     }
     namespace Platform {
@@ -915,6 +1485,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace CreateApplication.$metadata$ {
+            const constructor: abstract new () => CreateApplication;
+        }
         namespace CreateApplication {
             class Builder {
                 constructor();
@@ -928,6 +1502,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setLogoUrl(logoUrl: Nullable<string>): com.doordeck.multiplatform.sdk.model.data.Platform.CreateApplication.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.Platform.CreateApplication;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class EmailPreferences {
             constructor(senderEmail?: Nullable<string>, senderName?: Nullable<string>, primaryColour?: Nullable<string>, secondaryColour?: Nullable<string>, onlySendEssentialEmails?: Nullable<boolean>, callToAction?: Nullable<com.doordeck.multiplatform.sdk.model.data.Platform.EmailCallToAction>);
@@ -942,6 +1520,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace EmailPreferences.$metadata$ {
+            const constructor: abstract new () => EmailPreferences;
+        }
         namespace EmailPreferences {
             class Builder {
                 constructor();
@@ -953,6 +1535,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setCallToAction(callToAction: Nullable<com.doordeck.multiplatform.sdk.model.data.Platform.EmailCallToAction>): com.doordeck.multiplatform.sdk.model.data.Platform.EmailPreferences.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.Platform.EmailPreferences;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class EmailCallToAction {
             constructor(actionTarget: string, headline: string, actionText: string);
@@ -964,6 +1550,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             hashCode(): number;
             equals(other: Nullable<any>): boolean;
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace EmailCallToAction.$metadata$ {
+            const constructor: abstract new () => EmailCallToAction;
+        }
         namespace EmailCallToAction {
             class Builder {
                 constructor();
@@ -972,6 +1562,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setActionText(actionText: string): com.doordeck.multiplatform.sdk.model.data.Platform.EmailCallToAction.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.Platform.EmailCallToAction;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         interface AuthKey {
             readonly kid: string;
@@ -1002,6 +1596,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Platform.AuthKey["__doNotUseOrImplementIt"];
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace RsaKey.$metadata$ {
+            const constructor: abstract new () => RsaKey;
+        }
         namespace RsaKey {
             class Builder {
                 constructor();
@@ -1019,6 +1617,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setN(n: string): com.doordeck.multiplatform.sdk.model.data.Platform.RsaKey.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.Platform.RsaKey;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class EcKey implements com.doordeck.multiplatform.sdk.model.data.Platform.AuthKey {
             constructor(kty: string | undefined, use: string, kid: string, alg: Nullable<string> | undefined, d: string, crv: string, x: string, y: string);
@@ -1036,6 +1638,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Platform.AuthKey["__doNotUseOrImplementIt"];
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace EcKey.$metadata$ {
+            const constructor: abstract new () => EcKey;
+        }
         namespace EcKey {
             class Builder {
                 constructor();
@@ -1049,6 +1655,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setY(y: string): com.doordeck.multiplatform.sdk.model.data.Platform.EcKey.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.Platform.EcKey;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
         }
         class Ed25519Key implements com.doordeck.multiplatform.sdk.model.data.Platform.AuthKey {
             constructor(kty: string | undefined, use: string, kid: string, alg: Nullable<string> | undefined, d: string, crv: string, x: string);
@@ -1065,6 +1675,10 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
             equals(other: Nullable<any>): boolean;
             readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.data.Platform.AuthKey["__doNotUseOrImplementIt"];
         }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Ed25519Key.$metadata$ {
+            const constructor: abstract new () => Ed25519Key;
+        }
         namespace Ed25519Key {
             class Builder {
                 constructor();
@@ -1077,6 +1691,16 @@ export declare namespace com.doordeck.multiplatform.sdk.model.data {
                 setX(x: string): com.doordeck.multiplatform.sdk.model.data.Platform.Ed25519Key.Builder;
                 build(): com.doordeck.multiplatform.sdk.model.data.Platform.Ed25519Key;
             }
+            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+            namespace Builder.$metadata$ {
+                const constructor: abstract new () => Builder;
+            }
+        }
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Platform.$metadata$ {
+        abstract class constructor {
+            private constructor();
         }
     }
 }
@@ -1089,8 +1713,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TokenResponse.$metadata$ {
+        const constructor: abstract new () => TokenResponse;
+    }
+    namespace TokenResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class UserDetailsResponse {
         constructor(email: string, displayName: Nullable<string> | undefined, emailVerified: boolean, publicKey: string);
@@ -1102,8 +1739,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace UserDetailsResponse.$metadata$ {
+        const constructor: abstract new () => UserDetailsResponse;
+    }
+    namespace UserDetailsResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class RegisterEphemeralKeyResponse {
         constructor(certificateChain: kotlin.collections.KtList<string>, userId: string);
@@ -1113,8 +1763,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RegisterEphemeralKeyResponse.$metadata$ {
+        const constructor: abstract new () => RegisterEphemeralKeyResponse;
+    }
+    namespace RegisterEphemeralKeyResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class RegisterEphemeralKeyWithSecondaryAuthenticationResponse {
         constructor(method: com.doordeck.multiplatform.sdk.model.common.TwoFactorMethod);
@@ -1123,8 +1786,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RegisterEphemeralKeyWithSecondaryAuthenticationResponse.$metadata$ {
+        const constructor: abstract new () => RegisterEphemeralKeyWithSecondaryAuthenticationResponse;
+    }
+    namespace RegisterEphemeralKeyWithSecondaryAuthenticationResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.responses {
@@ -1135,18 +1811,44 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
     }
-    class IntegrationTypeResponse {
-        constructor(status?: Nullable<string>);
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace FusionLoginResponse.$metadata$ {
+        const constructor: abstract new () => FusionLoginResponse;
+    }
+    namespace FusionLoginResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+    class IntegrationTypeResponse {
+        constructor(status?: Nullable<string>);
         get status(): Nullable<string>;
         copy(status?: Nullable<string>): com.doordeck.multiplatform.sdk.model.responses.IntegrationTypeResponse;
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace IntegrationTypeResponse.$metadata$ {
+        const constructor: abstract new () => IntegrationTypeResponse;
+    }
+    namespace IntegrationTypeResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class DoorStateResponse {
         constructor(state: com.doordeck.multiplatform.sdk.model.responses.ServiceStateType);
@@ -1155,8 +1857,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace DoorStateResponse.$metadata$ {
+        const constructor: abstract new () => DoorStateResponse;
+    }
+    namespace DoorStateResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class IntegrationConfigurationResponse {
         constructor(doordeck?: Nullable<com.doordeck.multiplatform.sdk.model.responses.ControllerResponse>, service?: Nullable<com.doordeck.multiplatform.sdk.model.responses.ServiceStateResponse>, integration?: Nullable<com.doordeck.multiplatform.sdk.model.responses.DiscoveredDeviceResponse>);
@@ -1167,8 +1882,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace IntegrationConfigurationResponse.$metadata$ {
+        const constructor: abstract new () => IntegrationConfigurationResponse;
+    }
+    namespace IntegrationConfigurationResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class ControllerResponse {
         constructor(id: string, name?: Nullable<string>, role?: Nullable<com.doordeck.multiplatform.sdk.model.common.UserRole>);
@@ -1179,8 +1907,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ControllerResponse.$metadata$ {
+        const constructor: abstract new () => ControllerResponse;
+    }
+    namespace ControllerResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class ServiceStateResponse {
         constructor(state: com.doordeck.multiplatform.sdk.model.responses.ServiceStateType);
@@ -1189,8 +1930,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ServiceStateResponse.$metadata$ {
+        const constructor: abstract new () => ServiceStateResponse;
+    }
+    namespace ServiceStateResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class DiscoveredDeviceResponse {
         constructor(key: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController, metadata: kotlin.collections.KtMap<string, string>);
@@ -1200,8 +1954,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace DiscoveredDeviceResponse.$metadata$ {
+        const constructor: abstract new () => DiscoveredDeviceResponse;
+    }
+    namespace DiscoveredDeviceResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     abstract class ServiceStateType {
         private constructor();
@@ -1221,8 +1988,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         get ordinal(): 0 | 1 | 2;
         static values(): Array<com.doordeck.multiplatform.sdk.model.responses.ServiceStateType>;
         static valueOf(value: string): com.doordeck.multiplatform.sdk.model.responses.ServiceStateType;
-        static get Companion(): {
-        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ServiceStateType.$metadata$ {
+        const constructor: abstract new () => ServiceStateType;
+    }
+    namespace ServiceStateType {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.responses {
@@ -1234,8 +2014,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace AssistedLoginResponse.$metadata$ {
+        const constructor: abstract new () => AssistedLoginResponse;
+    }
+    namespace AssistedLoginResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class AssistedRegisterEphemeralKeyResponse {
         constructor(requiresVerification: boolean, requiresRetry: boolean);
@@ -1245,8 +2038,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace AssistedRegisterEphemeralKeyResponse.$metadata$ {
+        const constructor: abstract new () => AssistedRegisterEphemeralKeyResponse;
+    }
+    namespace AssistedRegisterEphemeralKeyResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.responses {
@@ -1266,8 +2072,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LockResponse.$metadata$ {
+        const constructor: abstract new () => LockResponse;
+    }
+    namespace LockResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class LockSettingsResponse {
         constructor(unlockTime: number, permittedAddresses: kotlin.collections.KtList<string>, defaultName: string, usageRequirements: Nullable<com.doordeck.multiplatform.sdk.model.responses.UsageRequirementsResponse> | undefined, unlockBetweenWindow: Nullable<com.doordeck.multiplatform.sdk.model.responses.UnlockBetweenSettingResponse> | undefined, tiles: kotlin.collections.KtList<string>, hidden: boolean, directAccessEndpoints?: kotlin.collections.KtList<string>, capabilities?: kotlin.collections.KtMap<com.doordeck.multiplatform.sdk.model.common.CapabilityType, com.doordeck.multiplatform.sdk.model.common.CapabilityStatus>);
@@ -1284,8 +2103,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LockSettingsResponse.$metadata$ {
+        const constructor: abstract new () => LockSettingsResponse;
+    }
+    namespace LockSettingsResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class UsageRequirementsResponse {
         constructor(time?: Nullable<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.TimeRequirementResponse>>, location?: Nullable<com.doordeck.multiplatform.sdk.model.responses.LocationRequirementResponse>);
@@ -1295,8 +2127,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace UsageRequirementsResponse.$metadata$ {
+        const constructor: abstract new () => UsageRequirementsResponse;
+    }
+    namespace UsageRequirementsResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class TimeRequirementResponse {
         constructor(start: string, end: string, timezone: string, days: kotlin.collections.KtList<string>);
@@ -1308,8 +2153,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TimeRequirementResponse.$metadata$ {
+        const constructor: abstract new () => TimeRequirementResponse;
+    }
+    namespace TimeRequirementResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class LocationRequirementResponse {
         constructor(latitude: number, longitude: number, enabled: boolean, radius: number, accuracy: number);
@@ -1322,8 +2180,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LocationRequirementResponse.$metadata$ {
+        const constructor: abstract new () => LocationRequirementResponse;
+    }
+    namespace LocationRequirementResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class UnlockBetweenSettingResponse {
         constructor(start: string, end: string, timezone: string, days: kotlin.collections.KtList<string>, exceptions?: Nullable<kotlin.collections.KtList<string>>);
@@ -1336,8 +2207,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace UnlockBetweenSettingResponse.$metadata$ {
+        const constructor: abstract new () => UnlockBetweenSettingResponse;
+    }
+    namespace UnlockBetweenSettingResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class LockStateResponse {
         constructor(locked: boolean, connected: boolean);
@@ -1347,8 +2231,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LockStateResponse.$metadata$ {
+        const constructor: abstract new () => LockStateResponse;
+    }
+    namespace LockStateResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class UserPublicKeyResponse {
         constructor(id: string, publicKey: string);
@@ -1358,8 +2255,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace UserPublicKeyResponse.$metadata$ {
+        const constructor: abstract new () => UserPublicKeyResponse;
+    }
+    namespace UserPublicKeyResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class BatchUserPublicKeyResponse {
         constructor(id: string, email: Nullable<string> | undefined, foreignKey: Nullable<string> | undefined, phone: Nullable<string> | undefined, publicKey: string);
@@ -1372,8 +2282,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace BatchUserPublicKeyResponse.$metadata$ {
+        const constructor: abstract new () => BatchUserPublicKeyResponse;
+    }
+    namespace BatchUserPublicKeyResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class ShareableLockResponse {
         constructor(id: string, name: string);
@@ -1383,8 +2306,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ShareableLockResponse.$metadata$ {
+        const constructor: abstract new () => ShareableLockResponse;
+    }
+    namespace ShareableLockResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class UserLockResponse {
         constructor(userId: string, email: string, publicKey: string, displayName: Nullable<string> | undefined, orphan: boolean, foreign: boolean, role: com.doordeck.multiplatform.sdk.model.common.UserRole, start?: Nullable<number>, end?: Nullable<number>);
@@ -1401,8 +2337,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace UserLockResponse.$metadata$ {
+        const constructor: abstract new () => UserLockResponse;
+    }
+    namespace UserLockResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class LockUserResponse {
         constructor(userId: string, email: string, publicKey: string, displayName: Nullable<string> | undefined, orphan: boolean, foreign: boolean, start: Nullable<number> | undefined, end: Nullable<number> | undefined, devices: kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.LockUserDetailsResponse>);
@@ -1419,8 +2368,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LockUserResponse.$metadata$ {
+        const constructor: abstract new () => LockUserResponse;
+    }
+    namespace LockUserResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class LockUserDetailsResponse {
         constructor(deviceId: string, role: com.doordeck.multiplatform.sdk.model.common.UserRole, start?: Nullable<number>, end?: Nullable<number>);
@@ -1432,8 +2394,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LockUserDetailsResponse.$metadata$ {
+        const constructor: abstract new () => LockUserDetailsResponse;
+    }
+    namespace LockUserDetailsResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class AuditResponse {
         constructor(deviceId: string, timestamp: number, type: com.doordeck.multiplatform.sdk.model.common.AuditEvent, issuer: com.doordeck.multiplatform.sdk.model.responses.AuditIssuerResponse, subject: Nullable<com.doordeck.multiplatform.sdk.model.responses.AuditSubjectResponse> | undefined, rejectionReason: Nullable<string> | undefined, rejected: boolean);
@@ -1448,8 +2423,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace AuditResponse.$metadata$ {
+        const constructor: abstract new () => AuditResponse;
+    }
+    namespace AuditResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class AuditIssuerResponse {
         constructor(userId: string, email?: Nullable<string>, ip?: Nullable<string>);
@@ -1460,8 +2448,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace AuditIssuerResponse.$metadata$ {
+        const constructor: abstract new () => AuditIssuerResponse;
+    }
+    namespace AuditIssuerResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class AuditSubjectResponse {
         constructor(userId: string, email: string, displayName?: Nullable<string>);
@@ -1472,8 +2473,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace AuditSubjectResponse.$metadata$ {
+        const constructor: abstract new () => AuditSubjectResponse;
+    }
+    namespace AuditSubjectResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.responses {
@@ -1500,8 +2514,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ApplicationResponse.$metadata$ {
+        const constructor: abstract new () => ApplicationResponse;
+    }
+    namespace ApplicationResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     interface AuthKeyResponse {
         readonly kid: string;
@@ -1519,8 +2546,15 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
             readonly "com.doordeck.multiplatform.sdk.model.responses.AuthKeyResponse": unique symbol;
         };
     }
-    const AuthKeyResponse: {
-    } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    abstract class AuthKeyResponse extends KtSingleton<AuthKeyResponse.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace AuthKeyResponse.$metadata$ {
+        abstract class constructor /* implements kotlinx.serialization.internal.SerializerFactory */ {
+            private constructor();
+        }
+    }
     class RsaKeyResponse implements com.doordeck.multiplatform.sdk.model.responses.AuthKeyResponse {
         constructor(use: string, kid: string, alg: Nullable<string> | undefined, ops: Nullable<kotlin.collections.KtList<string>> | undefined, x5u: Nullable<string> | undefined, x5t: Nullable<string> | undefined, x5t256: Nullable<string> | undefined, x5c: Nullable<kotlin.collections.KtList<string>> | undefined, exp: Nullable<number> | undefined, nbf: Nullable<number> | undefined, iat: Nullable<number> | undefined, e: string, n: string);
         get use(): string;
@@ -1541,8 +2575,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.responses.AuthKeyResponse["__doNotUseOrImplementIt"];
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RsaKeyResponse.$metadata$ {
+        const constructor: abstract new () => RsaKeyResponse;
+    }
+    namespace RsaKeyResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class EcKeyResponse implements com.doordeck.multiplatform.sdk.model.responses.AuthKeyResponse {
         constructor(use: string, kid: string, alg: Nullable<string> | undefined, ops: Nullable<kotlin.collections.KtList<string>> | undefined, x5u: Nullable<string> | undefined, x5t: Nullable<string> | undefined, x5t256: Nullable<string> | undefined, x5c: Nullable<kotlin.collections.KtList<string>> | undefined, exp: Nullable<number> | undefined, nbf: Nullable<number> | undefined, iat: Nullable<number> | undefined, crv: string, x: string, y: string);
@@ -1565,8 +2612,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.responses.AuthKeyResponse["__doNotUseOrImplementIt"];
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace EcKeyResponse.$metadata$ {
+        const constructor: abstract new () => EcKeyResponse;
+    }
+    namespace EcKeyResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class Ed25519KeyResponse implements com.doordeck.multiplatform.sdk.model.responses.AuthKeyResponse {
         constructor(use: string, kid: string, alg: Nullable<string> | undefined, ops: Nullable<kotlin.collections.KtList<string>> | undefined, x5u: Nullable<string> | undefined, x5t: Nullable<string> | undefined, x5t256: Nullable<string> | undefined, x5c: Nullable<kotlin.collections.KtList<string>> | undefined, exp: Nullable<number> | undefined, nbf: Nullable<number> | undefined, iat: Nullable<number> | undefined, d: Nullable<string> | undefined, crv: string, x: string);
@@ -1589,8 +2649,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
         readonly __doNotUseOrImplementIt: com.doordeck.multiplatform.sdk.model.responses.AuthKeyResponse["__doNotUseOrImplementIt"];
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Ed25519KeyResponse.$metadata$ {
+        const constructor: abstract new () => Ed25519KeyResponse;
+    }
+    namespace Ed25519KeyResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class EmailPreferencesResponse {
         constructor(senderEmail: Nullable<string> | undefined, senderName: Nullable<string> | undefined, primaryColour: string, secondaryColour: string, onlySendEssentialEmails?: Nullable<boolean>, callToAction?: Nullable<com.doordeck.multiplatform.sdk.model.responses.EmailCallToActionResponse>);
@@ -1604,8 +2677,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace EmailPreferencesResponse.$metadata$ {
+        const constructor: abstract new () => EmailPreferencesResponse;
+    }
+    namespace EmailPreferencesResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class EmailCallToActionResponse {
         constructor(actionTarget: string, headline: string, actionText: string);
@@ -1616,8 +2702,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace EmailCallToActionResponse.$metadata$ {
+        const constructor: abstract new () => EmailCallToActionResponse;
+    }
+    namespace EmailCallToActionResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class OauthResponse {
         constructor(authorizationEndpoint: string, clientId: string, grantType: string);
@@ -1628,8 +2727,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace OauthResponse.$metadata$ {
+        const constructor: abstract new () => OauthResponse;
+    }
+    namespace OauthResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class ApplicationOwnerDetailsResponse {
         constructor(userId: string, email: string, displayName: Nullable<string> | undefined, orphan: boolean, foreign: boolean);
@@ -1642,8 +2754,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ApplicationOwnerDetailsResponse.$metadata$ {
+        const constructor: abstract new () => ApplicationOwnerDetailsResponse;
+    }
+    namespace ApplicationOwnerDetailsResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class GetLogoUploadUrlResponse {
         constructor(uploadUrl: string);
@@ -1652,8 +2777,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace GetLogoUploadUrlResponse.$metadata$ {
+        const constructor: abstract new () => GetLogoUploadUrlResponse;
+    }
+    namespace GetLogoUploadUrlResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.responses {
@@ -1672,8 +2810,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace SiteResponse.$metadata$ {
+        const constructor: abstract new () => SiteResponse;
+    }
+    namespace SiteResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class SiteLocksResponse {
         constructor(id: string, name: string, colour: Nullable<string> | undefined, role: com.doordeck.multiplatform.sdk.model.common.UserRole, settings: com.doordeck.multiplatform.sdk.model.responses.SiteLockSettingsResponse);
@@ -1686,8 +2837,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace SiteLocksResponse.$metadata$ {
+        const constructor: abstract new () => SiteLocksResponse;
+    }
+    namespace SiteLocksResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class SiteLockSettingsResponse {
         constructor(unlockTime: number, permittedAddresses: kotlin.collections.KtList<string>, defaultName: string, tiles: kotlin.collections.KtList<string>, state?: Nullable<com.doordeck.multiplatform.sdk.model.responses.SiteStateResponse>, favourite?: Nullable<boolean>);
@@ -1701,8 +2865,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace SiteLockSettingsResponse.$metadata$ {
+        const constructor: abstract new () => SiteLockSettingsResponse;
+    }
+    namespace SiteLockSettingsResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class SiteStateResponse {
         constructor(connected: boolean);
@@ -1711,8 +2888,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace SiteStateResponse.$metadata$ {
+        const constructor: abstract new () => SiteStateResponse;
+    }
+    namespace SiteStateResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
     class UserForSiteResponse {
         constructor(userId: string, email: string, displayName: Nullable<string> | undefined, orphan: boolean);
@@ -1724,8 +2914,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace UserForSiteResponse.$metadata$ {
+        const constructor: abstract new () => UserForSiteResponse;
+    }
+    namespace UserForSiteResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.model.responses {
@@ -1738,8 +2941,21 @@ export declare namespace com.doordeck.multiplatform.sdk.model.responses {
         toString(): string;
         hashCode(): number;
         equals(other: Nullable<any>): boolean;
-        static get Companion(): {
-        };
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TileLocksResponse.$metadata$ {
+        const constructor: abstract new () => TileLocksResponse;
+    }
+    namespace TileLocksResponse {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.storage {
@@ -1773,142 +2989,212 @@ export declare namespace com.doordeck.multiplatform.sdk.storage {
     }
 }
 export declare namespace com.doordeck.multiplatform.sdk.util {
-    const Utils: {
-        decodeBase64ToByteArray(_this_: string): Int8Array;
-        encodeByteArrayToBase64(_this_: Int8Array): string;
-        certificateChainToString(_this_: kotlin.collections.KtList<string>): string;
-        stringToCertificateChain(_this_: string): kotlin.collections.KtList<string>;
-    };
+    abstract class Utils extends KtSingleton<Utils.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Utils.$metadata$ {
+        abstract class constructor {
+            decodeBase64ToByteArray(_this_: string): Int8Array;
+            encodeByteArrayToBase64(_this_: Int8Array): string;
+            certificateChainToString(_this_: kotlin.collections.KtList<string>): string;
+            stringToCertificateChain(_this_: string): kotlin.collections.KtList<string>;
+            private constructor();
+        }
+    }
 }
 export declare namespace com.doordeck.multiplatform.sdk.api {
-    const AccountApi: {
-        refreshToken(refreshToken?: Nullable<string>): Promise<com.doordeck.multiplatform.sdk.model.responses.TokenResponse>;
-        logout(): Promise<any>;
-        registerEphemeralKey(publicKey?: Nullable<Int8Array>): Promise<com.doordeck.multiplatform.sdk.model.responses.RegisterEphemeralKeyResponse>;
-        registerEphemeralKeyWithSecondaryAuthentication(publicKey?: Nullable<Int8Array>, method?: Nullable<com.doordeck.multiplatform.sdk.model.common.TwoFactorMethod>): Promise<com.doordeck.multiplatform.sdk.model.responses.RegisterEphemeralKeyWithSecondaryAuthenticationResponse>;
-        verifyEphemeralKeyRegistration(code: string, privateKey?: Nullable<Int8Array>): Promise<com.doordeck.multiplatform.sdk.model.responses.RegisterEphemeralKeyResponse>;
-        reverifyEmail(): Promise<any>;
-        changePassword(oldPassword: string, newPassword: string): Promise<any>;
-        getUserDetails(): Promise<com.doordeck.multiplatform.sdk.model.responses.UserDetailsResponse>;
-        updateUserDetails(displayName: string): Promise<any>;
-        deleteAccount(): Promise<any>;
-    };
+    abstract class AccountApi extends KtSingleton<AccountApi.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace AccountApi.$metadata$ {
+        abstract class constructor {
+            refreshToken(refreshToken?: Nullable<string>): Promise<com.doordeck.multiplatform.sdk.model.responses.TokenResponse>;
+            logout(): Promise<any>;
+            registerEphemeralKey(publicKey?: Nullable<Int8Array>): Promise<com.doordeck.multiplatform.sdk.model.responses.RegisterEphemeralKeyResponse>;
+            registerEphemeralKeyWithSecondaryAuthentication(publicKey?: Nullable<Int8Array>, method?: Nullable<com.doordeck.multiplatform.sdk.model.common.TwoFactorMethod>): Promise<com.doordeck.multiplatform.sdk.model.responses.RegisterEphemeralKeyWithSecondaryAuthenticationResponse>;
+            verifyEphemeralKeyRegistration(code: string, privateKey?: Nullable<Int8Array>): Promise<com.doordeck.multiplatform.sdk.model.responses.RegisterEphemeralKeyResponse>;
+            reverifyEmail(): Promise<any>;
+            changePassword(oldPassword: string, newPassword: string): Promise<any>;
+            getUserDetails(): Promise<com.doordeck.multiplatform.sdk.model.responses.UserDetailsResponse>;
+            updateUserDetails(displayName: string): Promise<any>;
+            deleteAccount(): Promise<any>;
+            private constructor();
+        }
+    }
     function account(): typeof com.doordeck.multiplatform.sdk.api.AccountApi;
 }
 export declare namespace com.doordeck.multiplatform.sdk.api {
-    const AccountlessApi: {
-        login(email: string, password: string): Promise<com.doordeck.multiplatform.sdk.model.responses.TokenResponse>;
-        registration(email: string, password: string, displayName?: Nullable<string>, force?: boolean, publicKey?: Nullable<Int8Array>): Promise<com.doordeck.multiplatform.sdk.model.responses.TokenResponse>;
-        verifyEmail(code: string): Promise<any>;
-        passwordReset(email: string): Promise<any>;
-        passwordResetVerify(userId: string, token: string, password: string): Promise<any>;
-    };
+    abstract class AccountlessApi extends KtSingleton<AccountlessApi.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace AccountlessApi.$metadata$ {
+        abstract class constructor {
+            login(email: string, password: string): Promise<com.doordeck.multiplatform.sdk.model.responses.TokenResponse>;
+            registration(email: string, password: string, displayName?: Nullable<string>, force?: boolean, publicKey?: Nullable<Int8Array>): Promise<com.doordeck.multiplatform.sdk.model.responses.TokenResponse>;
+            verifyEmail(code: string): Promise<any>;
+            passwordReset(email: string): Promise<any>;
+            passwordResetVerify(userId: string, token: string, password: string): Promise<any>;
+            private constructor();
+        }
+    }
     function accountless(): typeof com.doordeck.multiplatform.sdk.api.AccountlessApi;
 }
 export declare namespace com.doordeck.multiplatform.sdk.api {
-    const FusionApi: {
-        login(email: string, password: string): Promise<com.doordeck.multiplatform.sdk.model.responses.FusionLoginResponse>;
-        getIntegrationType(): Promise<com.doordeck.multiplatform.sdk.model.responses.IntegrationTypeResponse>;
-        getIntegrationConfiguration(type: string): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.IntegrationConfigurationResponse>>;
-        enableDoor(name: string, siteId: string, controller: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController): Promise<any>;
-        deleteDoor(deviceId: string): Promise<any>;
-        getDoorStatus(deviceId: string): Promise<com.doordeck.multiplatform.sdk.model.responses.DoorStateResponse>;
-        startDoor(deviceId: string): Promise<any>;
-        stopDoor(deviceId: string): Promise<any>;
-    };
+    abstract class FusionApi extends KtSingleton<FusionApi.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace FusionApi.$metadata$ {
+        abstract class constructor {
+            login(email: string, password: string): Promise<com.doordeck.multiplatform.sdk.model.responses.FusionLoginResponse>;
+            getIntegrationType(): Promise<com.doordeck.multiplatform.sdk.model.responses.IntegrationTypeResponse>;
+            getIntegrationConfiguration(type: string): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.IntegrationConfigurationResponse>>;
+            enableDoor(name: string, siteId: string, controller: com.doordeck.multiplatform.sdk.model.data.Fusion.LockController): Promise<any>;
+            deleteDoor(deviceId: string): Promise<any>;
+            getDoorStatus(deviceId: string): Promise<com.doordeck.multiplatform.sdk.model.responses.DoorStateResponse>;
+            startDoor(deviceId: string): Promise<any>;
+            stopDoor(deviceId: string): Promise<any>;
+            private constructor();
+        }
+    }
     function fusion(): typeof com.doordeck.multiplatform.sdk.api.FusionApi;
 }
 export declare namespace com.doordeck.multiplatform.sdk.api {
-    const HelperApi: {
-        uploadPlatformLogo(applicationId: string, contentType: string, image: Int8Array): Promise<any>;
-        assistedLogin(email: string, password: string): Promise<com.doordeck.multiplatform.sdk.model.responses.AssistedLoginResponse>;
-        assistedRegisterEphemeralKey(publicKey?: Nullable<Int8Array>): Promise<com.doordeck.multiplatform.sdk.model.responses.AssistedRegisterEphemeralKeyResponse>;
-        assistedRegister(email: string, password: string, displayName?: Nullable<string>, force?: boolean): Promise<any>;
-    };
+    abstract class HelperApi extends KtSingleton<HelperApi.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace HelperApi.$metadata$ {
+        abstract class constructor {
+            uploadPlatformLogo(applicationId: string, contentType: string, image: Int8Array): Promise<any>;
+            assistedLogin(email: string, password: string): Promise<com.doordeck.multiplatform.sdk.model.responses.AssistedLoginResponse>;
+            assistedRegisterEphemeralKey(publicKey?: Nullable<Int8Array>): Promise<com.doordeck.multiplatform.sdk.model.responses.AssistedRegisterEphemeralKeyResponse>;
+            assistedRegister(email: string, password: string, displayName?: Nullable<string>, force?: boolean): Promise<any>;
+            private constructor();
+        }
+    }
     function helper(): typeof com.doordeck.multiplatform.sdk.api.HelperApi;
 }
 export declare namespace com.doordeck.multiplatform.sdk.api {
-    const LockOperationsApi: {
-        getSingleLock(lockId: string): Promise<com.doordeck.multiplatform.sdk.model.responses.LockResponse>;
-        getLockAuditTrail(lockId: string, start: number, end: number): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.AuditResponse>>;
-        getAuditForUser(userId: string, start: number, end: number): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.AuditResponse>>;
-        getUsersForLock(lockId: string): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.UserLockResponse>>;
-        getLocksForUser(userId: string): Promise<com.doordeck.multiplatform.sdk.model.responses.LockUserResponse>;
-        updateLockName(lockId: string, name?: Nullable<string>): Promise<any>;
-        updateLockFavourite(lockId: string, favourite?: Nullable<boolean>): Promise<any>;
-        updateLockColour(lockId: string, colour?: Nullable<string>): Promise<any>;
-        updateLockSettingDefaultName(lockId: string, name?: Nullable<string>): Promise<any>;
-        setLockSettingPermittedAddresses(lockId: string, permittedAddresses: kotlin.collections.KtList<string>): Promise<any>;
-        updateLockSettingHidden(lockId: string, hidden: boolean): Promise<any>;
-        setLockSettingTimeRestrictions(lockId: string, times: kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.data.LockOperations.TimeRequirement>): Promise<any>;
-        updateLockSettingLocationRestrictions(lockId: string, location?: Nullable<com.doordeck.multiplatform.sdk.model.data.LockOperations.LocationRequirement>): Promise<any>;
-        getUserPublicKey(userEmail: string, visitor?: boolean): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
-        getUserPublicKeyByEmail(email: string): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
-        getUserPublicKeyByTelephone(telephone: string): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
-        getUserPublicKeyByLocalKey(localKey: string): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
-        getUserPublicKeyByForeignKey(foreignKey: string): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
-        getUserPublicKeyByIdentity(identity: string): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
-        getUserPublicKeyByEmails(emails: kotlin.collections.KtList<string>): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.BatchUserPublicKeyResponse>>;
-        getUserPublicKeyByTelephones(telephones: kotlin.collections.KtList<string>): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.BatchUserPublicKeyResponse>>;
-        getUserPublicKeyByLocalKeys(localKeys: kotlin.collections.KtList<string>): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.BatchUserPublicKeyResponse>>;
-        getUserPublicKeyByForeignKeys(foreignKeys: kotlin.collections.KtList<string>): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.BatchUserPublicKeyResponse>>;
-        unlock(unlockOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.UnlockOperation): Promise<any>;
-        shareLock(shareLockOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.ShareLockOperation): Promise<any>;
-        batchShareLock(batchShareLockOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.BatchShareLockOperation): Promise<any>;
-        revokeAccessToLock(revokeAccessToLockOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.RevokeAccessToLockOperation): Promise<any>;
-        updateSecureSettingUnlockDuration(updateSecureSettingUnlockDuration: com.doordeck.multiplatform.sdk.model.data.LockOperations.UpdateSecureSettingUnlockDuration): Promise<any>;
-        updateSecureSettingUnlockBetween(updateSecureSettingUnlockBetween: com.doordeck.multiplatform.sdk.model.data.LockOperations.UpdateSecureSettingUnlockBetween): Promise<any>;
-        getPinnedLocks(): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.LockResponse>>;
-        getShareableLocks(): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.ShareableLockResponse>>;
-    };
+    abstract class LockOperationsApi extends KtSingleton<LockOperationsApi.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace LockOperationsApi.$metadata$ {
+        abstract class constructor {
+            getSingleLock(lockId: string): Promise<com.doordeck.multiplatform.sdk.model.responses.LockResponse>;
+            getLockAuditTrail(lockId: string, start: number, end: number): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.AuditResponse>>;
+            getAuditForUser(userId: string, start: number, end: number): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.AuditResponse>>;
+            getUsersForLock(lockId: string): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.UserLockResponse>>;
+            getLocksForUser(userId: string): Promise<com.doordeck.multiplatform.sdk.model.responses.LockUserResponse>;
+            updateLockName(lockId: string, name?: Nullable<string>): Promise<any>;
+            updateLockFavourite(lockId: string, favourite?: Nullable<boolean>): Promise<any>;
+            updateLockColour(lockId: string, colour?: Nullable<string>): Promise<any>;
+            updateLockSettingDefaultName(lockId: string, name?: Nullable<string>): Promise<any>;
+            setLockSettingPermittedAddresses(lockId: string, permittedAddresses: kotlin.collections.KtList<string>): Promise<any>;
+            updateLockSettingHidden(lockId: string, hidden: boolean): Promise<any>;
+            setLockSettingTimeRestrictions(lockId: string, times: kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.data.LockOperations.TimeRequirement>): Promise<any>;
+            updateLockSettingLocationRestrictions(lockId: string, location?: Nullable<com.doordeck.multiplatform.sdk.model.data.LockOperations.LocationRequirement>): Promise<any>;
+            getUserPublicKey(userEmail: string, visitor?: boolean): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
+            getUserPublicKeyByEmail(email: string): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
+            getUserPublicKeyByTelephone(telephone: string): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
+            getUserPublicKeyByLocalKey(localKey: string): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
+            getUserPublicKeyByForeignKey(foreignKey: string): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
+            getUserPublicKeyByIdentity(identity: string): Promise<com.doordeck.multiplatform.sdk.model.responses.UserPublicKeyResponse>;
+            getUserPublicKeyByEmails(emails: kotlin.collections.KtList<string>): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.BatchUserPublicKeyResponse>>;
+            getUserPublicKeyByTelephones(telephones: kotlin.collections.KtList<string>): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.BatchUserPublicKeyResponse>>;
+            getUserPublicKeyByLocalKeys(localKeys: kotlin.collections.KtList<string>): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.BatchUserPublicKeyResponse>>;
+            getUserPublicKeyByForeignKeys(foreignKeys: kotlin.collections.KtList<string>): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.BatchUserPublicKeyResponse>>;
+            unlock(unlockOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.UnlockOperation): Promise<any>;
+            shareLock(shareLockOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.ShareLockOperation): Promise<any>;
+            batchShareLock(batchShareLockOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.BatchShareLockOperation): Promise<any>;
+            revokeAccessToLock(revokeAccessToLockOperation: com.doordeck.multiplatform.sdk.model.data.LockOperations.RevokeAccessToLockOperation): Promise<any>;
+            updateSecureSettingUnlockDuration(updateSecureSettingUnlockDuration: com.doordeck.multiplatform.sdk.model.data.LockOperations.UpdateSecureSettingUnlockDuration): Promise<any>;
+            updateSecureSettingUnlockBetween(updateSecureSettingUnlockBetween: com.doordeck.multiplatform.sdk.model.data.LockOperations.UpdateSecureSettingUnlockBetween): Promise<any>;
+            getPinnedLocks(): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.LockResponse>>;
+            getShareableLocks(): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.ShareableLockResponse>>;
+            private constructor();
+        }
+    }
     function lockOperations(): typeof com.doordeck.multiplatform.sdk.api.LockOperationsApi;
 }
 export declare namespace com.doordeck.multiplatform.sdk.api {
-    const PlatformApi: {
-        createApplication(application: com.doordeck.multiplatform.sdk.model.data.Platform.CreateApplication): Promise<any>;
-        listApplications(): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.ApplicationResponse>>;
-        getApplication(applicationId: string): Promise<com.doordeck.multiplatform.sdk.model.responses.ApplicationResponse>;
-        updateApplicationName(applicationId: string, name: string): Promise<any>;
-        updateApplicationCompanyName(applicationId: string, companyName: string): Promise<any>;
-        updateApplicationMailingAddress(applicationId: string, mailingAddress: string): Promise<any>;
-        updateApplicationPrivacyPolicy(applicationId: string, privacyPolicy: string): Promise<any>;
-        updateApplicationSupportContact(applicationId: string, supportContact: string): Promise<any>;
-        updateApplicationAppLink(applicationId: string, appLink: string): Promise<any>;
-        updateApplicationEmailPreferences(applicationId: string, emailPreferences: com.doordeck.multiplatform.sdk.model.data.Platform.EmailPreferences): Promise<any>;
-        updateApplicationLogoUrl(applicationId: string, logoUrl: string): Promise<any>;
-        deleteApplication(applicationId: string): Promise<any>;
-        getLogoUploadUrl(applicationId: string, contentType: string): Promise<com.doordeck.multiplatform.sdk.model.responses.GetLogoUploadUrlResponse>;
-        addAuthKey(applicationId: string, key: com.doordeck.multiplatform.sdk.model.data.Platform.AuthKey): Promise<any>;
-        addAuthIssuer(applicationId: string, url: string): Promise<any>;
-        deleteAuthIssuer(applicationId: string, url: string): Promise<any>;
-        addCorsDomain(applicationId: string, url: string): Promise<any>;
-        removeCorsDomain(applicationId: string, url: string): Promise<any>;
-        addApplicationOwner(applicationId: string, userId: string): Promise<any>;
-        removeApplicationOwner(applicationId: string, userId: string): Promise<any>;
-        getApplicationOwnersDetails(applicationId: string): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.ApplicationOwnerDetailsResponse>>;
-    };
+    abstract class PlatformApi extends KtSingleton<PlatformApi.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace PlatformApi.$metadata$ {
+        abstract class constructor {
+            createApplication(application: com.doordeck.multiplatform.sdk.model.data.Platform.CreateApplication): Promise<any>;
+            listApplications(): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.ApplicationResponse>>;
+            getApplication(applicationId: string): Promise<com.doordeck.multiplatform.sdk.model.responses.ApplicationResponse>;
+            updateApplicationName(applicationId: string, name: string): Promise<any>;
+            updateApplicationCompanyName(applicationId: string, companyName: string): Promise<any>;
+            updateApplicationMailingAddress(applicationId: string, mailingAddress: string): Promise<any>;
+            updateApplicationPrivacyPolicy(applicationId: string, privacyPolicy: string): Promise<any>;
+            updateApplicationSupportContact(applicationId: string, supportContact: string): Promise<any>;
+            updateApplicationAppLink(applicationId: string, appLink: string): Promise<any>;
+            updateApplicationEmailPreferences(applicationId: string, emailPreferences: com.doordeck.multiplatform.sdk.model.data.Platform.EmailPreferences): Promise<any>;
+            updateApplicationLogoUrl(applicationId: string, logoUrl: string): Promise<any>;
+            deleteApplication(applicationId: string): Promise<any>;
+            getLogoUploadUrl(applicationId: string, contentType: string): Promise<com.doordeck.multiplatform.sdk.model.responses.GetLogoUploadUrlResponse>;
+            addAuthKey(applicationId: string, key: com.doordeck.multiplatform.sdk.model.data.Platform.AuthKey): Promise<any>;
+            addAuthIssuer(applicationId: string, url: string): Promise<any>;
+            deleteAuthIssuer(applicationId: string, url: string): Promise<any>;
+            addCorsDomain(applicationId: string, url: string): Promise<any>;
+            removeCorsDomain(applicationId: string, url: string): Promise<any>;
+            addApplicationOwner(applicationId: string, userId: string): Promise<any>;
+            removeApplicationOwner(applicationId: string, userId: string): Promise<any>;
+            getApplicationOwnersDetails(applicationId: string): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.ApplicationOwnerDetailsResponse>>;
+            private constructor();
+        }
+    }
     function platform(): typeof com.doordeck.multiplatform.sdk.api.PlatformApi;
 }
 export declare namespace com.doordeck.multiplatform.sdk.api {
-    const SitesApi: {
-        listSites(): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.SiteResponse>>;
-        getLocksForSite(siteId: string): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.SiteLocksResponse>>;
-        getUsersForSite(siteId: string): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.UserForSiteResponse>>;
-    };
+    abstract class SitesApi extends KtSingleton<SitesApi.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace SitesApi.$metadata$ {
+        abstract class constructor {
+            listSites(): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.SiteResponse>>;
+            getLocksForSite(siteId: string): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.SiteLocksResponse>>;
+            getUsersForSite(siteId: string): Promise<kotlin.collections.KtList<com.doordeck.multiplatform.sdk.model.responses.UserForSiteResponse>>;
+            private constructor();
+        }
+    }
     function sites(): typeof com.doordeck.multiplatform.sdk.api.SitesApi;
 }
 export declare namespace com.doordeck.multiplatform.sdk.api {
-    const TilesApi: {
-        getLocksBelongingToTile(tileId: string): Promise<com.doordeck.multiplatform.sdk.model.responses.TileLocksResponse>;
-        associateMultipleLocks(tileId: string, siteId: string, lockIds: kotlin.collections.KtList<string>): Promise<any>;
-    };
+    abstract class TilesApi extends KtSingleton<TilesApi.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace TilesApi.$metadata$ {
+        abstract class constructor {
+            getLocksBelongingToTile(tileId: string): Promise<com.doordeck.multiplatform.sdk.model.responses.TileLocksResponse>;
+            associateMultipleLocks(tileId: string, siteId: string, lockIds: kotlin.collections.KtList<string>): Promise<any>;
+            private constructor();
+        }
+    }
     function tiles(): typeof com.doordeck.multiplatform.sdk.api.TilesApi;
 }
 export declare namespace com.doordeck.multiplatform.sdk.crypto {
-    const CryptoManager: {
-        generateKeyPair(): com.doordeck.multiplatform.sdk.model.data.Crypto.KeyPair;
-        generateEncodedKeyPair(): string;
-        isCertificateInvalidOrExpired(base64Certificate: string): boolean;
-    };
+    abstract class CryptoManager extends KtSingleton<CryptoManager.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace CryptoManager.$metadata$ {
+        abstract class constructor {
+            generateKeyPair(): com.doordeck.multiplatform.sdk.model.data.Crypto.KeyPair;
+            generateEncodedKeyPair(): string;
+            isCertificateInvalidOrExpired(base64Certificate: string): boolean;
+            private constructor();
+        }
+    }
     function crypto(): typeof com.doordeck.multiplatform.sdk.crypto.CryptoManager;
 }