doordeck-headless-sdk 0.86.0__py3-none-any.whl → 0.88.0__py3-none-any.whl

doordeck_headless_sdk/doordeck_headless_sdk.py

@@ -68,6 +68,7 @@ import base64
 import asyncio
 import ctypes
 from enum import Enum
+from types import SimpleNamespace
 from typing import List, Optional
 from dataclasses import dataclass, field
 
@@ -167,9 +168,6 @@ class GatewayTimeoutException(SdkException):
 def current_epoch_seconds() -> int:
     return int(time.time())
 
-def get_success_result(json_response):
-    return json_response["success"]["result"]
-
 def decode_base64_to_byte_array(input):
     return base64.b64decode(input)
 
@@ -183,10 +181,10 @@ def string_to_certificate_chain(input):
     return input.split('|')
 
 def handle_exception(response):
-    if response["failure"] is None:
+    if response.failure is None:
         return
-    exception_type = response["failure"]["exceptionType"]
-    exception_message = response["failure"]["exceptionMessage"]
+    exception_type = response.failure.exceptionType
+    exception_message = response.failure.exceptionMessage
     if "SdkException" in exception_type:
         raise SdkException(exception_message)
     if "MissingContextFieldException" in exception_type:
@@ -223,18 +221,20 @@ def handle_exception(response):
         raise GatewayTimeoutException(exception_message)
     raise SdkException("Unhandled exception type: " + exception_type)
 
+def object_hook(d):
+    return SimpleNamespace(**{k: (object_hook(v) if isinstance(v, dict) else v) for k, v in d.items()})
+
 py_callback_type = ctypes.CFUNCTYPE(None, ctypes.c_char_p)
 
-async def execute_async(sdk_func, args, response_handler = None):
+async def execute_async(sdk_func, args):
     loop = asyncio.get_running_loop()
     future = loop.create_future()
 
     def callback(result):
         try:
-            response = json.loads(result)
+            response = json.loads(result, object_hook=object_hook)
             handle_exception(response)
-            processed = response_handler(response) if response_handler else None
-            loop.call_soon_threadsafe(future.set_result, processed)
+            loop.call_soon_threadsafe(future.set_result, response.success.result)
         except Exception as e:
             loop.call_soon_threadsafe(future.set_exception, e)
 
@@ -245,208 +245,230 @@ async def execute_async(sdk_func, args, response_handler = None):
     return await future
 
 
-class ApiEnvironment(Enum):
-    DEV = "DEV"
-    STAGING = "STAGING"
-    PROD = "PROD"
-
-
-class TwoFactorMethod(Enum):
-    EMAIL = "EMAIL"
-    TELEPHONE = "TELEPHONE"
-    SMS = "SMS"
-
-
-class UserRole(Enum):
-    ADMIN = "ADMIN"
-    USER = "USER"
+@dataclass
+class LockController:
+    type: str = field(init=False)
 
+@dataclass
+class AlpetaController(LockController):
+    type: str = field(init=False)
+    username: str
+    password: str
+    doorId: int
+    baseUrl: str = None
 
-class CapabilityStatus(Enum):
-    SUPPORTED = "SUPPORTED"
-    UNSUPPORTED = "UNSUPPORTED"
+    def __post_init__(self):
+        self.type = "alpeta"
 
-class CapabilityType(Enum):
-    CONFIGURABLE_UNLOCK_DURATION = "CONFIGURABLE_UNLOCK_DURATION"
-    OPEN_HOURS = "OPEN_HOURS"
-    BATCH_SHARING_25 = "BATCH_SHARING_25"
+@dataclass
+class AmagController(LockController):
+    type: str = field(init=False)
+    username: str
+    password: str
+    doorId: int
+    baseUrl: str = None
 
+    def __post_init__(self):
+        self.type = "amag"
 
-class AuditEvent(Enum):
-    DOOR_OPEN = "DOOR_OPEN"
-    DOOR_CLOSE = "DOOR_CLOSE"
-    DOOR_UNLOCK = "DOOR_UNLOCK"
-    DOOR_LOCK = "DOOR_LOCK"
-    OWNER_ASSIGNED = "OWNER_ASSIGNED"
-    DEVICE_CONNECTED = "DEVICE_CONNECTED"
-    DEVICE_DISCONNECTED = "DEVICE_DISCONNECTED"
-    LOCK_SHARED = "LOCK_SHARED"
-    LOCK_REVOKED = "LOCK_REVOKED"
-    USER_PROMOTED = "USER_PROMOTED"
-    USER_DEMOTED = "USER_DEMOTED"
-    SETTING_CHANGED = "SETTING_CHANGED"
-    TILE_ASSOCIATED = "TILE_ASSOCIATED"
-    TILE_DISASSOCIATED = "TILE_DISASSOCIATED"
-    DEVICE_DECOMMISSIONED = "DEVICE_DECOMMISSIONED"
+@dataclass
+class AssaAbloyController(LockController):
+    type: str = field(init=False)
+    baseUrl: str
+    doorId: str
 
+    def __post_init__(self):
+        self.type = "assa-abloy"
 
 @dataclass
-class EncodedKeyPair:
-    private: str
-    public: str
+class AvigilonController(LockController):
+    type: str = field(init=False)
+    baseUrl: str
+    username: str
+    password: str
+    doorId: str
 
+    def __post_init__(self):
+        self.type = "avigilon"
 
 @dataclass
-class RefreshTokenData:
-    refreshToken: str
+class AxisController(LockController):
+    type: str = field(init=False)
+    baseUrl: str
+    doorIdentifier: str
 
-@dataclass
-class RegisterEphemeralKeyData:
-    publicKey: str
+    def __post_init__(self):
+        self.type = "axis"
 
 @dataclass
-class RegisterEphemeralKeyWithSecondaryAuthenticationData:
-    publicKey: str
-    method: typing.Optional[TwoFactorMethod] = None
+class CCureController(LockController):
+    type: str = field(init=False)
+    baseUrl: str
+    username: str
+    password: str
+    doorType: str
+    doorId: int
 
-@dataclass
-class VerifyEphemeralKeyRegistrationData:
-    code: str
-    privateKey: typing.Optional[str] = None
+    def __post_init__(self):
+        self.type = "ccure"
 
 @dataclass
-class ChangePasswordData:
-    oldPassword: str
-    newPassword: str
+class DemoController(LockController):
+    type: str = field(init=False)
+    port: int = 8080
+
+    def __post_init__(self):
+        self.type = "demo"
 
 @dataclass
-class UpdateUserDetailsData:
-    displayName: str
+class GallagherController(LockController):
+    type: str = field(init=False)
+    apiKey: str
+    doorId: str
+    baseUrl: Optional[str] = None
 
+    def __post_init__(self):
+        self.type = "gallagher"
 
 @dataclass
-class LoginData:
-    email: str
+class GenetecController(LockController):
+    type: str = field(init=False)
+    baseUrl: str
+    username: str
     password: str
+    doorId: str
+
+    def __post_init__(self):
+        self.type = "genetec"
 
 @dataclass
