doordeck-headless-sdk 0.104.0__py3-none-any.whl → 0.105.0__py3-none-any.whl

doordeck_headless_sdk/doordeck_headless_sdk.py

@@ -73,7 +73,7 @@ from dataclasses import dataclass, field
 
 
 class SdkException(Exception):
-    def __init__(self, message: str, exception: Exception = None):
+    def __init__(self, message: str, exception: typing.Optional[Exception] = None):
         super().__init__(message)
         self.exception = exception
 
@@ -89,8 +89,8 @@ class MissingAndroidContextException(SdkException):
 
 
 class BatchShareFailedException(SdkException):
-    def __init__(self, message: str, user_ids: list):
-        super().__init__(message, user_ids)
+    def __init__(self, message: str, user_ids: typing.List[str]):
+        super().__init__(message)
         self.user_ids = user_ids
 
 
@@ -254,7 +254,7 @@ class AlpetaController(LockController):
     username: str
     password: str
     doorId: int
-    baseUrl: str = None
+    baseUrl: typing.Optional[str] = None
 
     def __post_init__(self):
         self.type = "alpeta"
@@ -265,7 +265,7 @@ class AmagController(LockController):
     username: str
     password: str
     doorId: int
-    baseUrl: str = None
+    baseUrl: typing.Optional[str] = None
 
     def __post_init__(self):
         self.type = "amag"
@@ -324,7 +324,7 @@ class GallagherController(LockController):
     type: str = field(init=False)
     apiKey: str
     doorId: str
-    baseUrl: Optional[str] = None
+    baseUrl: typing.Optional[str] = None
 
     def __post_init__(self):
         self.type = "gallagher"
@@ -366,10 +366,10 @@ class MitrefinchController(LockController):
 class PaxtonNet2Controller(LockController):
     type: str = field(init=False)
     host: str
-    username: Optional[str] = None
-    password: Optional[str] = None
     address: str
     output: int
+    username: typing.Optional[str] = None
+    password: typing.Optional[str] = None
 
     def __post_init__(self):
         self.type = "net2"
@@ -402,7 +402,7 @@ class IntegraV2Controller(LockController):
     sessionId: str
     controllerId: int
     cardholderId: int
-    pinCode: Optional[int] = None
+    pinCode: typing.Optional[int] = None
 
     def __post_init__(self):
         self.type = "integra-v2"
@@ -430,7 +430,7 @@ class TdsiExgardeController(LockController):
     username: str
     password: str
     doorId: int
-    dbUrl: Optional[str] = None
+    dbUrl: typing.Optional[str] = None
 
     def __post_init__(self):
         self.type = "tdsi-exgarde"
@@ -452,7 +452,7 @@ class ZktecoController(LockController):
     clientSecret: str
     doorId: str
     entityType: typing.Literal["DOOR", "FLOOR"]
-    baseUrl: str = None
+    baseUrl: typing.Optional[str] = None
 
     def __post_init__(self):
         self.type = "zkteco-zkbio-cvsecurity"
@@ -602,6 +602,222 @@ class Ed25519Key(AuthKey):
         self.kty = "OKP"
 
 
