nuki-api-js 0.2.1 → 1.0.0

package/dist/effect.mjs

@@ -0,0 +1,2143 @@
+import { createEffectApi, createEffectByPath } from '@sferadev/openapi-utils/effect';
+export { ApiConfig, ApiError, NetworkError, ValidationError, makeApiLayer } from '@sferadev/openapi-utils/effect';
+
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+function compactObject(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value])=>notEmpty(value)));
+}
+
+const baseUrl = "https://api.nuki.io";
+async function client({ url, method, body, headers, pathParams, queryParams, signal, token = null, fetchImpl = fetch }) {
+    try {
+        const requestHeaders = compactObject({
+            "Content-Type": "application/json",
+            Authorization: token ? `Bearer ${token}` : undefined,
+            ...headers
+        });
+        if (requestHeaders["Content-Type"]?.toLowerCase().includes("multipart/form-data")) {
+            delete requestHeaders["Content-Type"];
+        }
+        const payload = body instanceof FormData ? body : requestHeaders["Content-Type"] === "application/json" ? JSON.stringify(body) : body;
+        const fullUrl = `${baseUrl}${resolveUrl(url, queryParams, pathParams)}`;
+        const response = await fetchImpl(fullUrl, {
+            signal,
+            method: method.toUpperCase(),
+            body: payload,
+            headers: requestHeaders
+        });
+        if (!response.ok) {
+            let error;
+            try {
+                error = await response.json();
+            } catch (e) {
+                error = {
+                    status: "unknown",
+                    payload: e instanceof Error ? `Unexpected error (${e.message})` : "Unexpected error"
+                };
+            }
+            throw error;
+        }
+        if (response.headers?.get("content-type")?.includes("json")) {
+            return await response.json();
+        } else {
+            return await response.text();
+        }
+    } catch (e) {
+        const errorObject = {
+            name: "unknown",
+            message: e instanceof Error ? `Network error (${e.message})` : "Network error",
+            stack: e
+        };
+        throw errorObject;
+    }
+}
+const resolveUrl = (url, queryParams = {}, pathParams = {})=>{
+    let query = new URLSearchParams(queryParams).toString();
+    if (query) query = `?${query}`;
+    return url.replace(/\{\w*\}/g, (key)=>pathParams[key.slice(1, -1)] ?? "") + query;
+};
+
+/**
+ * @summary Get an account
+ * @link /account
+ */ async function getAccountsResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/account`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update an account
+ * @link /account
+ */ async function postAccountsResource({ body, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/account`,
+        queryParams,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete an account
+ * @link /account
+ */ async function deleteAccountsResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "DELETE",
+        url: `/account`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Trigger the email change verification email
+ * @link /account/email/change
+ */ async function postAccountEmailChangeResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/account/email/change`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Trigger the email change verification email
+ * @link /account/email/verify
+ */ async function postAccountEmailVerifyResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/account/email/verify`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get all integrations for this account
+ * @link /account/integration
+ */ async function getAccountIntegrationsResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/account/integration`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete an integration
+ * @link /account/integration
+ */ async function deleteAccountIntegrationsResource({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "DELETE",
+        url: `/account/integration`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Enable one-time password for an account
+ * @link /account/otp
+ */ async function postAccountOtpResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/account/otp`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create a one-time password secret
+ * @link /account/otp
+ */ async function putAccountOtpResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "PUT",
+        url: `/account/otp`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Disable one-time password for an account
+ * @link /account/otp
+ */ async function deleteAccountOtpResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "DELETE",
+        url: `/account/otp`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Reset account password
+ * @link /account/password/reset
+ */ async function postAccountPasswordResetResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/account/password/reset`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get account setting
+ * @link /account/setting
+ */ async function getAccountSettingResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/account/setting`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create or update account setting
+ * @link /account/setting
+ */ async function putAccountSettingResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "PUT",
+        url: `/account/setting`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete an account setting
+ * @link /account/setting
+ */ async function deleteAccountSettingResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "DELETE",
+        url: `/account/setting`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of sub accounts
+ * @link /account/sub
+ */ async function getAccountSubsResource({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/account/sub`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create a sub account
+ * @link /account/sub
+ */ async function putAccountSubsResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "PUT",
+        url: `/account/sub`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a sub account
+ * @link /account/sub/{accountId}
+ */ async function getAccountSubResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.accountId) {
+        throw new Error(`Missing required path parameter: accountId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/account/sub/${pathParams.accountId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update a sub account
+ * @link /account/sub/{accountId}
+ */ async function postAccountSubResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.accountId) {
+        throw new Error(`Missing required path parameter: accountId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/account/sub/${pathParams.accountId}`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete a sub account
+ * @link /account/sub/{accountId}
+ */ async function deleteAccountSubResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.accountId) {
+        throw new Error(`Missing required path parameter: accountId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/account/sub/${pathParams.accountId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of account users
+ * @link /account/user
+ */ async function getAccountUsersResource({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/account/user`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create an account user
+ * @link /account/user
+ */ async function putAccountUsersResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "PUT",
+        url: `/account/user`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get an account user
+ * @link /account/user/{accountUserId}
+ */ async function getAccountUserResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.accountUserId) {
+        throw new Error(`Missing required path parameter: accountUserId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/account/user/${pathParams.accountUserId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update an account user
+ * @link /account/user/{accountUserId}
+ */ async function postAccountUserResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.accountUserId) {
+        throw new Error(`Missing required path parameter: accountUserId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/account/user/${pathParams.accountUserId}`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete an account user asynchronously
+ * @link /account/user/{accountUserId}
+ */ async function deleteAccountUserResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.accountUserId) {
+        throw new Error(`Missing required path parameter: accountUserId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/account/user/${pathParams.accountUserId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of addresses
+ * @link /address
+ */ async function getAddressesResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/address`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create an address
+ * @link /address
+ */ async function putAddressesResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "PUT",
+        url: `/address`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get info about an address token
+ * @link /address/token/{id}
+ */ async function getAddressTokenResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/address/token/${pathParams.id}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a redeemed address token
+ * @link /address/token/{id}/redeem
+ */ async function getAddressTokenRedeemResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/address/token/${pathParams.id}/redeem`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Redeem an address token
+ * @link /address/token/{id}/redeem
+ */ async function postAddressTokenRedeemResource({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/address/token/${pathParams.id}/redeem`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update an address
+ * @link /address/{addressId}
+ */ async function postAddressResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/address/${pathParams.addressId}`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete an address
+ * @link /address/{addressId}
+ */ async function deleteAddressResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/address/${pathParams.addressId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of address reservations
+ * @link /address/{addressId}/reservation
+ */ async function getAddressReservationsResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/address/${pathParams.addressId}/reservation`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Issues authorizations for an address reservation
+ * @link /address/{addressId}/reservation/{id}/issue
+ */ async function postAddressReservationIssueResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/address/${pathParams.addressId}/reservation/${pathParams.id}/issue`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Revoke authorizations for an address reservation
+ * @link /address/{addressId}/reservation/{id}/revoke
+ */ async function postAddressReservationRevokeResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/address/${pathParams.addressId}/reservation/${pathParams.id}/revoke`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update access times of a reservation
+ * @link /address/{addressId}/reservation/{id}/update/accesstimes
+ */ async function postReservationAccessTimesUpdateResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/address/${pathParams.addressId}/reservation/${pathParams.id}/update/accesstimes`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of address tokens
+ * @link /address/{addressId}/token
+ */ async function getAddressTokensResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/address/${pathParams.addressId}/token`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of address units
+ * @link /address/{addressId}/unit
+ */ async function getAddressUnitsResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/address/${pathParams.addressId}/unit`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create an address unit
+ * @link /address/{addressId}/unit
+ */ async function putAddressUnitsResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    const data = await request({
+        method: "PUT",
+        url: `/address/${pathParams.addressId}/unit`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete address units asynchronously
+ * @link /address/{addressId}/unit
+ */ async function deleteAddressUnitsResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/address/${pathParams.addressId}/unit`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete an address unit
+ * @link /address/{addressId}/unit/{id}
+ */ async function deleteAddressUnitResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.addressId) {
+        throw new Error(`Missing required path parameter: addressId`);
+    }
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/address/${pathParams.addressId}/unit/${pathParams.id}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get all registered decentral webhooks
+ * @link /api/decentralWebhook
+ */ async function getDecentralWebhooksResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/api/decentralWebhook`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create decentral webhook
+ * @link /api/decentralWebhook
+ */ async function putDecentralWebhooksResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "PUT",
+        url: `/api/decentralWebhook`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Unregister a decentral webhook
+ * @link /api/decentralWebhook/{id}
+ */ async function deleteDecentralWebhookResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/api/decentralWebhook/${pathParams.id}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of API keys
+ * @link /api/key
+ */ async function getApiKeysResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/api/key`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create an API key
+ * @link /api/key
+ */ async function putApiKeysResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "PUT",
+        url: `/api/key`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update an API key
+ * @link /api/key/{apiKeyId}
+ */ async function postApiKeyResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/api/key/${pathParams.apiKeyId}`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete an API key
+ * @link /api/key/{apiKeyId}
+ */ async function deleteApiKeyResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/api/key/${pathParams.apiKeyId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get an advanced API key
+ * @link /api/key/{apiKeyId}/advanced
+ */ async function getApiKeyAdvancedResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/api/key/${pathParams.apiKeyId}/advanced`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update an advanced API key
+ * @link /api/key/{apiKeyId}/advanced
+ */ async function postApiKeyAdvancedResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/api/key/${pathParams.apiKeyId}/advanced`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create an advanced API key
+ * @link /api/key/{apiKeyId}/advanced
+ */ async function putApiKeyAdvancedResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    const data = await request({
+        method: "PUT",
+        url: `/api/key/${pathParams.apiKeyId}/advanced`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete an advanced API key
+ * @link /api/key/{apiKeyId}/advanced
+ */ async function deleteApiKeyAdvancedResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/api/key/${pathParams.apiKeyId}/advanced`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Reactivate a deactivated advanced webhook integration
+ * @link /api/key/{apiKeyId}/advanced/reactivate
+ */ async function postApiKeyAdvancedReactivateResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/api/key/${pathParams.apiKeyId}/advanced/reactivate`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of API key tokens
+ * @link /api/key/{apiKeyId}/token
+ */ async function getApiKeyTokensResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/api/key/${pathParams.apiKeyId}/token`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create an API key token
+ * @link /api/key/{apiKeyId}/token
+ */ async function putApiKeyTokensResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    const data = await request({
+        method: "PUT",
+        url: `/api/key/${pathParams.apiKeyId}/token`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update an API key token
+ * @link /api/key/{apiKeyId}/token/{id}
+ */ async function postApiKeyTokenResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/api/key/${pathParams.apiKeyId}/token/${pathParams.id}`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete an API key token
+ * @link /api/key/{apiKeyId}/token/{id}
+ */ async function deleteApiKeyTokenResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/api/key/${pathParams.apiKeyId}/token/${pathParams.id}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of webhook logs (descending)
+ * @link /api/key/{apiKeyId}/webhook/logs
+ */ async function getWebhookLogsResource({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.apiKeyId) {
+        throw new Error(`Missing required path parameter: apiKeyId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/api/key/${pathParams.apiKeyId}/webhook/logs`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update the web config for a group of smartlocks
+ * @link /bulk-web-config
+ */ async function postSmartlockBulkWebConfigResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/bulk-web-config`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of companies
+ * @link /company
+ */ async function getCompaniesResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/company`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get all notifications attached to your account
+ * @link /notification
+ */ async function getNotificationsResource({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/notification`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create a notification configuration
+ * @link /notification
+ */ async function putNotificationsResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "PUT",
+        url: `/notification`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a notification configuration
+ * @link /notification/{notificationId}
+ */ async function getNotificationResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.notificationId) {
+        throw new Error(`Missing required path parameter: notificationId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/notification/${pathParams.notificationId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update a notification configuration
+ * @link /notification/{notificationId}
+ */ async function postNotificationResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.notificationId) {
+        throw new Error(`Missing required path parameter: notificationId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/notification/${pathParams.notificationId}`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete a notification configuration
+ * @link /notification/{notificationId}
+ */ async function deleteNotificationResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.notificationId) {
+        throw new Error(`Missing required path parameter: notificationId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/notification/${pathParams.notificationId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get all intercom brands
+ * @link /opener/brand
+ */ async function getOpenerBrandsResource({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/opener/brand`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get an intercom brand
+ * @link /opener/brand/{brandId}
+ */ async function getOpenerBrandResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.brandId) {
+        throw new Error(`Missing required path parameter: brandId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/opener/brand/${pathParams.brandId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of intercom models
+ * @link /opener/intercom
+ */ async function getOpenerIntercomsResource({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/opener/intercom`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get an intercom model
+ * @link /opener/intercom/{intercomId}
+ */ async function getOpenerIntercomResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.intercomId) {
+        throw new Error(`Missing required path parameter: intercomId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/opener/intercom/${pathParams.intercomId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of services
+ * @link /service
+ */ async function getServicesResource({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/service`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a service
+ * @link /service/{serviceId}
+ */ async function getServiceResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.serviceId) {
+        throw new Error(`Missing required path parameter: serviceId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/service/${pathParams.serviceId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Link a service
+ * @link /service/{serviceId}/link
+ */ async function postServiceLinkResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.serviceId) {
+        throw new Error(`Missing required path parameter: serviceId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/service/${pathParams.serviceId}/link`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Sync a service
+ * @link /service/{serviceId}/sync
+ */ async function postServiceSyncResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.serviceId) {
+        throw new Error(`Missing required path parameter: serviceId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/service/${pathParams.serviceId}/sync`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Unlink a service
+ * @link /service/{serviceId}/unlink
+ */ async function postServiceUnlinkResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.serviceId) {
+        throw new Error(`Missing required path parameter: serviceId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/service/${pathParams.serviceId}/unlink`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of smartlocks
+ * @link /smartlock
+ */ async function getSmartlocksResource({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/smartlock`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of smartlock authorizations for your smartlocks
+ * @link /smartlock/auth
+ */ async function getSmartlocksAuthsResource({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/smartlock/auth`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update smartlock authorizations asynchronously
+ * @link /smartlock/auth
+ */ async function postSmartlocksAuthsResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/auth`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create smartlock authorizations asynchronously
+ * @link /smartlock/auth
+ */ async function putSmartlocksAuthsResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "PUT",
+        url: `/smartlock/auth`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete smartlock authorizations asynchronously
+ * @link /smartlock/auth
+ */ async function deleteSmartlocksAuthsResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "DELETE",
+        url: `/smartlock/auth`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create smartlock authorizations asynchronously
+ * @link /smartlock/auth/advanced
+ */ async function putSmartlockAuthsAdvancedResource({ body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "PUT",
+        url: `/smartlock/auth/advanced`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a paginated list of smartlock authorizations for your smartlocks
+ * @link /smartlock/auth/paged
+ */ async function getSmartlocksAuthsPaginatedResource({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/smartlock/auth/paged`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of smartlock logs for all of your smartlocks
+ * @link /smartlock/log
+ */ async function getSmartlocksLogsResource({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/smartlock/log`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a smartlock
+ * @link /smartlock/{smartlockId}
+ */ async function getSmartlockResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/smartlock/${pathParams.smartlockId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update a smartlock
+ * @link /smartlock/{smartlockId}
+ */ async function postSmartlockResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete a smartlock
+ * @link /smartlock/{smartlockId}
+ */ async function deleteSmartlockResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/smartlock/${pathParams.smartlockId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Lock & unlock a smartlock with options
+ * @link /smartlock/{smartlockId}/action
+ */ async function postSmartlockActionResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/action`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Lock & unlock a smartlock with callback
+ * @link /smartlock/{smartlockId}/action/advanced
+ */ async function postSmartlockActionAdvancedResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/action/advanced`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Lock a smartlock
+ * @link /smartlock/{smartlockId}/action/lock
+ */ async function postSmartlockLockActionResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/action/lock`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Lock a smartlock
+ * @link /smartlock/{smartlockId}/action/lock/advanced
+ */ async function postSmartlockLockActionAdvancedResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/action/lock/advanced`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Unlock a smartlock
+ * @link /smartlock/{smartlockId}/action/unlock
+ */ async function postSmartlockUnlockActionResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/action/unlock`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Unlock a smartlock
+ * @link /smartlock/{smartlockId}/action/unlock/advanced
+ */ async function postSmartlockUnlockActionAdvancedResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/action/unlock/advanced`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update a smartlock admin PIN
+ * @link /smartlock/{smartlockId}/admin/pin
+ */ async function postSmartlockAdminPinResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/admin/pin`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update a smartlock advanced config
+ * @link /smartlock/{smartlockId}/advanced/config
+ */ async function postSmartlockAdvancedConfigResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/advanced/config`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update an opener advanced config
+ * @link /smartlock/{smartlockId}/advanced/openerconfig
+ */ async function postSmartlockOpenerAdvancedConfigResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/advanced/openerconfig`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update a smartdoor advanced config
+ * @link /smartlock/{smartlockId}/advanced/smartdoorconfig
+ */ async function postSmartdoorAdvancedConfigResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/advanced/smartdoorconfig`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of smartlock authorizations
+ * @link /smartlock/{smartlockId}/auth
+ */ async function getSmartlockAuthsResource({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/smartlock/${pathParams.smartlockId}/auth`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create a smartlock authorization asynchronously
+ * @link /smartlock/{smartlockId}/auth
+ */ async function putSmartlockAuthsResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "PUT",
+        url: `/smartlock/${pathParams.smartlockId}/auth`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Generate a new smartlock auth with a shared key
+ * @link /smartlock/{smartlockId}/auth/advanced/sharedkey
+ */ async function postSmartlockAuthWithSharedKeyResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/auth/advanced/sharedkey`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a smartlock authorization
+ * @link /smartlock/{smartlockId}/auth/{id}
+ */ async function getSmartlockAuthResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/smartlock/${pathParams.smartlockId}/auth/${pathParams.id}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update a smartlock authorization asynchronously
+ * @link /smartlock/{smartlockId}/auth/{id}
+ */ async function postSmartlockAuthResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/auth/${pathParams.id}`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete a smartlock authorization asynchronously
+ * @link /smartlock/{smartlockId}/auth/{id}
+ */ async function deleteSmartlockAuthResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    if (!pathParams.id) {
+        throw new Error(`Missing required path parameter: id`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/smartlock/${pathParams.smartlockId}/auth/${pathParams.id}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update a smartlock config
+ * @link /smartlock/{smartlockId}/config
+ */ async function postSmartlockConfigResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/config`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get a list of smartlock logs
+ * @link /smartlock/{smartlockId}/log
+ */ async function getSmartlockLogsResource({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/smartlock/${pathParams.smartlockId}/log`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Sync a smartlock
+ * @link /smartlock/{smartlockId}/sync
+ */ async function postSmartlockSyncResource({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/sync`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update a smartlock web config
+ * @link /smartlock/{smartlockId}/web/config
+ */ async function postSmartlockWebConfigResource({ pathParams, body, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.smartlockId) {
+        throw new Error(`Missing required path parameter: smartlockId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/smartlock/${pathParams.smartlockId}/web/config`,
+        body: body,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+const operationsByPath = {
+    "GET /account": getAccountsResource,
+    "POST /account": postAccountsResource,
+    "DELETE /account": deleteAccountsResource,
+    "POST /account/email/change": postAccountEmailChangeResource,
+    "POST /account/email/verify": postAccountEmailVerifyResource,
+    "GET /account/integration": getAccountIntegrationsResource,
+    "DELETE /account/integration": deleteAccountIntegrationsResource,
+    "POST /account/otp": postAccountOtpResource,
+    "PUT /account/otp": putAccountOtpResource,
+    "DELETE /account/otp": deleteAccountOtpResource,
+    "POST /account/password/reset": postAccountPasswordResetResource,
+    "GET /account/setting": getAccountSettingResource,
+    "PUT /account/setting": putAccountSettingResource,
+    "DELETE /account/setting": deleteAccountSettingResource,
+    "GET /account/sub": getAccountSubsResource,
+    "PUT /account/sub": putAccountSubsResource,
+    "GET /account/sub/{accountId}": getAccountSubResource,
+    "POST /account/sub/{accountId}": postAccountSubResource,
+    "DELETE /account/sub/{accountId}": deleteAccountSubResource,
+    "GET /account/user": getAccountUsersResource,
+    "PUT /account/user": putAccountUsersResource,
+    "GET /account/user/{accountUserId}": getAccountUserResource,
+    "POST /account/user/{accountUserId}": postAccountUserResource,
+    "DELETE /account/user/{accountUserId}": deleteAccountUserResource,
+    "GET /address": getAddressesResource,
+    "PUT /address": putAddressesResource,
+    "GET /address/token/{id}": getAddressTokenResource,
+    "GET /address/token/{id}/redeem": getAddressTokenRedeemResource,
+    "POST /address/token/{id}/redeem": postAddressTokenRedeemResource,
+    "POST /address/{addressId}": postAddressResource,
+    "DELETE /address/{addressId}": deleteAddressResource,
+    "GET /address/{addressId}/reservation": getAddressReservationsResource,
+    "POST /address/{addressId}/reservation/{id}/issue": postAddressReservationIssueResource,
+    "POST /address/{addressId}/reservation/{id}/revoke": postAddressReservationRevokeResource,
+    "POST /address/{addressId}/reservation/{id}/update/accesstimes": postReservationAccessTimesUpdateResource,
+    "GET /address/{addressId}/token": getAddressTokensResource,
+    "GET /address/{addressId}/unit": getAddressUnitsResource,
+    "PUT /address/{addressId}/unit": putAddressUnitsResource,
+    "DELETE /address/{addressId}/unit": deleteAddressUnitsResource,
+    "DELETE /address/{addressId}/unit/{id}": deleteAddressUnitResource,
+    "GET /api/decentralWebhook": getDecentralWebhooksResource,
+    "PUT /api/decentralWebhook": putDecentralWebhooksResource,
+    "DELETE /api/decentralWebhook/{id}": deleteDecentralWebhookResource,
+    "GET /api/key": getApiKeysResource,
+    "PUT /api/key": putApiKeysResource,
+    "POST /api/key/{apiKeyId}": postApiKeyResource,
+    "DELETE /api/key/{apiKeyId}": deleteApiKeyResource,
+    "GET /api/key/{apiKeyId}/advanced": getApiKeyAdvancedResource,
+    "POST /api/key/{apiKeyId}/advanced": postApiKeyAdvancedResource,
+    "PUT /api/key/{apiKeyId}/advanced": putApiKeyAdvancedResource,
+    "DELETE /api/key/{apiKeyId}/advanced": deleteApiKeyAdvancedResource,
+    "POST /api/key/{apiKeyId}/advanced/reactivate": postApiKeyAdvancedReactivateResource,
+    "GET /api/key/{apiKeyId}/token": getApiKeyTokensResource,
+    "PUT /api/key/{apiKeyId}/token": putApiKeyTokensResource,
+    "POST /api/key/{apiKeyId}/token/{id}": postApiKeyTokenResource,
+    "DELETE /api/key/{apiKeyId}/token/{id}": deleteApiKeyTokenResource,
+    "GET /api/key/{apiKeyId}/webhook/logs": getWebhookLogsResource,
+    "POST /bulk-web-config": postSmartlockBulkWebConfigResource,
+    "GET /company": getCompaniesResource,
+    "GET /notification": getNotificationsResource,
+    "PUT /notification": putNotificationsResource,
+    "GET /notification/{notificationId}": getNotificationResource,
+    "POST /notification/{notificationId}": postNotificationResource,
+    "DELETE /notification/{notificationId}": deleteNotificationResource,
+    "GET /opener/brand": getOpenerBrandsResource,
+    "GET /opener/brand/{brandId}": getOpenerBrandResource,
+    "GET /opener/intercom": getOpenerIntercomsResource,
+    "GET /opener/intercom/{intercomId}": getOpenerIntercomResource,
+    "GET /service": getServicesResource,
+    "GET /service/{serviceId}": getServiceResource,
+    "POST /service/{serviceId}/link": postServiceLinkResource,
+    "POST /service/{serviceId}/sync": postServiceSyncResource,
+    "POST /service/{serviceId}/unlink": postServiceUnlinkResource,
+    "GET /smartlock": getSmartlocksResource,
+    "GET /smartlock/auth": getSmartlocksAuthsResource,
+    "POST /smartlock/auth": postSmartlocksAuthsResource,
+    "PUT /smartlock/auth": putSmartlocksAuthsResource,
+    "DELETE /smartlock/auth": deleteSmartlocksAuthsResource,
+    "PUT /smartlock/auth/advanced": putSmartlockAuthsAdvancedResource,
+    "GET /smartlock/auth/paged": getSmartlocksAuthsPaginatedResource,
+    "GET /smartlock/log": getSmartlocksLogsResource,
+    "GET /smartlock/{smartlockId}": getSmartlockResource,
+    "POST /smartlock/{smartlockId}": postSmartlockResource,
+    "DELETE /smartlock/{smartlockId}": deleteSmartlockResource,
+    "POST /smartlock/{smartlockId}/action": postSmartlockActionResource,
+    "POST /smartlock/{smartlockId}/action/advanced": postSmartlockActionAdvancedResource,
+    "POST /smartlock/{smartlockId}/action/lock": postSmartlockLockActionResource,
+    "POST /smartlock/{smartlockId}/action/lock/advanced": postSmartlockLockActionAdvancedResource,
+    "POST /smartlock/{smartlockId}/action/unlock": postSmartlockUnlockActionResource,
+    "POST /smartlock/{smartlockId}/action/unlock/advanced": postSmartlockUnlockActionAdvancedResource,
+    "POST /smartlock/{smartlockId}/admin/pin": postSmartlockAdminPinResource,
+    "POST /smartlock/{smartlockId}/advanced/config": postSmartlockAdvancedConfigResource,
+    "POST /smartlock/{smartlockId}/advanced/openerconfig": postSmartlockOpenerAdvancedConfigResource,
+    "POST /smartlock/{smartlockId}/advanced/smartdoorconfig": postSmartdoorAdvancedConfigResource,
+    "GET /smartlock/{smartlockId}/auth": getSmartlockAuthsResource,
+    "PUT /smartlock/{smartlockId}/auth": putSmartlockAuthsResource,
+    "POST /smartlock/{smartlockId}/auth/advanced/sharedkey": postSmartlockAuthWithSharedKeyResource,
+    "GET /smartlock/{smartlockId}/auth/{id}": getSmartlockAuthResource,
+    "POST /smartlock/{smartlockId}/auth/{id}": postSmartlockAuthResource,
+    "DELETE /smartlock/{smartlockId}/auth/{id}": deleteSmartlockAuthResource,
+    "POST /smartlock/{smartlockId}/config": postSmartlockConfigResource,
+    "GET /smartlock/{smartlockId}/log": getSmartlockLogsResource,
+    "POST /smartlock/{smartlockId}/sync": postSmartlockSyncResource,
+    "POST /smartlock/{smartlockId}/web/config": postSmartlockWebConfigResource
+};
+const operationsByTag = {
+    "account": {
+        getAccountsResource,
+        postAccountsResource,
+        deleteAccountsResource,
+        postAccountEmailChangeResource,
+        postAccountEmailVerifyResource,
+        getAccountIntegrationsResource,
+        deleteAccountIntegrationsResource,
+        postAccountOtpResource,
+        putAccountOtpResource,
+        deleteAccountOtpResource,
+        postAccountPasswordResetResource,
+        getAccountSettingResource,
+        putAccountSettingResource,
+        deleteAccountSettingResource,
+        getAccountSubsResource,
+        putAccountSubsResource,
+        getAccountSubResource,
+        postAccountSubResource,
+        deleteAccountSubResource
+    },
+    "accountuser": {
+        getAccountUsersResource,
+        putAccountUsersResource,
+        getAccountUserResource,
+        postAccountUserResource,
+        deleteAccountUserResource
+    },
+    "address": {
+        getAddressesResource,
+        putAddressesResource,
+        postAddressResource,
+        deleteAddressResource,
+        getAddressUnitsResource,
+        putAddressUnitsResource,
+        deleteAddressUnitsResource,
+        deleteAddressUnitResource
+    },
+    "addresstoken": {
+        getAddressTokenResource,
+        getAddressTokenRedeemResource,
+        postAddressTokenRedeemResource,
+        getAddressTokensResource
+    },
+    "addressreservation": {
+        getAddressReservationsResource,
+        postAddressReservationIssueResource,
+        postAddressReservationRevokeResource,
+        postReservationAccessTimesUpdateResource
+    },
+    "advancedapi": {
+        getDecentralWebhooksResource,
+        putDecentralWebhooksResource,
+        deleteDecentralWebhookResource,
+        getWebhookLogsResource,
+        putSmartlockAuthsAdvancedResource,
+        postSmartlockActionAdvancedResource,
+        postSmartlockLockActionAdvancedResource,
+        postSmartlockUnlockActionAdvancedResource
+    },
+    "apikey": {
+        getApiKeysResource,
+        putApiKeysResource,
+        postApiKeyResource,
+        deleteApiKeyResource,
+        getApiKeyAdvancedResource,
+        postApiKeyAdvancedResource,
+        putApiKeyAdvancedResource,
+        deleteApiKeyAdvancedResource,
+        postApiKeyAdvancedReactivateResource,
+        getApiKeyTokensResource,
+        putApiKeyTokensResource,
+        postApiKeyTokenResource,
+        deleteApiKeyTokenResource
+    },
+    "smartlock": {
+        postSmartlockBulkWebConfigResource,
+        getSmartlocksResource,
+        getSmartlockResource,
+        postSmartlockResource,
+        deleteSmartlockResource,
+        postSmartlockActionResource,
+        postSmartlockLockActionResource,
+        postSmartlockUnlockActionResource,
+        postSmartlockAdminPinResource,
+        postSmartlockAdvancedConfigResource,
+        postSmartlockOpenerAdvancedConfigResource,
+        postSmartdoorAdvancedConfigResource,
+        postSmartlockConfigResource,
+        postSmartlockSyncResource,
+        postSmartlockWebConfigResource
+    },
+    "company": {
+        getCompaniesResource
+    },
+    "notification": {
+        getNotificationsResource,
+        putNotificationsResource,
+        getNotificationResource,
+        postNotificationResource,
+        deleteNotificationResource
+    },
+    "opener": {
+        getOpenerBrandsResource,
+        getOpenerBrandResource,
+        getOpenerIntercomsResource,
+        getOpenerIntercomResource
+    },
+    "service": {
+        getServicesResource,
+        getServiceResource,
+        postServiceLinkResource,
+        postServiceSyncResource,
+        postServiceUnlinkResource
+    },
+    "smartlockauth": {
+        getSmartlocksAuthsResource,
+        postSmartlocksAuthsResource,
+        putSmartlocksAuthsResource,
+        deleteSmartlocksAuthsResource,
+        getSmartlocksAuthsPaginatedResource,
+        getSmartlockAuthsResource,
+        putSmartlockAuthsResource,
+        postSmartlockAuthWithSharedKeyResource,
+        getSmartlockAuthResource,
+        postSmartlockAuthResource,
+        deleteSmartlockAuthResource
+    },
+    "smartlocklog": {
+        getSmartlocksLogsResource,
+        getSmartlockLogsResource
+    }
+};
+
+const ApiService = createEffectApi(operationsByTag);
+const effectByPath = createEffectByPath(operationsByPath);
+
+export { ApiService, effectByPath };