-class RegistrationData:
-    email: str
+class LenelController(LockController):
+    type: str = field(init=False)
+    baseUrl: str
+    username: str
     password: str
-    force: bool
-    publicKey: str
-    displayName: typing.Optional[str] = None
+    directoryId: str
+    panelId: str
+    readerId: str
 
-@dataclass
-class VerifyEmailData:
-    code: str
+    def __post_init__(self):
+        self.type = "lenel"
 
 @dataclass
-class PasswordResetData:
-    email: str
+class MitrefinchController(LockController):
+    type: str = field(init=False)
+    host: str
+    output: int
+
+    def __post_init__(self):
+        self.type = "mitrefinch"
 
 @dataclass
-class PasswordResetVerifyData:
-    userId: str
-    token: str
+class PaxtonNet2Controller(LockController):
+    type: str = field(init=False)
+    host: str
+    username: str
     password: str
+    address: str
+    output: int
 
+    def __post_init__(self):
+        self.type = "net2"
 
 @dataclass
-class OperationContextData:
-    userId: str
-    userCertificateChain: str
-    userPublicKey: str
-    userPrivateKey: str
-
+class Paxton10Controller(LockController):
+    type: str = field(init=False)
+    baseUrl: str
+    username: str
+    password: str
+    applianceId: int
 
-@dataclass
-class UploadPlatformLogoData:
-    applicationId: str
-    contentType: str
-    image: str
+    def __post_init__(self):
+        self.type = "paxton10"
 
 @dataclass
-class AssistedLoginData:
-    email: str
+class IntegraV1Controller(LockController):
+    type: str = field(init=False)
+    username: str
     password: str
+    controllerId: int
 
-@dataclass
-class AssistedRegisterEphemeralKeyData:
-    publicKey: str
+    def __post_init__(self):
+        self.type = "integra"
 
 @dataclass
-class AssistedRegisterData:
-    email: str
-    password: str
-    displayName: typing.Optional[str] = None
-    force: bool = False
+class IntegraV2Controller(LockController):
+    type: str = field(init=False)
+    baseUrl: str
+    sessionId: str
+    controllerId: int
+    cardholderId: int
+    pinCode: Optional[int] = None
 
+    def __post_init__(self):
+        self.type = "integra-v2"
 
 @dataclass
-class LockIdData:
-    lockId: str
+class DataSource:
+    driverClass: str
+    url: str
+    user: str
+    password: str
 
 @dataclass
-class GetLockAuditTrailData:
-    lockId: str
-    start: int
-    end: int
+class PacController(LockController):
+    type: str = field(init=False)
+    dataSource: DataSource
+    outputChannel: int
+    controllerSerial: int
 
-@dataclass
-class GetAuditForUserData:
-    userId: str
-    start: int
-    end: int
+    def __post_init__(self):
+        self.type = "pac512"
 
 @dataclass
-class GetLocksForUserData:
-    userId: str
+class TdsiExgardeController(LockController):
+    type: str = field(init=False)
+    username: str
+    password: str
+    doorId: int
+    dbUrl: Optional[str] = None
 
-@dataclass
-class UpdateLockNameData:
-    lockId: str
-    name: typing.Optional[str] = None
+    def __post_init__(self):
+        self.type = "tdsi-exgarde"
 
 @dataclass
-class UpdateLockFavouriteData:
-    lockId: str
-    favourite: typing.Optional[bool] = None
+class TdsiGardisController(LockController):
+    type: str = field(init=False)
+    host: str
+    username: str
+    password: str
+    doorId: int
 
-@dataclass
-class UpdateLockColourData:
-    lockId: str
-    colour: typing.Optional[str] = None
+    def __post_init__(self):
+        self.type = "tdsi-gardis"
 
 @dataclass
-class UpdateLockSettingDefaultNameData:
-    lockId: str
-    name: typing.Optional[str] = None
+class ZktecoController(LockController):
+    type: str = field(init=False)
+    clientSecret: str
+    doorId: str
+    entityType: typing.Literal["DOOR", "FLOOR"]
+    baseUrl: str = None
+
+    def __post_init__(self):
+        self.type = "zkteco-zkbio-cvsecurity"
 
-@dataclass
-class SetLockSettingPermittedAddressesData:
-    lockId: str
-    permittedAddresses: typing.List[str]
 
-@dataclass
-class UpdateLockSettingHiddenData:
-    lockId: str
-    hidden: bool
 
 @dataclass
-class TimeRequirementData:
+class TimeRequirement:
     start: str
     end: str
     timezone: str
     days: typing.List[str]
 
 @dataclass
-class SetLockSettingTimeRestrictionsData:
-    lockId: str
-    times: typing.List[TimeRequirementData]
-
-@dataclass
-class LocationRequirementData:
+class LocationRequirement:
     latitude: float
     longitude: float
     enabled: typing.Optional[bool] = None
@@ -454,61 +476,15 @@ class LocationRequirementData:
     accuracy: typing.Optional[int] = None
 
 @dataclass
-class UpdateLockSettingLocationRestrictionsData:
-    lockId: str
-    location: typing.Optional[LocationRequirementData] = None
-
-@dataclass
-class GetUserPublicKeyData:
-    userEmail: str
-    visitor: bool = False
-
-@dataclass
-class GetUserPublicKeyByEmailData:
-    email: str
-
-@dataclass
-class GetUserPublicKeyByTelephoneData:
-    telephone: str
-
-@dataclass
-class GetUserPublicKeyByLocalKeyData:
-    localKey: str
-
-@dataclass
-class GetUserPublicKeyByForeignKeyData:
-    foreignKey: str
-
-@dataclass
-class GetUserPublicKeyByIdentityData:
-    identity: str
-
-@dataclass
-class GetUserPublicKeyByEmailsData:
-    emails: typing.List[str]
-
-@dataclass
-class GetUserPublicKeyByTelephonesData:
-    telephones: typing.List[str]
-
-@dataclass
-class GetUserPublicKeyByLocalKeysData:
-    localKeys: typing.List[str]
-
-@dataclass
-class GetUserPublicKeyByForeignKeysData:
-    foreignKeys: typing.List[str]
-
-@dataclass
-class ShareLockData:
+class ShareLock:
     targetUserId: str
-    targetUserRole: UserRole
+    targetUserRole: typing.Literal["ADMIN", "USER"]
     targetUserPublicKey: str
     start: typing.Optional[int] = None
     end: typing.Optional[int] = None
 
 @dataclass
-class BaseOperationData:
+class BaseOperation:
     lockId: str
     userId: typing.Optional[str] = None
     userCertificateChain: typing.Optional[typing.List[str]] = None
@@ -519,27 +495,27 @@ class BaseOperationData:
     jti: str = field(default_factory=lambda: str(uuid.uuid4()))
 
 @dataclass
-class ShareLockOperationData:
-    baseOperation: BaseOperationData
-    shareLock: ShareLockData
+class ShareLockOperation:
+    baseOperation: BaseOperation
+    shareLock: ShareLock
 
 @dataclass