+class ISecureStorage:
+    def set_api_environment(self, api_environment: str) -> None:
+        raise NotImplementedError
+
+    def get_api_environment(self) -> str | None:
+        raise NotImplementedError
+
+    def add_cloud_auth_token(self, token: str) -> None:
+        raise NotImplementedError
+
+    def get_cloud_auth_token(self) -> str | None:
+        raise NotImplementedError
+
+    def add_cloud_refresh_auth_token(self, token: str) -> None:
+        raise NotImplementedError
+
+    def get_cloud_refresh_token(self) -> str | None:
+        raise NotImplementedError
+
+    def set_fusion_host(self, host: str) -> None:
+        raise NotImplementedError
+
+    def get_fusion_host(self) -> str | None:
+        raise NotImplementedError
+
+    def add_fusion_auth_token(self, token: str) -> None:
+        raise NotImplementedError
+
+    def get_fusion_auth_token(self) -> str | None:
+        raise NotImplementedError
+
+    def add_public_key(self, public_key: bytes) -> None:
+        raise NotImplementedError
+
+    def get_public_key(self) -> bytes | None:
+        raise NotImplementedError
+
+    def add_private_key(self, private_key: bytes) -> None:
+        raise NotImplementedError
+
+    def get_private_key(self) -> bytes | None:
+        raise NotImplementedError
+
+    def set_key_pair_verified(self, verified: bool) -> None:
+        raise NotImplementedError
+
+    def get_key_pair_verified(self) -> bool | None:
+        raise NotImplementedError
+
+    def add_user_id(self, user_id: str) -> None:
+        raise NotImplementedError
+
+    def get_user_id(self) -> str | None:
+        raise NotImplementedError
+
+    def set_user_email(self, user_email: str) -> None:
+        raise NotImplementedError
+
+    def get_user_email(self) -> str | None:
+        raise NotImplementedError
+
+    def add_certificate_chain(self, certificate_chain: typing.List[str]) -> None:
+        raise NotImplementedError
+
+    def get_certificate_chain(self) -> typing.List[str]:
+        raise NotImplementedError
+
+    def clear(self) -> None:
+        raise NotImplementedError
+
+class SecureStorage:
+    Implementation: ISecureStorage | None = None
+
+    static_buffer = ctypes.create_string_buffer(1024 * 10)
+
+    py_set_data_type = ctypes.CFUNCTYPE(None, ctypes.c_void_p)
+    py_get_data_type = ctypes.CFUNCTYPE(ctypes.c_char_p)
+
+    @staticmethod
+    def set_api_environment(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.set_api_environment(ctypes.string_at(result).decode())
+
+    @staticmethod
+    def get_api_environment() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_api_environment():
+            SecureStorage.static_buffer.value = r.encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def add_cloud_auth_token(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.add_cloud_auth_token(ctypes.string_at(result).decode())
+
+    @staticmethod
+    def get_cloud_auth_token() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_cloud_auth_token():
+            SecureStorage.static_buffer.value = r.encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def add_cloud_refresh_auth_token(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.add_cloud_refresh_auth_token(ctypes.string_at(result).decode())
+
+    @staticmethod
+    def get_cloud_refresh_token() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_cloud_refresh_token():
+            SecureStorage.static_buffer.value = r.encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def set_fusion_host(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.set_fusion_host(ctypes.string_at(result).decode())
+
+    @staticmethod
+    def get_fusion_host() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_fusion_host():
+            SecureStorage.static_buffer.value = r.encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def add_fusion_auth_token(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.add_fusion_auth_token(ctypes.string_at(result).decode())
+
+    @staticmethod
+    def get_fusion_auth_token() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_fusion_auth_token():
+            SecureStorage.static_buffer.value = r.encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def add_public_key(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.add_public_key(decode_base64_to_byte_array(ctypes.string_at(result).decode()))
+
+    @staticmethod
+    def get_public_key() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_public_key():
+            SecureStorage.static_buffer.value = encode_byte_array_to_base64(r).encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def add_private_key(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.add_private_key(decode_base64_to_byte_array(ctypes.string_at(result).decode()))
+
+    @staticmethod
+    def get_private_key() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_private_key():
+            SecureStorage.static_buffer.value = encode_byte_array_to_base64(r).encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def set_key_pair_verified(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.set_key_pair_verified(bool(ctypes.string_at(result).decode()))
+
+    @staticmethod
+    def get_key_pair_verified() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_key_pair_verified():
+            SecureStorage.static_buffer.value = str(r).encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def add_user_id(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.add_user_id(ctypes.string_at(result).decode())
+
+    @staticmethod
+    def get_user_id() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_user_id():
+            SecureStorage.static_buffer.value = r.encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def set_user_email(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.set_user_email(ctypes.string_at(result).decode())
+
+    @staticmethod
+    def get_user_email() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_user_email():
+            SecureStorage.static_buffer.value = r.encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def add_certificate_chain(result) -> None:
+        if SecureStorage.Implementation is not None and result is not None:
+            SecureStorage.Implementation.add_certificate_chain(string_to_certificate_chain(ctypes.string_at(result).decode()))
+
+    @staticmethod
+    def get_certificate_chain() -> int | None:
+        if r := SecureStorage.Implementation and SecureStorage.Implementation.get_certificate_chain():
+            SecureStorage.static_buffer.value = certificate_chain_to_string(r).encode()
+            return ctypes.addressof(SecureStorage.static_buffer)
+        return None
+
+    @staticmethod
+    def clear() -> None:
+        if SecureStorage.Implementation is not None:
+            SecureStorage.Implementation.clear()
+
+
 class Account(object):
 
     def __init__(self, resource):
@@ -627,7 +843,7 @@ class Account(object):
             [self.resource, json.dumps(data)]
         )
 
-    async def register_ephemeral_key_with_secondary_authentication(self, publicKey: str, method: Optional[typing.Literal["EMAIL", "TELEPHONE", "SMS"]] = None):
+    async def register_ephemeral_key_with_secondary_authentication(self, publicKey: str, method: typing.Optional[typing.Literal["EMAIL", "TELEPHONE", "SMS"]] = None):
         data = {
             "publicKey": publicKey,
             "method": method
@@ -637,7 +853,7 @@ class Account(object):
             [self.resource, json.dumps(data)]
         )
 
-    async def verify_ephemeral_key_registration(self, code: str, privateKey: str = None):
+    async def verify_ephemeral_key_registration(self, code: str, privateKey: typing.Optional[str] = None):
         data = {
             "code": code,
             "privateKey": privateKey
@@ -698,7 +914,7 @@ class Accountless(object):
             [self.resource, json.dumps(data)]
         )
 
-    async def registration(self, email: str, password: str, force: bool = False, displayName: str = None, publicKey: str = None):
+    async def registration(self, email: str, password: str, force: bool = False, displayName: typing.Optional[str] = None, publicKey: typing.Optional[str] = None):
         data = {
             "email": email,
             "password": password,
@@ -915,7 +1131,7 @@ class Helper(object):
             [self.resource, json.dumps(data)]
         )
 
-    async def assisted_register(self, email: str, password: str, force: bool = False, displayName: str = None):
+    async def assisted_register(self, email: str, password: str, force: bool = False, displayName: typing.Optional[str] = None):
         data = {
             "email": email,
             "password": password,
@@ -976,7 +1192,7 @@ class LockOperations(object):
             [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_name(self, lockId: str, name: str = None):
+    async def update_lock_name(self, lockId: str, name: typing.Optional[str] = None):
         data = {
             "lockId": lockId,
             "name": name
@@ -986,7 +1202,7 @@ class LockOperations(object):
             [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_favourite(self, lockId: str, favourite: bool = None):
+    async def update_lock_favourite(self, lockId: str, favourite: typing.Optional[bool] = None):
         data = {
             "lockId": lockId,
             "favourite": favourite
@@ -996,7 +1212,7 @@ class LockOperations(object):
             [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_colour(self, lockId: str, colour: str = None):
+    async def update_lock_colour(self, lockId: str, colour: typing.Optional[str] = None):
         data = {
             "lockId": lockId,
             "colour": colour
@@ -1006,7 +1222,7 @@ class LockOperations(object):
             [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_setting_default_name(self, lockId: str, name: str = None):
+    async def update_lock_setting_default_name(self, lockId: str, name: typing.Optional[str] = None):
         data = {
             "lockId": lockId,
             "name": name
@@ -1039,17 +1255,17 @@ class LockOperations(object):
     async def set_lock_setting_time_restrictions(self, lockId: str, times: List[TimeRequirement]):
         data = {
             "lockId": lockId,
-            "times": dataclasses.asdict(times)
+            "times": [dataclasses.asdict(t) for t in times]
         }
         return await execute_async(
             _doordeck_headless_sdk.setLockSettingTimeRestrictions,
             [self.resource, json.dumps(data)]
         )
 
-    async def update_lock_setting_location_restrictions(self, lockId: str, location: LocationRequirement = None):
+    async def update_lock_setting_location_restrictions(self, lockId: str, location: typing.Optional[LocationRequirement] = None):
         data = {
             "lockId": lockId,
-            "location": dataclasses.asdict(location)
+            **({"location": dataclasses.asdict(location)} if location is not None else {})
         }
         return await execute_async(
             _doordeck_headless_sdk.updateLockSettingLocationRestrictions,
@@ -1429,9 +1645,55 @@ class Tiles(object):
 
 class InitializeSdk(object):
 
-    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):
+    def __init__(self, api_environment: typing.Literal["DEV", "STAGING", "PROD"] = "PROD",
+        cloud_auth_token: typing.Optional[str] = None, cloud_refresh_token: typing.Optional[str] = None,
+        fusion_host: typing.Optional[str] = None, secure_storage_impl: typing.Optional[ISecureStorage] = None):
+
+        self.secureStorage = Doordeck_Headless_Sdk_kref_com_doordeck_multiplatform_sdk_storage_SecureStorage()
+        if secure_storage_impl is not None:
+            SecureStorage.Implementation = secure_storage_impl
+
+            setApiEnvironmentCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.set_api_environment), ctypes.c_void_p).value
+            getApiEnvironmentCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_api_environment), ctypes.c_void_p).value
+            addCloudAuthTokenCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.add_cloud_auth_token), ctypes.c_void_p).value
+            getCloudAuthTokenCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_cloud_auth_token), ctypes.c_void_p).value
+            addCloudRefreshTokenCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.add_cloud_refresh_auth_token), ctypes.c_void_p).value
+            getCloudRefreshTokenCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_cloud_refresh_token), ctypes.c_void_p).value
+            setFusionHostCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.set_fusion_host), ctypes.c_void_p).value
+            getFusionHostCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_fusion_host), ctypes.c_void_p).value
+            addFusionAuthTokenCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.add_fusion_auth_token), ctypes.c_void_p).value
+            getFusionAuthTokenCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_fusion_auth_token), ctypes.c_void_p).value
+            addPublicKeyCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.add_public_key), ctypes.c_void_p).value
+            getPublicKeyCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_public_key), ctypes.c_void_p).value
+            addPrivateKeyCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.add_private_key), ctypes.c_void_p).value
+            getPrivateKeyCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_private_key), ctypes.c_void_p).value
+            setKeyPairVerifiedCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.set_key_pair_verified), ctypes.c_void_p).value
+            getKeyPairVerifiedCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_key_pair_verified), ctypes.c_void_p).value
+            addUserIdCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.add_user_id), ctypes.c_void_p).value
+            getUserIdCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_user_id), ctypes.c_void_p).value
+            addUserEmailCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.set_user_email), ctypes.c_void_p).value
+            getUserEmailCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_user_email), ctypes.c_void_p).value
+            addCertificateChainCp = ctypes.cast(SecureStorage.py_set_data_type(SecureStorage.add_certificate_chain), ctypes.c_void_p).value
+            getCertificateChainCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.get_certificate_chain), ctypes.c_void_p).value
+            clearCp = ctypes.cast(SecureStorage.py_get_data_type(SecureStorage.clear), ctypes.c_void_p).value
+
+            self.secureStorage = _doordeck_headless_sdk.createMingwSecureStorage(
+                setApiEnvironmentCp, getApiEnvironmentCp,
+                addCloudAuthTokenCp, getCloudAuthTokenCp,
+                addCloudRefreshTokenCp, getCloudRefreshTokenCp,
+                setFusionHostCp, getFusionHostCp,
+                addFusionAuthTokenCp, getFusionAuthTokenCp,
+                addPublicKeyCp, getPublicKeyCp,
+                addPrivateKeyCp, getPrivateKeyCp,
+                setKeyPairVerifiedCp, getKeyPairVerifiedCp,
+                addUserIdCp, getUserIdCp,
+                addUserEmailCp, getUserEmailCp,
+                addCertificateChainCp, getCertificateChainCp,
+                clearCp
+            )
+
         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.sdkConfig = _doordeck_headless_sdk.buildSdkConfig(self.sdkApiEnvironment, cloud_auth_token, cloud_refresh_token, fusion_host, self.secureStorage)
         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))