-class BatchShareLockOperationData:
-    baseOperation: BaseOperationData
-    users: typing.List[ShareLockData]
+class BatchShareLockOperation:
+    baseOperation: BaseOperation
+    users: typing.List[ShareLock]
 
 @dataclass
-class RevokeAccessToLockOperationData:
-    baseOperation: BaseOperationData
+class RevokeAccessToLockOperation:
+    baseOperation: BaseOperation
     users: typing.List[str]
 
 @dataclass
-class UpdateSecureSettingUnlockDurationData:
-    baseOperation: BaseOperationData
+class UpdateSecureSettingUnlockDuration:
+    baseOperation: BaseOperation
     unlockDuration: int
 
 @dataclass
-class UnlockBetweenData:
+class UnlockBetween:
     start: str
     end: str
     timezone: str
@@ -547,100 +523,51 @@ class UnlockBetweenData:
     exceptions: typing.Optional[typing.List[str]] = None
 
 @dataclass
-class UnlockOperationData:
-    baseOperation: BaseOperationData
+class UnlockOperation:
+    baseOperation: BaseOperation
     directAccessEndpoints: typing.Optional[typing.List[str]] = None
 
 @dataclass
-class UpdateSecureSettingUnlockBetweenData:
-    baseOperation: BaseOperationData
-    unlockBetween: typing.Optional[UnlockBetweenData] = None
+class UpdateSecureSettingUnlockBetween:
+    baseOperation: BaseOperation
+    unlockBetween: typing.Optional[UnlockBetween] = None
 
 
 @dataclass
-class EmailCallToActionData:
+class EmailCallToAction:
     actionTarget: str
     headline: str
     actionText: str
 
 @dataclass
-class EmailPreferencesData:
+class EmailPreferences:
     senderEmail: typing.Optional[str] = None
     senderName: typing.Optional[str] = None
     primaryColour: typing.Optional[str] = None
     secondaryColour: typing.Optional[str] = None
     onlySendEssentialEmails: typing.Optional[bool] = None
-    callToAction: typing.Optional[EmailCallToActionData] = None
+    callToAction: typing.Optional[EmailCallToAction] = None
 
 @dataclass
-class CreateApplicationData:
+class CreateApplication:
     name: str
     companyName: str
     mailingAddress: str
     privacyPolicy: typing.Optional[str] = None
     supportContact: typing.Optional[str] = None
     appLink: typing.Optional[str] = None
-    emailPreferences: typing.Optional[EmailPreferencesData] = None
+    emailPreferences: typing.Optional[EmailPreferences] = None
     logoUrl: typing.Optional[str] = None
 
 @dataclass
-class ApplicationIdData:
-    applicationId: str
-
-@dataclass
-class UpdateApplicationNameData:
-    applicationId: str
-    name: str
-
-@dataclass
-class UpdateApplicationCompanyNameData:
-    applicationId: str
-    companyName: str
-
-@dataclass
-class UpdateApplicationMailingAddressData:
-    applicationId: str
-    mailingAddress: str
-
-@dataclass
-class UpdateApplicationPrivacyPolicyData:
-    applicationId: str
-    privacyPolicy: str
-
-@dataclass
-class UpdateApplicationSupportContactData:
-    applicationId: str
-    supportContact: str
-
-@dataclass
-class UpdateApplicationAppLinkData:
-    applicationId: str
-    appLink: str
-
-@dataclass
-class UpdateApplicationEmailPreferencesData:
-    applicationId: str
-    emailPreferences: EmailPreferencesData
-
-@dataclass
-class UpdateApplicationLogoUrlData:
-    applicationId: str
-    logoUrl: str
-
-@dataclass
-class GetLogoUploadUrlData:
-    applicationId: str
-    contentType: str
-
-@dataclass
-class AuthKeyData:
+class AuthKey:
     use: str
     kid: str
     alg: typing.Optional[str]
     kty: str = field(init=False)
 
 @dataclass
-class RsaKeyData(AuthKeyData):
+class RsaKey(AuthKey):
     kty: str
     p: str
     q: str
@@ -655,7 +582,7 @@ class RsaKeyData(AuthKeyData):
         self.kty = "RSA"
 
 @dataclass
-class EcKeyData(AuthKeyData):
+class EcKey(AuthKey):
     kty: str
     d: str
     crv: str
@@ -666,7 +593,7 @@ class EcKeyData(AuthKeyData):
         self.kty = "EC"
 
 @dataclass
-class Ed25519KeyData(AuthKeyData):
+class Ed25519Key(AuthKey):
     kty: str
     d: str
     crv: str
@@ -675,368 +602,17 @@ class Ed25519KeyData(AuthKeyData):
     def __post_init__(self):
         self.kty = "OKP"
 
-@dataclass
-class AddAuthKeyData:
-    applicationId: str
-    key: AuthKeyData
-
-@dataclass
-class AuthIssuerData:
-    applicationId: str
-    url: str
-
-@dataclass
-class CorsDomainData:
-    applicationId: str
-    url: str
-
-@dataclass
-class ApplicationOwnerData:
-    applicationId: str
-    userId: str
-
-
-@dataclass
-class SuccessResultData:
-    result: typing.Any
-
-@dataclass
-class FailedResultData:
-    exceptionType: str
-    exceptionMessage: str
-
-@dataclass
-class ResultData:
-    success: typing.Optional[SuccessResultData] = None
-    failure: typing.Optional[FailedResultData] = None
-
-
-@dataclass
-class SiteIdData:
-    siteId: str
-
-
-@dataclass
-class GetLocksBelongingToTileData:
-    tileId: str
-
-@dataclass
-class AssociateMultipleLocksData:
-    tileId: str
-    siteId: str
-    lockIds: typing.List[str]
-
-
-@dataclass
-class TokenResponse:
-    authToken: str
-    refreshToken: str
-
-@dataclass
-class UserDetailsResponse:
-    email: str
-    emailVerified: bool
-    publicKey: str
-    displayName: typing.Optional[str] = None
-
-@dataclass
-class RegisterEphemeralKeyResponse:
-    certificateChain: [typing.List[str]]
-    userId: str
-
-@dataclass
-class RegisterEphemeralKeyWithSecondaryAuthenticationResponse:
-    method: TwoFactorMethod
-
-
-@dataclass
-class AssistedLoginResponse:
-    requiresVerification: bool
-
-@dataclass
-class AssistedRegisterEphemeralKeyResponse:
-    requiresVerification: bool
-
-
-@dataclass
-class AuditSubjectResponse:
-    userId: str
-    email: str
-    displayName: typing.Optional[str] = None
-
-@dataclass
-class AuditIssuerResponse:
-    userId: str
-    email: typing.Optional[str] = None
-    ip: typing.Optional[str] = None
-
-@dataclass
-class AuditResponse:
-    deviceId: str
-    timestamp: float
-    type: AuditEvent
-    issuer: AuditIssuerResponse
-    rejected: bool
-    subject: typing.Optional[AuditSubjectResponse] = None
-    rejectionReason: typing.Optional[str] = None
-
-@dataclass
-class LockUserDetailsResponse:
-    deviceId: str
-    role: UserRole
-    start: typing.Optional[float] = None
-    end: typing.Optional[float] = None
-
-@dataclass
-class LockUserResponse:
-    userId: str
-    email: str
-    publicKey: str
-    orphan: bool
-    foreign: bool
-    devices: typing.List[LockUserDetailsResponse]
-    displayName: typing.Optional[str] = None
-    start: typing.Optional[float] = None
-    end: typing.Optional[float] = None
-
-@dataclass
-class UserLockResponse:
-    userId: str
-    email: str
-    publicKey: str
-    orphan: bool
-    foreign: bool
-    role: UserRole
-    displayName: typing.Optional[str] = None
-    start: typing.Optional[float] = None
-    end: typing.Optional[float] = None
-
-@dataclass
-class ShareableLockResponse:
-    id: str
-    name: str
-
-@dataclass
-class BatchUserPublicKeyResponse:
-    id: str
-    publicKey: str
-    email: typing.Optional[str] = None
-    foreignKey: typing.Optional[str] = None
-    phone: typing.Optional[str] = None
-
-@dataclass
-class UserPublicKeyResponse:
-    id: str
-    publicKey: str
-
-@dataclass
-class LockStateResponse:
-    locked: bool
-    connected: bool
-
-@dataclass
-class UnlockBetweenSettingResponse:
-    start: str
-    end: str
-    timezone: str
-    days: typing.List[str]
-    exceptions: typing.Optional[typing.List[str]] = None
-
-@dataclass
-class LocationRequirementResponse:
-    latitude: float
-    longitude: float
-    enabled: typing.Optional[bool] = None
-    radius: typing.Optional[int] = None
-    accuracy: typing.Optional[int] = None
-
-@dataclass
-class TimeRequirementResponse:
-    start: str
-    end: str
-    timezone: str
-    days: typing.List[str]
-
-@dataclass
-class UsageRequirementsResponse:
-    time: typing.Optional[typing.List[TimeRequirementResponse]] = None
-    location: typing.Optional[LocationRequirementResponse] = None
-
-@dataclass
-class LockSettingsResponse:
-    unlockTime: float
-    permittedAddresses: typing.List[str]
-    defaultName: str
-    tiles: typing.List[str]
-    hidden: bool
-    directAccessEndpoints: typing.List[str]
-    capabilities: typing.Dict[CapabilityType, CapabilityStatus]
-    usageRequirements: typing.Optional[UsageRequirementsResponse] = None
-    unlockBetweenWindow: typing.Optional[UnlockBetweenSettingResponse] = None
-
-@dataclass
-class LockResponse:
-    id: str
-    name: str
-    role: UserRole
-    settings: LockSettingsResponse
-    state: LockStateResponse
-    favourite: bool
-    colour: typing.Optional[str] = None
-    start: typing.Optional[str] = None
-    end: typing.Optional[str] = None
-    unlockTime: typing.Optional[float] = None
-
-
-@dataclass
-class EmailCallToActionResponse:
-    actionTarget: str
-    headline: str
-    actionText: str
-
-@dataclass
-class EmailPreferencesResponse:
-    primaryColour: str
-    secondaryColour: str
-    senderEmail: typing.Optional[str] = None
-    senderName: typing.Optional[str] = None
-    onlySendEssentialEmails: typing.Optional[bool] = None
-    callToAction: typing.Optional[EmailCallToActionResponse] = None
-
-@dataclass
-class OauthResponse:
-    authorizationEndpoint: str
-    clientId: str
-    grantType: str
-
-@dataclass
-class AuthKeyResponse:
-    kid: str
-    use: str
-    alg: Optional[str]
-    ops: Optional[List[str]]
-    x5u: Optional[str]
-    x5t: Optional[str]
-    x5t256: Optional[str]
-    x5c: Optional[List[str]]
-    exp: Optional[int]
-    nbf: Optional[int]
-    iat: Optional[int]
-
-@dataclass
-class RsaKeyResponse(AuthKeyResponse):
-    e: str
-    n: str
-
-@dataclass
-class EcKeyResponse(AuthKeyResponse):
-    crv: str
-    x: str
-    y: str
-
-@dataclass
-class Ed25519KeyResponse(AuthKeyResponse):
-    crv: str
-    x: str
-    d: Optional[str] = None
-
-@dataclass
-class ApplicationResponse:
-   applicationId: str
-   name: str
-   emailPreferences: EmailPreferencesResponse
-   oauth: typing.Optional[OauthResponse]
-   lastUpdated: typing.Optional[float] = None
-   owners: typing.Optional[typing.List[str]] = None
-   corsDomains: typing.Optional[typing.List[str]] = None
-   authDomains: typing.Optional[typing.List[str]] = None
-   logoUrl: typing.Optional[str] = None
-   privacyPolicy: typing.Optional[str] = None
-   mailingAddress: typing.Optional[str] = None
-   companyName: typing.Optional[str] = None
-   supportContact: typing.Optional[str] = None
-   appLink: typing.Optional[str] = None
-   slug: typing.Optional[str] = None
-   authKeys: typing.Dict[str, AuthKeyResponse] = field(default_factory=dict)
-   isDoordeckApplication: typing.Optional[bool] = None
-
-@dataclass
-class ApplicationOwnerDetailsResponse:
-    userId: str
-    email: str
-    orphan: bool
-    foreign: bool
-    displayName: typing.Optional[str] = None
-
-@dataclass
-class GetLogoUploadUrlResponse:
-    uploadUrl: str
-
-
-@dataclass
-class SiteResponse:
-    id: str
-    name: str
-    colour: str
-    longitude: float
-    latitude: float
-    radius: int
-    passBackground: str
-    created: str
-    updated: str
-
-@dataclass
-class SiteStateResponse:
-    connected: bool
-
-@dataclass
-class UserForSiteResponse:
-    userId: str
-    email: str
-    orphan: bool
-    displayName: typing.Optional[str] = None
-
-@dataclass
-class SiteLockSettingsResponse:
-    unlockTime: float
-    permittedAddresses: typing.List[str]
-    defaultName: str
-    tiles: typing.List[str]
-    state: typing.Optional[SiteStateResponse] = None
-    favourite: typing.Optional[bool] = None
-
-@dataclass
-class SiteLocksResponse:
-    id: str
-    name: str
-    role: UserRole
-    settings: SiteLockSettingsResponse
-    colour: typing.Optional[str] = None
-
-@dataclass
-class TileLocksResponse:
-    siteId: str
-    tileId: str
-    deviceIds: typing.List[str]
-
-
-@dataclass
-class TileLocksResponse:
-    siteId: str
-    tileId: str
-    deviceIds: typing.List[str]
-
 
 class Account(object):
 
     def __init__(self, resource):
         self.resource = resource
 
-    async def refresh_token(self, data):
+    async def refresh_token(self, refreshToken: str):
+        data = { "refreshToken": refreshToken }
         return await execute_async(
             _doordeck_headless_sdk.refreshToken,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: TokenResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
     async def logout(self):
@@ -1045,25 +621,31 @@ class Account(object):
             [self.resource]
         )
 