{doordeck_headless_sdk-0.104.0.dist-info → doordeck_headless_sdk-0.105.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: doordeck_headless_sdk
-Version: 0.104.0
+Version: 0.105.0
 Summary: The official Doordeck SDK for Kotlin Multiplatform
 Author-email: Doordeck Limited <development@doordeck.com>
 Project-URL: Homepage, https://www.doordeck.com

doordeck_headless_sdk-0.105.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+doordeck_headless_sdk/Doordeck.Headless.Sdk.dll,sha256=uIcSUNnqzyWJYERj-Kek2ZDaUdEXD0DrI4chyLSz100,14162944
+doordeck_headless_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doordeck_headless_sdk/_doordeck_headless_sdk.pyd,sha256=Tq0Kxe5WQcRS8Xx5E_Si5Yv3JUWFFqght0YgMsnuzJ0,16056683
+doordeck_headless_sdk/doordeck_headless_sdk.py,sha256=V4v-MSCqk6UggXpN356WAKN87PYgtibAz70u9RNGdb4,3080443
+doordeck_headless_sdk-0.105.0.dist-info/licenses/LICENSE,sha256=zE1N4JILDTkSIDtdmqdnKKxKEQh_VdqeoAV2230eNOI,10141
+doordeck_headless_sdk-0.105.0.dist-info/METADATA,sha256=H_37aw2H0cB9VscYEblMqLOUAkHeT-baa8BgzP2mic0,3085
+doordeck_headless_sdk-0.105.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+doordeck_headless_sdk-0.105.0.dist-info/top_level.txt,sha256=VmXlkrtf2J3rayniS9e6Zpu_oYR7p4DmdudxnV0nd_U,22
+doordeck_headless_sdk-0.105.0.dist-info/RECORD,,

{doordeck_headless_sdk-0.104.0.dist-info → doordeck_headless_sdk-0.105.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

doordeck_headless_sdk-0.104.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-doordeck_headless_sdk/Doordeck.Headless.Sdk.dll,sha256=MVZw-PBd7CWFb7XskyD9reIdn88JzgKYc4-g8Ws1XhA,14162944
-doordeck_headless_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-doordeck_headless_sdk/_doordeck_headless_sdk.pyd,sha256=ePRQqYMSWRepc-gS8pgUe41gaeOn66IUb4qGDj_h4DM,16060267
-doordeck_headless_sdk/doordeck_headless_sdk.py,sha256=bKnGwKt27cOgRDq71viQmpiqUD1ERwN7jGkGSHJSFCU,3067423
-doordeck_headless_sdk-0.104.0.dist-info/licenses/LICENSE,sha256=zE1N4JILDTkSIDtdmqdnKKxKEQh_VdqeoAV2230eNOI,10141
-doordeck_headless_sdk-0.104.0.dist-info/METADATA,sha256=-T57EySB61y3r3Qc2gVGyksHxWP5E9UwV6HDO1NVnRk,3085
-doordeck_headless_sdk-0.104.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-doordeck_headless_sdk-0.104.0.dist-info/top_level.txt,sha256=VmXlkrtf2J3rayniS9e6Zpu_oYR7p4DmdudxnV0nd_U,22
-doordeck_headless_sdk-0.104.0.dist-info/RECORD,,