-    async def register_ephemeral_key(self, data):
+    async def register_ephemeral_key(self, publicKey: str):
+        data = { "publicKey": publicKey }
         return await execute_async(
             _doordeck_headless_sdk.registerEphemeralKey,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: RegisterEphemeralKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def register_ephemeral_key_with_secondary_authentication(self, data):
+    async def register_ephemeral_key_with_secondary_authentication(self, publicKey: str, method: Optional[typing.Literal["EMAIL", "TELEPHONE", "SMS"]] = None):
+        data = {
+            "publicKey": publicKey,
+            "method": method
+        }
         return await execute_async(
             _doordeck_headless_sdk.registerEphemeralKeyWithSecondaryAuthentication,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: RegisterEphemeralKeyWithSecondaryAuthenticationResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def verify_ephemeral_key_registration(self, data):
+    async def verify_ephemeral_key_registration(self, code: str, privateKey: str = None):
+        data = {
+            "code": code,
+            "privateKey": privateKey
+        }
         return await execute_async(
             _doordeck_headless_sdk.verifyEphemeralKeyRegistration,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: RegisterEphemeralKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
     async def reverify_email(self):
@@ -1072,23 +654,27 @@ class Account(object):
             [self.resource]
         )
 
-    async def change_password(self, data):
+    async def change_password(self, oldPassword: str, newPassword: str):
+        data = {
+           "oldPassword": oldPassword,
+            "oldPassword": oldPassword
+        }
         return await execute_async(
             _doordeck_headless_sdk.changePassword,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
     async def get_user_details(self):
         return await execute_async(
             _doordeck_headless_sdk.getUserDetails,
-            [self.resource],
-            lambda r: UserDetailsResponse(**get_success_result(r))
+            [self.resource]
         )
 
-    async def update_user_details(self, data):
+    async def update_user_details(self, displayName: str):
+        data = { "displayName": displayName }
         return await execute_async(
             _doordeck_headless_sdk.updateUserDetails,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
     async def delete_account(self):
@@ -1103,36 +689,52 @@ class Accountless(object):
     def __init__(self, resource):
         self.resource = resource
 
-    async def login(self, data):
+    async def login(self, email: str, password: str):
+        data = {
+            "email": email,
+            "password": password
+        }
         return await execute_async(
             _doordeck_headless_sdk.login,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: TokenResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def registration(self, data):
+    async def registration(self, email: str, password: str, force: bool = False, displayName: str = None, publicKey: str = None):
+        data = {
+            "email": email,
+            "password": password,
+            "force": force,
+            "publicKey": publicKey,
+            "displayName": displayName
+        }
         return await execute_async(
             _doordeck_headless_sdk.registration,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: TokenResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def verify_email(self, data):
+    async def verify_email(self, code: str):
+        data = { "code": code }
         return await execute_async(
             _doordeck_headless_sdk.verifyEmail,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def password_reset(self, data):
+    async def password_reset(self, email: str):
+        data = { "email": email }
         return await execute_async(
             _doordeck_headless_sdk.passwordReset,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def password_reset_verify(self, data):
+    async def password_reset_verify(self, userId: str, token: str, password: str):
+        data = {
+            "userId": userId,
+            "token": token,
+            "password": password
+        }
         return await execute_async(
             _doordeck_headless_sdk.passwordResetVerify,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
 
@@ -1144,10 +746,10 @@ class ContextManager(object):
     def get_api_environment(self):
         env = _doordeck_headless_sdk.getApiEnvironment(self.resource)
         name = _doordeck_headless_sdk.getApiEnvironmentName(env)
-        return ApiEnvironment[name]
+        return name
 
-    def set_cloud_auth_token(self, data):
-        _doordeck_headless_sdk.setCloudAuthToken(self.resource, data)
+    def set_cloud_auth_token(self, token: str):
+        _doordeck_headless_sdk.setCloudAuthToken(self.resource, token)
 
     def get_cloud_auth_token(self):
         return _doordeck_headless_sdk.getCloudAuthToken(self.resource)
@@ -1155,32 +757,32 @@ class ContextManager(object):
     def is_cloud_auth_token_about_to_expire(self):
         return _doordeck_headless_sdk.isCloudAuthTokenAboutToExpire(self.resource)
 
-    def set_cloud_refresh_token(self, data):
-        _doordeck_headless_sdk.setCloudRefreshToken(self.resource, data)
+    def set_cloud_refresh_token(self, token: str):
+        _doordeck_headless_sdk.setCloudRefreshToken(self.resource, token)
 
     def get_cloud_refresh_token(self):
         return _doordeck_headless_sdk.getCloudRefreshToken(self.resource)
 
-    def set_fusion_host(self, data):
-        _doordeck_headless_sdk.setFusionHost(self.resource, data)
+    def set_fusion_host(self, host: str):
+        _doordeck_headless_sdk.setFusionHost(self.resource, host)
 
     def get_fusion_host(self):
         return _doordeck_headless_sdk.getFusionHost(self.resource)
 
-    def set_fusion_auth_token(self, data):
-        _doordeck_headless_sdk.setFusionAuthToken(self.resource, data)
+    def set_fusion_auth_token(self, token: str):
+        _doordeck_headless_sdk.setFusionAuthToken(self.resource, token)
 
     def get_fusion_auth_token(self):
         return _doordeck_headless_sdk.getFusionAuthToken(self.resource)
 
-    def set_user_id(self, data):
-        _doordeck_headless_sdk.setUserId(self.resource, data)
+    def set_user_id(self, userId: str):
+        _doordeck_headless_sdk.setUserId(self.resource, userId)
 
     def get_user_id(self):
         return _doordeck_headless_sdk.getUserId(self.resource)
 
-    def set_user_email(self, data):
-        _doordeck_headless_sdk.setUserEmail(self.resource, data)
+    def set_user_email(self, email: str):
+        _doordeck_headless_sdk.setUserEmail(self.resource, email)
 
     def get_user_email(self):
         return _doordeck_headless_sdk.getUserEmail(self.resource)
@@ -1191,8 +793,14 @@ class ContextManager(object):
     def is_key_pair_valid(self):
         return _doordeck_headless_sdk.isKeyPairValid(self.resource)
 
-    def set_operation_context(self, data):
-        _doordeck_headless_sdk.setOperationContextJson(self.resource, json.dumps(dataclasses.asdict(data)))
+    def set_operation_context(self, userId: str, userCertificateChain: str, userPublicKey: str, userPrivateKey: str):
+        data = {
+            "userId": userId,
+            "userCertificateChain": userCertificateChain,
+            "userPublicKey": userPublicKey,
+            "userPrivateKey": userPrivateKey
+        }
+        _doordeck_headless_sdk.setOperationContextJson(self.resource, json.dumps(data))
 
     def clear_context(self):
         _doordeck_headless_sdk.clearContext(self.resource)
@@ -1204,8 +812,75 @@ class CryptoManager(object):
         self.resource = resource
 
     def generate_key_pair(self):
-        response = json.loads(_doordeck_headless_sdk.generateEncodedKeyPair(self.resource))
-        return EncodedKeyPair(**response)
+        return json.loads(_doordeck_headless_sdk.generateEncodedKeyPair(self.resource), object_hook=object_hook)
+
+
+class Fusion(object):
+
+    def __init__(self, resource):
+        self.resource = resource
+
+    async def login(self, email: str, password: str):
+        data = {
+            "email": email,
+            "password": password
+        }
+        return await execute_async(
+            _doordeck_headless_sdk.loginFusion,
+            [self.resource, json.dumps(data)]
+        )
+
+    async def get_integration_type(self):
+        return await execute_async(
+            _doordeck_headless_sdk.getIntegrationType,
+            [self.resource]
+        )
+
+    async def get_integration_configuration(self, type: str):
+        data = { "type": type }
+        return await execute_async(
+            _doordeck_headless_sdk.getIntegrationConfiguration,
+            [self.resource, json.dumps(data)]
+        )
+
+    async def enable_door(self, name: str, siteId: str, controller: LockController):
+        data = {
+            "name": name,
+            "siteId": siteId,
+            "controller": dataclasses.asdict(controller)
+        }
+        return await execute_async(
+            _doordeck_headless_sdk.enableDoor,
+            [self.resource, json.dumps(data)]
+        )
+
+    async def delete_door(self, deviceId: str):
+        data = { "deviceId": deviceId }
+        return await execute_async(
+            _doordeck_headless_sdk.deleteDoor,
+            [self.resource, json.dumps(data)]
+        )
+
+    async def get_door_status(self, deviceId: str):
+        data = { "deviceId": deviceId }
+        return await execute_async(
+            _doordeck_headless_sdk.getDoorStatus,
+            [self.resource, json.dumps(data)]
+        )
+
+    async def start_door(self, deviceId: str):
+        data = { "deviceId": deviceId }
+        return await execute_async(
+            _doordeck_headless_sdk.startDoor,
+            [self.resource, json.dumps(data)]
+        )
+
+    async def stop_door(self, deviceId: str):
+        data = { "deviceId": deviceId }
+        return await execute_async(
+            _doordeck_headless_sdk.stopDoor,
+            [self.resource, json.dumps(data)]
+        )
 
 
 class Helper(object):
@@ -1213,30 +888,44 @@ class Helper(object):
     def __init__(self, resource):
         self.resource = resource
 
-    async def upload_platform_logo(self, data):
+    async def upload_platform_logo(self, applicationId: str, contentType: str, image: str):
+        data = {
+            "applicationId": applicationId,
+            "contentType": contentType,
+            "image": image
+        }
         return await execute_async(
             _doordeck_headless_sdk.uploadPlatformLogo,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def assisted_login(self, data):
+    async def assisted_login(self, email: str, password: str):
+        data = {
+            "email": email,
+            "password": password
+        }
         return await execute_async(
             _doordeck_headless_sdk.assistedLogin,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: AssistedLoginResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def assisted_register_ephemeral_key(self, data):
+    async def assisted_register_ephemeral_key(self, publicKey: str):
+        data = { "publicKey": publicKey }
         return await execute_async(
             _doordeck_headless_sdk.assistedRegisterEphemeralKey,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: AssistedRegisterEphemeralKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def assisted_register(self, data):
+    async def assisted_register(self, email: str, password: str, force: bool = False, displayName: str = None):
+        data = {
+            "email": email,
+            "password": password,
+            "displayName": displayName,
+            "force": force
+        }
         return await execute_async(
             _doordeck_headless_sdk.assistedRegister,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
 
@@ -1245,190 +934,233 @@ class LockOperations(object):
     def __init__(self, resource):
         self.resource = resource
 
-    async def get_single_lock(self, data):
+    async def get_single_lock(self, lockId: str):
+        data = { "lockId": lockId }
         return await execute_async(
             _doordeck_headless_sdk.getSingleLock,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: LockResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_lock_audit_trail(self, data):
+    async def get_lock_audit_trail(self, lockId: str, start: int, end: int):
+        data = {
+            "lockId": lockId,
+            "start": start,
+            "end": end
+        }
         return await execute_async(
             _doordeck_headless_sdk.getLockAuditTrail,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: [AuditResponse(**item) for item in get_success_result(r)]
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_audit_for_user(self, data):
+    async def get_audit_for_user(self, lockId: str, start: int, end: int):
+        data = {
+            "lockId": lockId,
+            "start": start,
+            "end": end
+        }
         return await execute_async(
             _doordeck_headless_sdk.getAuditForUser,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: [AuditResponse(**item) for item in get_success_result(r)]
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_users_for_lock(self, data):
+    async def get_users_for_lock(self, userId: str):
+        data = { "userId": userId }
         return await execute_async(
             _doordeck_headless_sdk.getUsersForLock,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: [UserLockResponse(**item) for item in get_success_result(r)]
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_locks_for_user(self, data):
+    async def get_locks_for_user(self, userId: str):
+        data = { "userId": userId }
         return await execute_async(
             _doordeck_headless_sdk.getLocksForUser,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: UserLockResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_name(self, data):
+    async def update_lock_name(self, lockId: str, name: str = None):
+        data = {
+            "lockId": lockId,
+            "name": name
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateLockName,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_favourite(self, data):
+    async def update_lock_favourite(self, lockId: str, favourite: bool = None):
+        data = {
+            "lockId": lockId,
+            "favourite": favourite
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateLockFavourite,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_colour(self, data):
+    async def update_lock_colour(self, lockId: str, colour: str = None):
+        data = {
+            "lockId": lockId,
+            "colour": colour
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateLockColour,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_setting_default_name(self, data):
+    async def update_lock_setting_default_name(self, lockId: str, name: str = None):
+        data = {
+            "lockId": lockId,
+            "name": name
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateLockSettingDefaultName,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def set_lock_setting_permitted_addresses(self, data):
+    async def set_lock_setting_permitted_addresses(self, lockId: str, permittedAddresses: List[str]):
+        data = {
+            "lockId": lockId,
+            "permittedAddresses": permittedAddresses
+        }
         return await execute_async(
             _doordeck_headless_sdk.setLockSettingPermittedAddresses,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_setting_hidden(self, data):
+    async def update_lock_setting_hidden(self, lockId: str, hidden: bool):
+        data = {
+            "lockId": lockId,
+            "hidden": hidden
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateLockSettingHidden,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def set_lock_setting_time_restrictions(self, data):
+    async def set_lock_setting_time_restrictions(self, lockId: str, times: List[TimeRequirement]):
+        data = {
+            "lockId": lockId,
+            "times": dataclasses.asdict(times)
+        }
         return await execute_async(
             _doordeck_headless_sdk.setLockSettingTimeRestrictions,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_setting_location_restrictions(self, data):
+    async def update_lock_setting_location_restrictions(self, lockId: str, location: LocationRequirement = None):
+        data = {
+            "lockId": lockId,
+            "location": dataclasses.asdict(location)
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateLockSettingLocationRestrictions,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_user_public_key(self, data):
+    async def get_user_public_key(self, userEmail: str, visitor: bool = False):
+        data = {
+            "userEmail": userEmail,
+            "visitor": visitor
+        }
         return await execute_async(
             _doordeck_headless_sdk.getUserPublicKey,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: UserPublicKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_user_public_key_by_email(self, data):
+    async def get_user_public_key_by_email(self, email: str):
+        data = { "email": email }
         return await execute_async(
             _doordeck_headless_sdk.getUserPublicKeyByEmail,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: UserPublicKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_user_public_key_by_telephone(self, data):
+    async def get_user_public_key_by_telephone(self, telephone: str):
+        data = { "telephone": telephone }
         return await execute_async(
             _doordeck_headless_sdk.getUserPublicKeyByTelephone,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: UserPublicKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_user_public_key_by_local_key(self, data):
+    async def get_user_public_key_by_local_key(self, localKey: str):
+        data = { "localKey": localKey }
         return await execute_async(
             _doordeck_headless_sdk.getUserPublicKeyByLocalKey,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: UserPublicKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_user_public_key_by_foreign_key(self, data):
+    async def get_user_public_key_by_foreign_key(self, foreignKey: str):
+        data = { "foreignKey": foreignKey }
         return await execute_async(
             _doordeck_headless_sdk.getUserPublicKeyByForeignKey,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: UserPublicKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_user_public_key_by_identity(self, data):
+    async def get_user_public_key_by_identity(self, identity: str):
+        data = { "identity": identity }
         return await execute_async(
             _doordeck_headless_sdk.getUserPublicKeyByIdentity,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: UserPublicKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_user_public_key_by_emails(self, data):
+    async def get_user_public_key_by_emails(self, emails: List[str]):
+        data = { "emails": emails }
         return await execute_async(
             _doordeck_headless_sdk.getUserPublicKeyByEmails,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: UserPublicKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_user_public_key_by_telephones(self, data):
+    async def get_user_public_key_by_telephones(self, telephones: List[str]):
+        data = { "telephones": telephones }
         return await execute_async(
             _doordeck_headless_sdk.getUserPublicKeyByTelephones,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: BatchUserPublicKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_user_public_key_by_local_keys(self, data):
+    async def get_user_public_key_by_local_keys(self, localKeys: List[str]):
+        data = { "localKeys": localKeys }
         return await execute_async(
             _doordeck_headless_sdk.getUserPublicKeyByLocalKeys,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: BatchUserPublicKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_user_public_key_by_foreign_keys(self, data):
+    async def get_user_public_key_by_foreign_keys(self, foreignKeys: List[str]):
+        data = { "foreignKeys": foreignKeys }
         return await execute_async(
             _doordeck_headless_sdk.getUserPublicKeyByForeignKeys,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: BatchUserPublicKeyResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def unlock(self, data):
+    async def unlock(self, data: UnlockOperation):
         return await execute_async(
             _doordeck_headless_sdk.unlock,
             [self.resource, json.dumps(dataclasses.asdict(data))]
         )
 
-    async def share_lock(self, data):
+    async def share_lock(self, data: ShareLockOperation):
         return await execute_async(
             _doordeck_headless_sdk.shareLock,
             [self.resource, json.dumps(dataclasses.asdict(data))]
         )
 
-    async def batch_share_lock(self, data):
+    async def batch_share_lock(self, data: BatchShareLockOperation):
         return await execute_async(
             _doordeck_headless_sdk.batchShareLock,
             [self.resource, json.dumps(dataclasses.asdict(data))]
         )
 
-    async def revoke_access_to_lock(self, data):
+    async def revoke_access_to_lock(self, data: RevokeAccessToLockOperation):
         return await execute_async(
             _doordeck_headless_sdk.revokeAccessToLock,
             [self.resource, json.dumps(dataclasses.asdict(data))]
         )
 
-    async def update_secure_setting_unlock_duration(self, data):
+    async def update_secure_setting_unlock_duration(self, data: UpdateSecureSettingUnlockDuration):
         return await execute_async(
             _doordeck_headless_sdk.updateSecureSettingUnlockDuration,
             [self.resource, json.dumps(dataclasses.asdict(data))]
         )
 
-    async def update_secure_setting_unlock_between(self, data):
+    async def update_secure_setting_unlock_between(self, data: UpdateSecureSettingUnlockBetween):
         return await execute_async(
             _doordeck_headless_sdk.updateSecureSettingUnlockBetween,
             [self.resource, json.dumps(dataclasses.asdict(data))]
@@ -1437,15 +1169,13 @@ class LockOperations(object):
     async def get_pinned_locks(self):
         return await execute_async(
             _doordeck_headless_sdk.getPinnedLocks,
-            [self.resource],
-            lambda r: [LockResponse(**item) for item in get_success_result(r)]
+            [self.resource]
         )
 
     async def get_shareable_locks(self):
         return await execute_async(
             _doordeck_headless_sdk.getShareableLocks,
-            [self.resource],
-            lambda r: [ShareableLockResponse(**item) for item in get_success_result(r)]
+            [self.resource]
         )
 
 
@@ -1454,7 +1184,7 @@ class Platform(object):
     def __init__(self, resource):
         self.resource = resource
 
-    async def create_application(self, data):
+    async def create_application(self, data: CreateApplication):
         return await execute_async(
             _doordeck_headless_sdk.createApplication,
             [self.resource, json.dumps(dataclasses.asdict(data))]
@@ -1463,125 +1193,188 @@ class Platform(object):
     async def list_applications(self):
         return await execute_async(
             _doordeck_headless_sdk.listApplications,
-            [self.resource],
-            lambda r: [ApplicationResponse(**item) for item in get_success_result(r)]
+            [self.resource]
         )
 
-    async def get_application(self, data):
+    async def get_application(self, applicationId: str):
+        data = { "applicationId": applicationId }
         return await execute_async(
             _doordeck_headless_sdk.getApplication,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: ApplicationResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_application_name(self, data):
+    async def update_application_name(self, applicationId: str, name: str):
+        data = {
+            "applicationId": applicationId,
+            "name": name
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateApplicationName,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_application_company_name(self, data):
+    async def update_application_company_name(self, applicationId: str, companyName: str):
+        data = {
+            "applicationId": applicationId,
+            "companyName": companyName
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateApplicationCompanyName,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_application_mailing_address(self, data):
+    async def update_application_mailing_address(self, applicationId: str, mailingAddress: str):
+        data = {
+            "applicationId": applicationId,
+            "mailingAddress": mailingAddress
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateApplicationMailingAddress,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_application_privacy_policy(self, data):
+    async def update_application_privacy_policy(self, applicationId: str, privacyPolicy: str):
+        data = {
+            "applicationId": applicationId,
+            "privacyPolicy": privacyPolicy
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateApplicationPrivacyPolicy,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_application_support_contact(self, data):
+    async def update_application_support_contact(self, applicationId: str, supportContact: str):
+        data = {
+            "applicationId": applicationId,
+            "supportContact": supportContact
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateApplicationSupportContact,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_application_app_link(self, data):
+    async def update_application_app_link(self, applicationId: str, appLink: str):
+        data = {
+            "applicationId": applicationId,
+            "appLink": appLink
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateApplicationAppLink,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_application_email_preferences(self, data):
+    async def update_application_email_preferences(self, applicationId: str, emailPreferences: EmailPreferences):
+        data = {
+            "applicationId": applicationId,
+            "emailPreferences": dataclasses.asdict(emailPreferences)
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateApplicationEmailPreferences,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def update_application_logo_url(self, data):
+    async def update_application_logo_url(self, applicationId: str, logoUrl: str):
+        data = {
+            "applicationId": applicationId,
+            "logoUrl": logoUrl
+        }
         return await execute_async(
             _doordeck_headless_sdk.updateApplicationLogoUrl,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def delete_application(self, data):
+    async def delete_application(self, applicationId: str):
+        data = { "applicationId": applicationId }
         return await execute_async(
             _doordeck_headless_sdk.deleteApplication,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_logo_upload_url(self, data):
+    async def get_logo_upload_url(self, applicationId: str, contentType: str):
+        data = {
+            "applicationId": applicationId,
+            "contentType": contentType
+        }
         return await execute_async(
             _doordeck_headless_sdk.getLogoUploadUrl,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: GetLogoUploadUrlResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def add_auth_key(self, data):
+    async def add_auth_key(self, applicationId: str, key: AuthKey):
+        data = {
+            "applicationId": applicationId,
+            "key": dataclasses.asdict(key)
+        }
         return await execute_async(
             _doordeck_headless_sdk.addAuthKey,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def add_auth_issuer(self, data):
+    async def add_auth_issuer(self, applicationId: str, url: str):
+        data = {
+            "applicationId": applicationId,
+            "url": url
+        }
         return await execute_async(
             _doordeck_headless_sdk.addAuthIssuer,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def delete_auth_issuer(self, data):
+    async def delete_auth_issuer(self, applicationId: str, url: str):
+        data = {
+            "applicationId": applicationId,
+            "url": url
+        }
         return await execute_async(
             _doordeck_headless_sdk.deleteAuthIssuer,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def add_cors_domain(self, data):
+    async def add_cors_domain(self, applicationId: str, url: str):
+        data = {
+            "applicationId": applicationId,
+            "url": url
+        }
         return await execute_async(
             _doordeck_headless_sdk.addCorsDomain,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def remove_cors_domain(self, data):
+    async def remove_cors_domain(self, applicationId: str, url: str):
+        data = {
+            "applicationId": applicationId,
+            "url": url
+        }
         return await execute_async(
             _doordeck_headless_sdk.removeCorsDomain,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def add_application_owner(self, data):
+    async def add_application_owner(self, applicationId: str, userId: str):
+        data = {
+            "applicationId": applicationId,
+            "userId": userId
+        }
         return await execute_async(
             _doordeck_headless_sdk.addApplicationOwner,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def remove_application_owner(self, data):
+    async def remove_application_owner(self, applicationId: str, userId: str):
+        data = {
+            "applicationId": applicationId,
+            "userId": userId
+        }
         return await execute_async(
             _doordeck_headless_sdk.removeApplicationOwner,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_application_owners_details(self, data):
+    async def get_application_owners_details(self, applicationId: str):
+        data = { "applicationId": applicationId }
         return await execute_async(
             _doordeck_headless_sdk.getApplicationOwnersDetails,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: [ApplicationOwnerDetailsResponse(**item) for item in get_success_result(r)]
+            [self.resource, json.dumps(data)]
         )
 
 
@@ -1593,22 +1386,21 @@ class Sites(object):
     async def list_sites(self):
         return await execute_async(
             _doordeck_headless_sdk.listSites,
-            [self.resource],
-            lambda r: [SiteResponse(**item) for item in get_success_result(r)]
+            [self.resource]
         )
 
-    async def get_locks_for_site(self, data):
+    async def get_locks_for_site(self, siteId: str):
+        data = { "siteId": siteId }
         return await execute_async(
             _doordeck_headless_sdk.getLocksForSite,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: [SiteLocksResponse(**item) for item in get_success_result(r)]
+            [self.resource, json.dumps(data)]
         )
 
-    async def get_users_for_site(self, data):
+    async def get_users_for_site(self, siteId: str):
+        data = { "siteId": siteId }
         return await execute_async(
             _doordeck_headless_sdk.getUsersForSite,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: [UserForSiteResponse(**item) for item in get_success_result(r)]
+            [self.resource, json.dumps(data)]
         )
 
 
@@ -1617,28 +1409,34 @@ class Tiles(object):
     def __init__(self, resource):
         self.resource = resource
 
-    async def get_locks_belonging_to_tile(self, data):
+    async def get_locks_belonging_to_tile(self, tileId: str):
+        data = { "tileId": tileId }
         return await execute_async(
             _doordeck_headless_sdk.getLocksBelongingToTile,
-            [self.resource, json.dumps(dataclasses.asdict(data))],
-            lambda r: TileLocksResponse(**get_success_result(r))
+            [self.resource, json.dumps(data)]
         )
 
-    async def associate_multiple_locks(self, data):
+    async def associate_multiple_locks(self, tileId: str, siteId: str, lockIds: List[str]):
+        data = {
+            "tileId": tileId,
+            "siteId": siteId,
+            "lockIds": lockIds
+        }
         return await execute_async(
             _doordeck_headless_sdk.associateMultipleLocks,
-            [self.resource, json.dumps(dataclasses.asdict(data))]
+            [self.resource, json.dumps(data)]
         )
 
 
 class InitializeSdk(object):
 
-    def __init__(self, api_environment, cloud_auth_token = None, cloud_refresh_token = None, fusion_host = None):
-        self.sdkApiEnvironment = _doordeck_headless_sdk.getApiEnvironmentByName(Doordeck_Headless_Sdk_kref_com_doordeck_multiplatform_sdk_model_data_ApiEnvironment(), api_environment.name)
+    def __init__(self, api_environment: typing.Literal["DEV", "STAGING", "PROD"] = "PROD", cloud_auth_token: str = None, cloud_refresh_token: str = None, fusion_host: str = None):
+        self.sdkApiEnvironment = _doordeck_headless_sdk.getApiEnvironmentByName(Doordeck_Headless_Sdk_kref_com_doordeck_multiplatform_sdk_model_data_ApiEnvironment(), api_environment)
         self.sdkConfig = _doordeck_headless_sdk.buildSdkConfig(self.sdkApiEnvironment, cloud_auth_token, cloud_refresh_token, fusion_host)
         self.sdk = initialize(Doordeck_Headless_Sdk_kref_com_doordeck_multiplatform_sdk_KDoordeckFactory(), self.sdkConfig)
         self.accountless = Accountless(accountless(self.sdk))
         self.account = Account(account(self.sdk))
+        self.fusion = Fusion(fusion(self.sdk))
         self.helper = Helper(helper(self.sdk))
         self.lockOperations = LockOperations(lockOperations(self.sdk))
         self.platform = Platform(platform(self.sdk))