@allthings/sdk 10.0.0-beta.1 → 10.0.0-beta.2

package/dist/lib.esm.js

@@ -1,1350 +0,0 @@
-import Bottleneck from 'bottleneck';
-
-function createTokenStore(initialToken) {
-    const token = new Map(Object.entries(initialToken || {}));
-    return {
-        get: (key) => token.get(key),
-        reset: () => token.clear(),
-        set: (update) => Object.entries(update).forEach(([key, value]) => token.set(key, value)),
-    };
-}
-
-const version = "10.0.0-beta.1";
-
-const environment = typeof process !== 'undefined' && process.env ? process.env : {};
-
-const REST_API_URL = 'https://api.allthings.me';
-const OAUTH_URL = 'https://accounts.allthings.me';
-const QUEUE_CONCURRENCY = undefined;
-const QUEUE_DELAY = 0;
-const QUEUE_RESERVOIR = 30;
-const QUEUE_RESERVOIR_REFILL_INTERVAL = 166;
-const REQUEST_BACK_OFF_INTERVAL = 200;
-const REQUEST_MAX_RETRIES = 50;
-const DEFAULT_API_WRAPPER_OPTIONS = {
-    apiUrl: environment.ALLTHINGS_REST_API_URL || REST_API_URL,
-    clientId: environment.ALLTHINGS_OAUTH_CLIENT_ID,
-    clientSecret: environment.ALLTHINGS_OAUTH_CLIENT_SECRET,
-    oauthUrl: environment.ALLTHINGS_OAUTH_URL || OAUTH_URL,
-    password: environment.ALLTHINGS_OAUTH_PASSWORD,
-    requestBackOffInterval: REQUEST_BACK_OFF_INTERVAL,
-    requestMaxRetries: REQUEST_MAX_RETRIES,
-    scope: 'user:profile',
-    username: environment.ALLTHINGS_OAUTH_USERNAME,
-};
-const USER_AGENT = `Allthings Node SDK REST Client/${version}`;
-
-function buildQueryString(params) {
-    const usp = new URLSearchParams();
-    for (const [key, value] of Object.entries(params).sort(([a], [b]) => a.localeCompare(b))) {
-        if (value != null && value !== '') {
-            usp.append(key, String(value));
-        }
-    }
-    return usp.toString();
-}
-function parseQueryString(query) {
-    const cleaned = query.startsWith('#') ? query.slice(1) : query;
-    return Object.fromEntries(new URLSearchParams(cleaned));
-}
-
-const RESPONSE_TYPE$1 = 'code';
-const GRANT_TYPE$3 = 'authorization_code';
-const castToAuthorizationRequestParameters$1 = (parameters) => {
-    const { redirectUri, clientId, scope, state } = parameters;
-    if (!clientId) {
-        throw new Error('Missing required "clientId" parameter to perform authorization code grant redirect');
-    }
-    if (!redirectUri) {
-        throw new Error('Missing required "redirectUri" parameter to perform authorization code grant redirect');
-    }
-    return {
-        client_id: clientId,
-        redirect_uri: redirectUri,
-        response_type: RESPONSE_TYPE$1,
-        ...(scope ? { scope } : {}),
-        ...(state ? { state } : {}),
-    };
-};
-const isEligibleForClientRedirect$1 = (parameters) => {
-    try {
-        return !!castToAuthorizationRequestParameters$1(parameters);
-    }
-    catch {
-        return false;
-    }
-};
-const getRedirectUrl$1 = (parameters) => `${parameters.oauthUrl}/oauth/authorize?${buildQueryString(castToAuthorizationRequestParameters$1(parameters))}`;
-const castToTokenRequestParameters$2 = (parameters) => {
-    const { authorizationCode, redirectUri, clientId, clientSecret } = parameters;
-    if (!clientId) {
-        throw new Error('Missing required "clientId" parameter to perform authorization code grant');
-    }
-    if (!redirectUri) {
-        throw new Error('Missing required "redirectUri" parameter to perform authorization code grant');
-    }
-    if (!authorizationCode) {
-        throw new Error('Missing required "authorizationCode" parameter to perform authorization code grant');
-    }
-    return {
-        client_id: clientId,
-        code: authorizationCode,
-        grant_type: GRANT_TYPE$3,
-        redirect_uri: redirectUri,
-        ...(clientSecret ? { client_secret: clientSecret } : {}),
-    };
-};
-const isEligible$3 = (parameters) => {
-    try {
-        return !!castToTokenRequestParameters$2(parameters);
-    }
-    catch {
-        return false;
-    }
-};
-const requestToken$3 = (tokenRequester, parameters) => tokenRequester(castToTokenRequestParameters$2(parameters));
-
-const SUBSCRIPTIONS = environment.DEBUG?.split(',').map((item) => item.trim()) || [];
-function makeLogger(name) {
-    return ['log', 'info', 'warn', 'error'].reduce((logger, type) => ({
-        ...logger,
-        [type]: function log(...logs) {
-            if (SUBSCRIPTIONS.includes('*') ||
-                SUBSCRIPTIONS.includes(name) ||
-                SUBSCRIPTIONS.includes(name.toLocaleLowerCase())) {
-                console[type](`${name}:`, ...logs);
-            }
-            return true;
-        },
-    }), {});
-}
-
-const logger = makeLogger('OAuth Token Request');
-const makeFetchTokenRequester = (url) => async (parameters) => {
-    try {
-        const response = await fetch(url, {
-            body: buildQueryString(parameters),
-            cache: 'no-cache',
-            credentials: 'omit',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                accept: 'application/json',
-                'user-agent': USER_AGENT,
-            },
-            method: 'POST',
-            mode: 'cors',
-        });
-        if (response.status !== 200) {
-            throw response;
-        }
-        const { access_token: newAccessToken, refresh_token: newRefreshToken, expires_in: expiresIn, } = await response.json();
-        return {
-            accessToken: newAccessToken,
-            expiresIn,
-            refreshToken: newRefreshToken,
-        };
-    }
-    catch (error) {
-        if (!(error instanceof Response)) {
-            throw error;
-        }
-        const errorName = `HTTP ${error.status} — ${error.statusText}`;
-        logger.error(errorName, error);
-        throw new Error(`HTTP ${error.status} — ${error.statusText}. Could not get token.`);
-    }
-};
-
-const GRANT_TYPE$2 = 'refresh_token';
-const castToTokenRequestParameters$1 = (parameters) => {
-    const { clientId, clientSecret, refreshToken, scope } = parameters;
-    if (!clientId) {
-        throw new Error('Missing required "clientId" parameter to perform refresh token grant');
-    }
-    if (!refreshToken) {
-        throw new Error('Missing required "refreshToken" parameter to perform refresh token grant');
-    }
-    return {
-        client_id: clientId,
-        grant_type: GRANT_TYPE$2,
-        refresh_token: refreshToken,
-        ...(clientSecret ? { client_secret: clientSecret } : {}),
-        ...(scope ? { scope } : {}),
-    };
-};
-const isEligible$2 = (parameters) => {
-    try {
-        return !!castToTokenRequestParameters$1(parameters);
-    }
-    catch {
-        return false;
-    }
-};
-const requestToken$2 = (tokenRequester, parameters) => tokenRequester(castToTokenRequestParameters$1(parameters));
-
-async function requestAndSaveToStore(requester, tokenStore) {
-    const response = await requester();
-    tokenStore.set(response);
-    return response;
-}
-
-const partial = (function_, ...partialArguments) => (...arguments_) => function_(...partialArguments, ...arguments_);
-async function until(predicate, transformer, initialValue, iterationCount = 0) {
-    const transformed = await transformer(initialValue, iterationCount);
-    return (await predicate(transformed, iterationCount))
-        ? transformed
-        : until(predicate, transformer, transformed, iterationCount + 1);
-}
-function clearIntervalFunction(intervalId) {
-    clearInterval(intervalId);
-    return true;
-}
-
-function pseudoRandomString(length = 16) {
-    let token = '';
-    while (token.length < length) {
-        token += Math.random().toString(36).slice(2);
-    }
-    return token.slice(0, Math.max(0, length));
-}
-
-async function del(request, method, body, returnRawResultObject, headers) {
-    return request('delete', method, { body, headers }, returnRawResultObject);
-}
-
-async function get(request, method, query, returnRawResultObject, headers) {
-    return request('get', method, { headers, query }, returnRawResultObject);
-}
-
-var EnumGender;
-(function (EnumGender) {
-    EnumGender["female"] = "female";
-    EnumGender["male"] = "male";
-})(EnumGender || (EnumGender = {}));
-var EnumUserType;
-(function (EnumUserType) {
-    EnumUserType["allthingsUser"] = "allthings_user";
-    EnumUserType["allthingsContent"] = "allthings_content";
-    EnumUserType["customer"] = "customer";
-    EnumUserType["demoContent"] = "demo_content";
-    EnumUserType["demoPublic"] = "demo_public";
-    EnumUserType["partner"] = "partner";
-})(EnumUserType || (EnumUserType = {}));
-var EnumCommunicationPreferenceChannel;
-(function (EnumCommunicationPreferenceChannel) {
-    EnumCommunicationPreferenceChannel["push"] = "push";
-    EnumCommunicationPreferenceChannel["email"] = "email";
-})(EnumCommunicationPreferenceChannel || (EnumCommunicationPreferenceChannel = {}));
-var EnumUserPermissionRole;
-(function (EnumUserPermissionRole) {
-    EnumUserPermissionRole["appAdmin"] = "app-admin";
-    EnumUserPermissionRole["appOwner"] = "app-owner";
-    EnumUserPermissionRole["articlesAgent"] = "articles-agent";
-    EnumUserPermissionRole["articlesViewOnly"] = "articles-view-only";
-    EnumUserPermissionRole["bookableAssetAgent"] = "bookable-asset-agent";
-    EnumUserPermissionRole["bookingAgent"] = "booking-agent";
-    EnumUserPermissionRole["cockpitManager"] = "cockpit-manager";
-    EnumUserPermissionRole["dataConnectorAdmin"] = "data-connector-admin";
-    EnumUserPermissionRole["documentAdmin"] = "doc-admin";
-    EnumUserPermissionRole["externalAgent"] = "external-agent";
-    EnumUserPermissionRole["globalOrgAdmin"] = "global-org-admin";
-    EnumUserPermissionRole["globalUserAdmin"] = "global-user-admin";
-    EnumUserPermissionRole["orgAdmin"] = "org-admin";
-    EnumUserPermissionRole["orgTeamManager"] = "org-team-manager";
-    EnumUserPermissionRole["pinboardAgent"] = "pinboard-agent";
-    EnumUserPermissionRole["platformOwner"] = "platform-owner";
-    EnumUserPermissionRole["qa"] = "qa";
-    EnumUserPermissionRole["serviceCenterAgent"] = "service-center-agent";
-    EnumUserPermissionRole["serviceCenterManager"] = "service-center-manager";
-    EnumUserPermissionRole["setup"] = "setup";
-    EnumUserPermissionRole["tenantManager"] = "tenant-manager";
-})(EnumUserPermissionRole || (EnumUserPermissionRole = {}));
-var EnumUserPermissionObjectType;
-(function (EnumUserPermissionObjectType) {
-    EnumUserPermissionObjectType["app"] = "App";
-    EnumUserPermissionObjectType["group"] = "Group";
-    EnumUserPermissionObjectType["property"] = "Property";
-    EnumUserPermissionObjectType["unit"] = "Unit";
-})(EnumUserPermissionObjectType || (EnumUserPermissionObjectType = {}));
-const remapUserResult = (user) => {
-    const { tenantIDs: tenantIds, ...result } = user;
-    return { ...result, tenantIds };
-};
-const remapEmbeddedUser = (embedded) => embedded.users ? embedded.users.map(remapUserResult) : [];
-async function userCreate(client, appId, username, data) {
-    return client.post('/v1/users', {
-        ...data,
-        creationContext: appId,
-        username,
-    });
-}
-async function getUsers(client, page = 1, limit = -1, filter = {}) {
-    const { _embedded: { items: users }, total, } = await client.get('/v1/users', {
-        filter: JSON.stringify(filter),
-        limit,
-        page,
-    });
-    return { _embedded: { items: users.map(remapUserResult) }, total };
-}
-async function getCurrentUser(client) {
-    return remapUserResult(await client.get('/v1/me'));
-}
-async function userGetById(client, userId) {
-    return remapUserResult(await client.get(`/v1/users/${userId}`));
-}
-async function userUpdateById(client, userId, data) {
-    const { tenantIds: tenantIDs, ...rest } = data;
-    return remapUserResult(await client.patch(`/v1/users/${userId}`, { ...rest, tenantIDs }));
-}
-async function userCreatePermission(client, userId, data) {
-    const { objectId: objectID, ...rest } = data;
-    const { objectID: resultObjectId, ...result } = await client.post(`/v1/users/${userId}/permissions`, {
-        ...rest,
-        objectID,
-    });
-    return {
-        ...result,
-        objectId: resultObjectId,
-    };
-}
-async function userCreatePermissionBatch(client, userId, permissions) {
-    const { objectId, objectType, roles, startDate, endDate } = permissions;
-    const batch = {
-        batch: roles.map((role) => ({
-            endDate: endDate?.toISOString(),
-            objectID: objectId,
-            objectType,
-            restrictions: [],
-            role,
-            startDate: startDate?.toISOString(),
-        })),
-    };
-    return !(await client.post(`/v1/users/${userId}/permissions`, batch));
-}
-async function userGetPermissions(client, userId) {
-    const { _embedded: { items: permissions }, } = await client.get(`/v1/users/${userId}/roles?limit=-1`);
-    return permissions.map(({ objectID: objectId, ...result }) => ({
-        ...result,
-        objectId,
-    }));
-}
-async function userDeletePermission(client, permissionId) {
-    return !(await client.delete(`/v1/permissions/${permissionId}`));
-}
-async function userGetUtilisationPeriods(client, userId) {
-    const { _embedded: { items: utilisationPeriods }, } = await client.get(`/v1/users/${userId}/utilisation-periods`);
-    return utilisationPeriods;
-}
-async function userCheckInToUtilisationPeriod(client, userId, utilisationPeriodId) {
-    const { email: userEmail } = await client.userGetById(userId);
-    return client.utilisationPeriodCheckInUser(utilisationPeriodId, {
-        email: userEmail,
-    });
-}
-async function userGetByEmail(client, email, page = 1, limit = 1000) {
-    return client.getUsers(page, limit, { email });
-}
-async function userChangePassword(client, userId, currentPassword, newPassword) {
-    return !(await client.put(`/v1/users/${userId}/password`, {
-        currentPassword,
-        plainPassword: newPassword,
-    }));
-}
-
-async function agentCreate(client, appId, propertyManagerId, username, data, sendInvitation, externalAgentCompany) {
-    const user = await client.userCreate(appId, username, {
-        ...data,
-        type: EnumUserType.customer,
-    });
-    const manager = await client.post(`/v1/property-managers/${propertyManagerId}/users`, {
-        userID: user.id,
-        ...(externalAgentCompany && { externalAgentCompany }),
-    });
-    return (!((typeof sendInvitation !== 'undefined' ? sendInvitation : true) &&
-        (await client.post(`/v1/users/${user.id}/invitations`))) && {
-        ...user,
-        ...manager,
-    });
-}
-async function agentCreatePermissions(client, agentId, objectId, objectType, permissions, startDate, endDate) {
-    return client.userCreatePermissionBatch(agentId, {
-        endDate,
-        objectId,
-        objectType,
-        restrictions: [],
-        roles: permissions,
-        startDate,
-    });
-}
-
-async function appCreate(client, userId, data) {
-    return client.post(`/v1/users/${userId}/apps`, {
-        availableLocales: { '0': 'de_DE' },
-        ...data,
-        siteUrl: data.siteUrl.replace('_', ''),
-    });
-}
-async function appGetById(client, appId) {
-    return client.get(`/v1/apps/${appId}`);
-}
-
-async function bookingGetById(client, bookingId) {
-    return client.get(`/v1/bookings/${bookingId}`);
-}
-async function bookingUpdateById(client, bookingId, data) {
-    return client.patch(`/v1/bookings/${bookingId}`, data);
-}
-
-async function bucketGet(client, bucketId) {
-    return client.get(`/v1/buckets/${bucketId}`);
-}
-async function bucketCreate(client, data) {
-    return client.post('/v1/buckets', {
-        channels: data.channels,
-        name: data.name,
-    });
-}
-async function bucketAddFile(client, bucketId, fileId) {
-    return ((await client.post(`/v1/buckets/${bucketId}/files`, {
-        id: fileId,
-    })) === '');
-}
-async function bucketRemoveFile(client, bucketId, fileId) {
-    return (await client.delete(`/v1/buckets/${bucketId}/files/${fileId}`)) === '';
-}
-async function bucketRemoveFilesInPath(client, bucketId, data) {
-    return ((await client.delete(`/v1/buckets/${bucketId}/files`, {
-        folder: data.path,
-    })) === '');
-}
-
-const createManyFiles = async (attachments, apiClient) => {
-    const responses = await Promise.all(attachments.map(async (attachment) => {
-        try {
-            const result = await apiClient.fileCreate({
-                file: attachment.content,
-                name: attachment.filename,
-            });
-            return result;
-        }
-        catch (error) {
-            return error instanceof Error ? error : new Error(String(error));
-        }
-    }));
-    return responses;
-};
-async function createManyFilesSorted(files, client) {
-    const result = await createManyFiles(files, client);
-    return {
-        error: result.filter((item) => item instanceof Error),
-        success: result
-            .filter((item) => !(item instanceof Error))
-            .map((item) => item.id),
-    };
-}
-
-async function conversationGetById(client, conversationId) {
-    return client.get(`/v1/conversations/${conversationId}`);
-}
-async function conversationCreateMessage(client, conversationId, messageData) {
-    const url = `/v1/conversations/${conversationId}/messages`;
-    const payload = messageData.attachments?.length
-        ? {
-            content: {
-                description: messageData.body,
-                files: (await createManyFilesSorted(messageData.attachments, client))
-                    .success,
-            },
-            createdBy: messageData.createdBy,
-            inputChannel: messageData.inputChannel,
-            internal: false,
-            type: 'file',
-        }
-        : {
-            content: {
-                content: messageData.body,
-            },
-            createdBy: messageData.createdBy,
-            inputChannel: messageData.inputChannel,
-            type: 'text',
-        };
-    return client.post(url, payload);
-}
-
-async function fileCreate(client, data) {
-    return client.post('/v1/files', {
-        formData: {
-            file: [data.file, data.name],
-            path: data.path || '',
-        },
-    });
-}
-async function fileDelete(client, fileId) {
-    return (await client.delete(`/v1/files/${fileId}`)) === '';
-}
-
-async function groupCreate(client, propertyId, data) {
-    const { propertyManagerId, ...rest } = data;
-    return client.post(`/v1/properties/${propertyId}/groups`, {
-        ...rest,
-        propertyManagerID: propertyManagerId,
-    });
-}
-async function groupGetById(client, groupId) {
-    const { propertyManagerID: propertyManagerId, ...result } = await client.get(`/v1/groups/${groupId}`);
-    return { ...result, propertyManagerId };
-}
-async function groupUpdateById(client, groupId, data) {
-    return client.patch(`/v1/groups/${groupId}`, data);
-}
-async function getGroups(client, page = 1, limit = -1, filter = {}) {
-    const { _embedded: { items: groups }, total, } = await client.get('/v1/groups', {
-        filter: JSON.stringify(filter),
-        limit,
-        page,
-    });
-    return { _embedded: { items: groups }, total };
-}
-
-async function lookupIds(client, appId, data) {
-    const url = data.dataSource
-        ? `/v1/id-lookup/${appId}/${data.resource}/${data.dataSource}`
-        : `/v1/id-lookup/${appId}/${data.resource}`;
-    return client.post(url, {
-        externalIds: typeof data.externalIds === 'string'
-            ? [data.externalIds]
-            : data.externalIds,
-        ...(data.parentId ? { parentId: data.parentId } : {}),
-        ...(data.userType ? { userType: data.userType } : {}),
-    });
-}
-
-function stringToDate(s) {
-    return new Date(Date.parse(s));
-}
-function dateToString(d) {
-    return d.toISOString();
-}
-
-var EnumNotificationCategory;
-(function (EnumNotificationCategory) {
-    EnumNotificationCategory["events"] = "events";
-    EnumNotificationCategory["hintsAndTips"] = "hints-and-tips";
-    EnumNotificationCategory["lostAndFound"] = "lost-and-found";
-    EnumNotificationCategory["localDeals"] = "local-deals";
-    EnumNotificationCategory["localEvents"] = "local-events";
-    EnumNotificationCategory["miscellaneous"] = "miscellaneous";
-    EnumNotificationCategory["deals"] = "deals";
-    EnumNotificationCategory["messages"] = "messages";
-    EnumNotificationCategory["adminMessages"] = "admin-messages";
-    EnumNotificationCategory["newThingsToGive"] = "new-things-to-give";
-    EnumNotificationCategory["newThingsForSale"] = "new-things-for-sale";
-    EnumNotificationCategory["surveys"] = "surveys";
-    EnumNotificationCategory["supportOffer"] = "support-offer";
-    EnumNotificationCategory["supportRequest"] = "support-request";
-    EnumNotificationCategory["sustainability"] = "sustainability";
-    EnumNotificationCategory["localServices"] = "local-services";
-    EnumNotificationCategory["services"] = "services";
-    EnumNotificationCategory["ticketDigestEmail"] = "ticket-digest-email";
-    EnumNotificationCategory["appDigestEmail"] = "app-digest-email";
-    EnumNotificationCategory["newFile"] = "new-file";
-})(EnumNotificationCategory || (EnumNotificationCategory = {}));
-var EnumNotificationType;
-(function (EnumNotificationType) {
-    EnumNotificationType["clipboardThing"] = "clipboard-thing";
-    EnumNotificationType["comment"] = "comment";
-    EnumNotificationType["communityArticle"] = "community-article";
-    EnumNotificationType["newFile"] = "new-file";
-    EnumNotificationType["ticketComment"] = "ticket-comment";
-    EnumNotificationType["welcomeNotification"] = "welcome-notification";
-})(EnumNotificationType || (EnumNotificationType = {}));
-function remapNotificationResult({ createdAt, objectID, referencedObjectID, ...restNotification }) {
-    return {
-        createdAt: stringToDate(createdAt),
-        objectId: objectID,
-        referencedObjectId: referencedObjectID,
-        ...restNotification,
-    };
-}
-async function notificationsGetByUser(client, userId, page = 1, limit = -1) {
-    const { _embedded: { items: notifications }, total, metaData, } = await client.get(`/v1/users/${userId}/notifications?page=${page}&limit=${limit}`);
-    return {
-        _embedded: { items: notifications.map(remapNotificationResult) },
-        metaData,
-        total,
-    };
-}
-async function notificationsUpdateReadByUser(client, userId, lastReadAt = new Date()) {
-    return client.patch(`/v1/users/${userId}/notifications`, {
-        lastReadAt: dateToString(lastReadAt),
-    });
-}
-async function notificationUpdateRead(client, notificationId) {
-    return remapNotificationResult(await client.patch(`/v1/notifications/${notificationId}`, { read: true }));
-}
-
-function remapKeys(input, mapFunction) {
-    return Object.entries(input).reduce((accumulator, entry) => ({
-        ...accumulator,
-        [mapFunction(entry[0])]: entry[1],
-    }), {});
-}
-
-function camelCaseToDash(input) {
-    return input.replace(/([A-Z])/g, (g) => `-${g[0].toLowerCase()}`);
-}
-function dashCaseToCamel(input) {
-    return input.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-}
-
-var EnumNotificationSettingsValue;
-(function (EnumNotificationSettingsValue) {
-    EnumNotificationSettingsValue["never"] = "never";
-    EnumNotificationSettingsValue["immediately"] = "immediately";
-    EnumNotificationSettingsValue["daily"] = "daily";
-    EnumNotificationSettingsValue["weekly"] = "weekly";
-    EnumNotificationSettingsValue["biweekly"] = "biweekly";
-    EnumNotificationSettingsValue["monthly"] = "monthly";
-})(EnumNotificationSettingsValue || (EnumNotificationSettingsValue = {}));
-async function notificationSettingsUpdateByUser(client, userId, data) {
-    const result = await client.patch(`/v1/users/${userId}/notification-settings`, { notificationSettings: remapKeys(data, camelCaseToDash) });
-    return remapKeys(result, dashCaseToCamel);
-}
-async function notificationSettingsResetByUser(client, userId) {
-    const result = await client.delete(`/v1/users/${userId}/notification-settings`);
-    return remapKeys(result, dashCaseToCamel);
-}
-
-async function propertyCreate(client, appId, data) {
-    return client.post(`/v1/apps/${appId}/properties`, data);
-}
-async function propertyGetById(client, propertyId) {
-    return client.get(`/v1/properties/${propertyId}`);
-}
-async function propertyUpdateById(client, propertyId, data) {
-    return client.patch(`/v1/properties/${propertyId}`, data);
-}
-async function getProperties(client, page = 1, limit = -1, filter = {}) {
-    const { _embedded: { items: properties }, total, } = await client.get('/v1/properties', {
-        filter: JSON.stringify(filter),
-        limit,
-        page,
-    });
-    return { _embedded: { items: properties }, total };
-}
-
-const remapRegistationCodeResult = (registrationCode) => {
-    const { tenantID: externalId, ...result } = registrationCode;
-    return { ...result, externalId };
-};
-async function registrationCodeCreate(client, code, utilisationPeriods, options = { permanent: false }) {
-    const { externalId, ...moreOptions } = options;
-    return remapRegistationCodeResult(await client.post('/v1/registration-codes', {
-        code,
-        utilisationPeriods: typeof utilisationPeriods === 'string'
-            ? [utilisationPeriods]
-            : utilisationPeriods,
-        ...(externalId ? { externalId, tenantID: externalId } : {}),
-        ...moreOptions,
-    }));
-}
-async function registrationCodeUpdateById(client, registrationCodeId, data) {
-    return remapRegistationCodeResult(await client.patch(`/v1/registration-codes/${registrationCodeId}`, data));
-}
-async function registrationCodeGetById(client, registrationCodeId) {
-    return remapRegistationCodeResult(await client.get(`/v1/invitations/${registrationCodeId}`));
-}
-async function registrationCodeDelete(client, registrationCodeId) {
-    return (await client.delete(`/v1/invitations/${registrationCodeId}`)) === '';
-}
-
-async function serviceProviderCreate(client, data) {
-    return client.post('/v1/service-providers', data);
-}
-async function serviceProviderGetById(client, serviceProviderId) {
-    return client.get(`/v1/service-providers/${serviceProviderId}`);
-}
-async function serviceProviderUpdateById(client, serviceProviderId, data) {
-    return client.patch(`/v1/service-providers/${serviceProviderId}`, data);
-}
-
-var ETicketStatus;
-(function (ETicketStatus) {
-    ETicketStatus["CLOSED"] = "closed";
-    ETicketStatus["WAITING_FOR_AGENT"] = "waiting-for-agent";
-    ETicketStatus["WAITING_FOR_CUSTOMER"] = "waiting-for-customer";
-    ETicketStatus["WAITING_FOR_EXTERNAL"] = "waiting-for-external";
-})(ETicketStatus || (ETicketStatus = {}));
-var ETrafficLightColor;
-(function (ETrafficLightColor) {
-    ETrafficLightColor["GREEN"] = "green";
-    ETrafficLightColor["RED"] = "red";
-    ETrafficLightColor["YELLOW"] = "yellow";
-})(ETrafficLightColor || (ETrafficLightColor = {}));
-async function ticketGetById(client, ticketId) {
-    return client.get(`/v1/tickets/${ticketId}`);
-}
-async function ticketCreateOnUser(client, userId, utilisationPeriodId, payload) {
-    return client.post(`/v1/users/${userId}/tickets`, {
-        ...payload,
-        files: payload.files
-            ? (await createManyFilesSorted(payload.files, client)).success
-            : [],
-        utilisationPeriod: utilisationPeriodId,
-    });
-}
-async function ticketCreateOnServiceProvider(client, serviceProviderId, payload) {
-    return client.post(`/v1/property-managers/${serviceProviderId}/tickets`, {
-        ...payload,
-        files: payload.files
-            ? (await createManyFilesSorted(payload.files, client)).success
-            : [],
-    });
-}
-
-var EnumUnitObjectType;
-(function (EnumUnitObjectType) {
-    EnumUnitObjectType["adjoiningRoom"] = "adjoining-room";
-    EnumUnitObjectType["advertisingSpace"] = "advertising-space";
-    EnumUnitObjectType["aerial"] = "aerial";
-    EnumUnitObjectType["apartmentBuilding"] = "apartment-building";
-    EnumUnitObjectType["atm"] = "atm";
-    EnumUnitObjectType["atmRoom"] = "atm-room";
-    EnumUnitObjectType["attic"] = "attic";
-    EnumUnitObjectType["atticFlat"] = "attic-flat";
-    EnumUnitObjectType["bank"] = "bank";
-    EnumUnitObjectType["basment"] = "basment";
-    EnumUnitObjectType["bikeShed"] = "bike-shed";
-    EnumUnitObjectType["buildingLaw"] = "building-law";
-    EnumUnitObjectType["cafeteria"] = "cafeteria";
-    EnumUnitObjectType["caretakerRoom"] = "caretaker-room";
-    EnumUnitObjectType["carport"] = "carport";
-    EnumUnitObjectType["cellar"] = "cellar";
-    EnumUnitObjectType["commercialProperty"] = "commercial-property";
-    EnumUnitObjectType["commonRoom"] = "common-room";
-    EnumUnitObjectType["deliveryZone"] = "delivery-zone";
-    EnumUnitObjectType["diverse"] = "diverse";
-    EnumUnitObjectType["doubleParkingSpace"] = "double-parking-space";
-    EnumUnitObjectType["engineeringRoom"] = "engineering-room";
-    EnumUnitObjectType["entertainment"] = "entertainment";
-    EnumUnitObjectType["environment"] = "environment";
-    EnumUnitObjectType["estate"] = "estate";
-    EnumUnitObjectType["fillingStation"] = "filling-station";
-    EnumUnitObjectType["fitnessCenter"] = "fitness-center";
-    EnumUnitObjectType["flat"] = "flat";
-    EnumUnitObjectType["freeZone"] = "free-zone";
-    EnumUnitObjectType["garage"] = "garage";
-    EnumUnitObjectType["garden"] = "garden";
-    EnumUnitObjectType["gardenFlat"] = "garden-flat";
-    EnumUnitObjectType["heatingFacilities"] = "heating-facilities";
-    EnumUnitObjectType["hotel"] = "hotel";
-    EnumUnitObjectType["incidentalRentalExpenses"] = "incidental-rental-expenses";
-    EnumUnitObjectType["industry"] = "industry";
-    EnumUnitObjectType["kiosk"] = "kiosk";
-    EnumUnitObjectType["kitchen"] = "kitchen";
-    EnumUnitObjectType["loft"] = "loft";
-    EnumUnitObjectType["machine"] = "machine";
-    EnumUnitObjectType["maisonette"] = "maisonette";
-    EnumUnitObjectType["medicalPractice"] = "medical-practice";
-    EnumUnitObjectType["mopedShed"] = "moped-shed";
-    EnumUnitObjectType["motorcycleParkingSpace"] = "motorcycle-parking-space";
-    EnumUnitObjectType["office"] = "office";
-    EnumUnitObjectType["oneFamilyHouse"] = "one-family-house";
-    EnumUnitObjectType["parkingBox"] = "parking-box";
-    EnumUnitObjectType["parkingGarage"] = "parking-garage";
-    EnumUnitObjectType["parkingSpace"] = "parking-space";
-    EnumUnitObjectType["parkingSpaces"] = "parking-spaces";
-    EnumUnitObjectType["penthouse"] = "penthouse";
-    EnumUnitObjectType["productionPlant"] = "production-plant";
-    EnumUnitObjectType["pub"] = "pub";
-    EnumUnitObjectType["publicArea"] = "public-area";
-    EnumUnitObjectType["restaurant"] = "restaurant";
-    EnumUnitObjectType["retirementHome"] = "retirement-home";
-    EnumUnitObjectType["salesFloor"] = "sales-floor";
-    EnumUnitObjectType["school"] = "school";
-    EnumUnitObjectType["shelter"] = "shelter";
-    EnumUnitObjectType["storage"] = "storage";
-    EnumUnitObjectType["store"] = "store";
-    EnumUnitObjectType["storeroom"] = "storeroom";
-    EnumUnitObjectType["studio"] = "studio";
-    EnumUnitObjectType["terrace"] = "terrace";
-    EnumUnitObjectType["toilets"] = "toilets";
-    EnumUnitObjectType["utilityRoom"] = "utility-room";
-    EnumUnitObjectType["variableParkingSpace"] = "variable-parking-space";
-    EnumUnitObjectType["variableRoom"] = "variable-room";
-    EnumUnitObjectType["visitorParkingSpace"] = "visitor-parking-space";
-    EnumUnitObjectType["workshop"] = "workshop";
-})(EnumUnitObjectType || (EnumUnitObjectType = {}));
-var EnumUnitType;
-(function (EnumUnitType) {
-    EnumUnitType["rented"] = "rented";
-    EnumUnitType["owned"] = "owned";
-})(EnumUnitType || (EnumUnitType = {}));
-async function unitCreate(client, groupId, data) {
-    return client.post(`/v1/groups/${groupId}/units`, data);
-}
-async function unitGetById(client, unitId) {
-    return client.get(`/v1/units/${unitId}`);
-}
-async function unitUpdateById(client, unitId, data) {
-    return client.patch(`/v1/units/${unitId}`, data);
-}
-async function getUnits(client, page = 1, limit = -1, filter = {}) {
-    const { _embedded: { items: units }, total, } = await client.get('/v1/units', {
-        filter: JSON.stringify(filter),
-        limit,
-        page,
-    });
-    return { _embedded: { items: units }, total };
-}
-
-var EnumUserRelationType;
-(function (EnumUserRelationType) {
-    EnumUserRelationType["isResponsible"] = "is-responsible";
-})(EnumUserRelationType || (EnumUserRelationType = {}));
-async function userRelationCreate(client, userId, data) {
-    return client.post(`/v1/users/${userId}/user-relations/${data.type}`, {
-        ids: data.ids,
-        level: data.level,
-        readOnly: data.readOnly,
-        role: data.role,
-    });
-}
-async function userRelationDelete(client, userId, data) {
-    return client.delete(`/v1/users/${userId}/user-relations/${data.type}`, {
-        ids: data.ids,
-        level: data.level,
-        role: data.role,
-    });
-}
-async function userRelationsGetByUser(client, userId) {
-    return client.get(`/v1/users/${userId}/user-relations`);
-}
-
-var EnumUtilisationPeriodType;
-(function (EnumUtilisationPeriodType) {
-    EnumUtilisationPeriodType["tenant"] = "tenant";
-    EnumUtilisationPeriodType["ownership"] = "ownership";
-    EnumUtilisationPeriodType["vacant"] = "vacant";
-})(EnumUtilisationPeriodType || (EnumUtilisationPeriodType = {}));
-async function utilisationPeriodCreate(client, unitId, data) {
-    const { tenantIDs: tenantIds, _embedded, ...result } = await client.post(`/v1/units/${unitId}/utilisation-periods`, data);
-    return {
-        ...result,
-        invitations: _embedded.invitations.map(remapRegistationCodeResult),
-        tenantIds,
-        users: remapEmbeddedUser(_embedded),
-    };
-}
-async function utilisationPeriodGetById(client, utilisationPeriodId) {
-    const { tenantIDs: tenantIds, _embedded, ...result } = await client.get(`/v1/utilisation-periods/${utilisationPeriodId}`);
-    return {
-        ...result,
-        invitations: _embedded.invitations.map(remapRegistationCodeResult),
-        tenantIds,
-        users: remapEmbeddedUser(_embedded),
-    };
-}
-async function utilisationPeriodUpdateById(client, utilisationPeriodId, data) {
-    const { tenantIDs: tenantIds, _embedded, ...result } = await client.patch(`/v1/utilisation-periods/${utilisationPeriodId}`, data);
-    return {
-        ...result,
-        invitations: _embedded.invitations.map(remapRegistationCodeResult),
-        tenantIds,
-        users: remapEmbeddedUser(_embedded),
-    };
-}
-async function utilisationPeriodDelete(client, utilisationPeriodId) {
-    return !(await client.delete(`/v1/utilisation-periods/${utilisationPeriodId}/soft`));
-}
-async function utilisationPeriodCheckInUser(client, utilisationPeriodId, data) {
-    return ((await client.post(`/v1/utilisation-periods/${utilisationPeriodId}/users`, {
-        email: data.email,
-    })) && client.utilisationPeriodGetById(utilisationPeriodId));
-}
-async function utilisationPeriodCheckOutUser(client, utilisationPeriodId, userId) {
-    return ((await client.delete(`/v1/utilisation-periods/${utilisationPeriodId}/users/${userId}`)) === '');
-}
-async function utilisationPeriodAddRegistrationCode(client, utilisationPeriodId, code, tenant, permanent = false) {
-    return client.post(`/v1/utilisation-periods/${utilisationPeriodId}/registration-codes`, { code, permanent, tenant });
-}
-
-async function patch(request, method, body, returnRawResultObject, headers) {
-    return request('patch', method, { body, headers }, returnRawResultObject);
-}
-
-async function post(request, method, body, returnRawResultObject, headers) {
-    return request('post', method, { body, headers }, returnRawResultObject);
-}
-
-async function put(request, method, body, returnRawResultObject, headers) {
-    return request('put', method, { body, headers }, returnRawResultObject);
-}
-
-const GRANT_TYPE$1 = 'client_credentials';
-const castClientOptionsToRequestParameters = (clientOptions) => {
-    const { scope, clientId, clientSecret } = clientOptions;
-    if (!clientId) {
-        throw new Error('Missing required "clientId" parameter to perform client credentials grant');
-    }
-    if (!clientSecret) {
-        throw new Error('Missing required "clientSecret" parameter to perform client credentials grant');
-    }
-    return {
-        client_id: clientId,
-        client_secret: clientSecret,
-        grant_type: GRANT_TYPE$1,
-        ...(scope ? { scope } : {}),
-    };
-};
-const isEligible$1 = (clientOptions) => {
-    try {
-        return !!castClientOptionsToRequestParameters(clientOptions);
-    }
-    catch {
-        return false;
-    }
-};
-const requestToken$1 = (oauthTokenRequest, clientOptions) => oauthTokenRequest(castClientOptionsToRequestParameters(clientOptions));
-
-const RESPONSE_TYPE = 'token';
-const castToAuthorizationRequestParameters = (parameters) => {
-    const { clientId, scope, state, redirectUri } = parameters;
-    if (!clientId) {
-        throw new Error('Missing required "clientId" parameter to perform implicit grant');
-    }
-    return {
-        client_id: clientId,
-        redirect_uri: redirectUri || window.location.href,
-        response_type: RESPONSE_TYPE,
-        ...(scope ? { scope } : {}),
-        ...(state ? { state } : {}),
-    };
-};
-const isEligibleForClientRedirect = (parameters) => {
-    try {
-        return !!castToAuthorizationRequestParameters(parameters);
-    }
-    catch {
-        return false;
-    }
-};
-const getRedirectUrl = (parameters) => `${parameters.oauthUrl}/oauth/authorize?${buildQueryString(castToAuthorizationRequestParameters(parameters))}`;
-
-const GRANT_TYPE = 'password';
-const castToTokenRequestParameters = (parameters) => {
-    const { username, password, scope, clientId, clientSecret } = parameters;
-    if (!clientId) {
-        throw new Error('Missing required "clientId" parameter to perform password grant');
-    }
-    if (!username) {
-        throw new Error('Missing required "username" parameter to perform password grant');
-    }
-    if (!password) {
-        throw new Error('Missing required "password" parameter to perform password grant');
-    }
-    return {
-        client_id: clientId,
-        grant_type: GRANT_TYPE,
-        password,
-        username,
-        ...(scope ? { scope } : {}),
-        ...(clientSecret ? { client_secret: clientSecret } : {}),
-    };
-};
-const isEligible = (parameters) => {
-    try {
-        return !!castToTokenRequestParameters(parameters);
-    }
-    catch {
-        return false;
-    }
-};
-const requestToken = (tokenRequester, parameters) => tokenRequester(castToTokenRequestParameters(parameters));
-
-async function maybeUpdateToken(oauthTokenStore, tokenFetcher, options, mustRefresh = false) {
-    if (!mustRefresh && oauthTokenStore.get('accessToken')) {
-        return;
-    }
-    const refreshOptions = {
-        ...options,
-        refreshToken: oauthTokenStore.get('refreshToken'),
-    };
-    if (isEligible$2(refreshOptions)) {
-        return oauthTokenStore.set(await requestToken$2(tokenFetcher, refreshOptions));
-    }
-    if (isEligible(options)) {
-        return oauthTokenStore.set(await requestToken(tokenFetcher, options));
-    }
-    if (typeof window !== 'undefined' && options.implicit) {
-        const parsedLocationHash = parseQueryString(window.location.hash);
-        const accessToken = parsedLocationHash.access_token;
-        if (accessToken) {
-            window.history.replaceState({}, '', window.location.href.split('#')[0]);
-            return oauthTokenStore.set({ accessToken });
-        }
-        if (isEligibleForClientRedirect(options)) {
-            window.location.href = getRedirectUrl(options);
-            return;
-        }
-    }
-    if (!mustRefresh && isEligible$3(options)) {
-        return oauthTokenStore.set(await requestToken$3(tokenFetcher, options));
-    }
-    if (options.authorizationRedirect &&
-        isEligibleForClientRedirect$1(options)) {
-        return options.authorizationRedirect(getRedirectUrl$1(options));
-    }
-    if (isEligible$1(options)) {
-        return oauthTokenStore.set(await requestToken$1(tokenFetcher, options));
-    }
-    return;
-}
-
-function sleep(milliseconds) {
-    return new Promise((resolve) => setTimeout(() => resolve(true), milliseconds));
-}
-
-const requestLogger = makeLogger('REST API Request');
-const responseLogger = makeLogger('REST API Response');
-const RETRYABLE_STATUS_CODES = [401, 408, 429, 502, 503, 504];
-const TOKEN_REFRESH_STATUS_CODES = [401];
-const queue = new Bottleneck({
-    maxConcurrent: QUEUE_CONCURRENCY,
-    minTime: QUEUE_DELAY,
-    reservoir: QUEUE_RESERVOIR,
-});
-const refillIntervalSet = new Set();
-function isFormData(body) {
-    return typeof body !== 'undefined' && body.formData !== undefined;
-}
-function refillReservoir() {
-    if (refillIntervalSet.size === 0) {
-        const interval = setInterval(async () => {
-            const reservoir = (await queue.currentReservoir());
-            if (queue.empty() && (await queue.running()) === 0 && reservoir > 10) {
-                return ((await queue.incrementReservoir(1)) &&
-                    clearIntervalFunction(interval) &&
-                    refillIntervalSet.delete(interval));
-            }
-            return reservoir < QUEUE_RESERVOIR
-                ? queue.incrementReservoir(1)
-                : clearIntervalFunction(interval) && refillIntervalSet.delete(interval);
-        }, QUEUE_RESERVOIR_REFILL_INTERVAL);
-        return refillIntervalSet.add(interval);
-    }
-    return refillIntervalSet;
-}
-async function makeResultFromResponse(response) {
-    if (RETRYABLE_STATUS_CODES.includes(response.status)) {
-        return response.clone();
-    }
-    if (!response.ok) {
-        return new Error(`${response.status} ${response.statusText}\n\n${await response.text()}`);
-    }
-    if (response.headers.get('content-type') !== 'application/json' &&
-        response.status !== 204) {
-        return new Error(`Response content type was "${response.headers.get('content-type')}" but expected JSON`);
-    }
-    return {
-        body: response.status === 204 ? '' : await response.json(),
-        status: response.status,
-    };
-}
-function responseWasSuccessful(response) {
-    return !RETRYABLE_STATUS_CODES.includes(response.status);
-}
-function makeApiRequest(oauthTokenStore, oauthTokenRequester, options, httpMethod, apiMethod, payload, returnRawResultObject) {
-    return async (previousResult, retryCount) => {
-        if (retryCount > 0) {
-            if (retryCount > options.requestMaxRetries) {
-                const error = `Maximum number of retries reached while retrying ${previousResult.method} request ${previousResult.path}.`;
-                requestLogger.error(error);
-                throw new Error(error);
-            }
-            requestLogger.warn(`Warning: encountered ${previousResult.status}. Retrying ${previousResult.method} request ${previousResult.path} (retry #${retryCount}).`);
-            await sleep(Math.ceil(Math.random() *
-                options.requestBackOffInterval *
-                2 ** retryCount));
-        }
-        await maybeUpdateToken(oauthTokenStore, oauthTokenRequester, options, retryCount > 0 &&
-            TOKEN_REFRESH_STATUS_CODES.includes(previousResult.status));
-        const payloadQuery = payload?.query
-            ? (apiMethod.includes('?') ? '&' : '?') + buildQueryString(payload.query)
-            : '';
-        const url = `${options.apiUrl}/api${apiMethod}${payloadQuery}`;
-        if (!oauthTokenStore.get('accessToken')) {
-            throw new Error(`Unable to get OAuth2 access token. Error trying to call endpoint: ${url}`);
-        }
-        try {
-            return (refillReservoir() &&
-                (await queue.schedule(async () => {
-                    const method = httpMethod.toUpperCase();
-                    const body = payload?.body;
-                    const hasForm = isFormData(body);
-                    const form = isFormData(body) ? body.formData : {};
-                    const formData = Object.entries(form).reduce((previous, [name, value]) => {
-                        if (Array.isArray(value)) {
-                            const [content, filename] = value;
-                            const blobContent = content instanceof Blob ? content : new Blob([content]);
-                            previous.append(name, blobContent, filename);
-                        }
-                        else {
-                            previous.append(name, value);
-                        }
-                        return previous;
-                    }, new FormData());
-                    const headers = {
-                        accept: 'application/json',
-                        authorization: `Bearer ${oauthTokenStore.get('accessToken')}`,
-                        'X-Allthings-Caller': `${options.serviceName
-                            ? options.serviceName
-                            :
-                                environment.SEVICE_NAME
-                                    ? environment.SEVICE_NAME
-                                    : 'unknown service name'} --- clientID ${options.clientId?.split('_')[0] ??
-                            options.clientId ??
-                            'no client id present'}`,
-                        ...(hasForm ? {} : { 'content-type': 'application/json' }),
-                        ...(typeof window === 'undefined' &&
-                            typeof document === 'undefined' && { 'user-agent': USER_AGENT }),
-                        ...payload?.headers,
-                    };
-                    if (environment.LOG_REQUEST) {
-                        console.log({ sdkLogs: { method, url } });
-                    }
-                    requestLogger.log(method, url, {
-                        body,
-                        headers,
-                    });
-                    const requestBody = {
-                        body: hasForm ? formData : JSON.stringify(body),
-                    };
-                    const response = await fetch(url, {
-                        cache: 'no-cache',
-                        credentials: 'omit',
-                        headers,
-                        method,
-                        mode: 'cors',
-                        ...(hasForm || body ? requestBody : {}),
-                    });
-                    const result = await makeResultFromResponse(response);
-                    responseLogger.log(method, url, result instanceof Error
-                        ? { error: result }
-                        : {
-                            body: result.body,
-                            status: response.status,
-                        });
-                    return result instanceof Error && returnRawResultObject
-                        ? {
-                            body: result.message,
-                            status: response.status,
-                        }
-                        : result;
-                })));
-        }
-        catch (error) {
-            return error;
-        }
-    };
-}
-async function request(oauthTokenStore, oauthTokenRequester, options, httpMethod, apiMethod, payload, returnRawResultObject) {
-    const result = await until(responseWasSuccessful, makeApiRequest(oauthTokenStore, oauthTokenRequester, options, httpMethod, apiMethod, payload, returnRawResultObject));
-    if (result instanceof Error) {
-        requestLogger.log('Request Error', result, payload);
-        throw result;
-    }
-    return returnRawResultObject ? result : result.body;
-}
-
-const API_METHODS = [
-    agentCreate,
-    agentCreatePermissions,
-    appCreate,
-    appGetById,
-    bucketCreate,
-    bucketAddFile,
-    bucketRemoveFile,
-    bucketRemoveFilesInPath,
-    bucketGet,
-    conversationGetById,
-    conversationCreateMessage,
-    fileCreate,
-    fileDelete,
-    notificationSettingsResetByUser,
-    notificationSettingsUpdateByUser,
-    groupCreate,
-    groupGetById,
-    groupUpdateById,
-    getGroups,
-    lookupIds,
-    notificationsGetByUser,
-    notificationUpdateRead,
-    notificationsUpdateReadByUser,
-    propertyCreate,
-    propertyGetById,
-    propertyUpdateById,
-    getProperties,
-    serviceProviderCreate,
-    serviceProviderGetById,
-    serviceProviderUpdateById,
-    registrationCodeCreate,
-    registrationCodeUpdateById,
-    registrationCodeDelete,
-    registrationCodeGetById,
-    ticketCreateOnUser,
-    ticketCreateOnServiceProvider,
-    ticketGetById,
-    unitCreate,
-    unitGetById,
-    unitUpdateById,
-    getUnits,
-    userCreate,
-    userGetById,
-    userUpdateById,
-    userChangePassword,
-    userCreatePermission,
-    userCreatePermissionBatch,
-    userGetPermissions,
-    userDeletePermission,
-    userCheckInToUtilisationPeriod,
-    userGetUtilisationPeriods,
-    userGetByEmail,
-    getCurrentUser,
-    getUsers,
-    userRelationCreate,
-    userRelationDelete,
-    userRelationsGetByUser,
-    utilisationPeriodCreate,
-    utilisationPeriodDelete,
-    utilisationPeriodGetById,
-    utilisationPeriodUpdateById,
-    utilisationPeriodCheckInUser,
-    utilisationPeriodCheckOutUser,
-    utilisationPeriodAddRegistrationCode,
-    bookingUpdateById,
-    bookingGetById,
-];
-function restClient(userOptions = DEFAULT_API_WRAPPER_OPTIONS) {
-    const options = {
-        ...DEFAULT_API_WRAPPER_OPTIONS,
-        ...userOptions,
-    };
-    if (options.apiUrl === undefined) {
-        throw new Error('API URL is undefined.');
-    }
-    if (options.oauthUrl === undefined) {
-        throw new Error('OAuth2 URL is undefined.');
-    }
-    if (!options.clientId &&
-        !(options.accessToken || options.tokenStore) &&
-        typeof window === 'undefined') {
-        throw new Error('Missing required "clientId" or "accessToken" parameter .');
-    }
-    const tokenRequester = makeFetchTokenRequester(`${options.oauthUrl}/oauth/token`);
-    const tokenStore = options.tokenStore ||
-        createTokenStore({
-            accessToken: options.accessToken,
-            refreshToken: options.refreshToken,
-        });
-    const request$1 = partial(request, tokenStore, tokenRequester, options);
-    const del$1 = partial(del, request$1);
-    const get$1 = partial(get, request$1);
-    const post$1 = partial(post, request$1);
-    const patch$1 = partial(patch, request$1);
-    const put$1 = partial(put, request$1);
-    const oauth = {
-        authorizationCode: {
-            getUri: (state = options.state || pseudoRandomString()) => partial(getRedirectUrl$1, {
-                ...options,
-                state,
-            })(),
-            requestToken: (authorizationCode) => requestAndSaveToStore(partial(requestToken$3, tokenRequester, {
-                ...options,
-                authorizationCode: authorizationCode || options.authorizationCode,
-            }), tokenStore),
-        },
-        generateState: pseudoRandomString,
-        refreshToken: (refreshToken) => requestAndSaveToStore(partial(requestToken$2, tokenRequester, {
-            ...options,
-            refreshToken: refreshToken || tokenStore.get('refreshToken'),
-        }), tokenStore),
-    };
-    const client = API_METHODS.reduce((methods, method) => ({
-        ...methods,
-        [method.name]: (...arguments_) => method(client, ...arguments_),
-    }), {
-        delete: del$1,
-        get: get$1,
-        oauth,
-        options,
-        patch: patch$1,
-        post: post$1,
-        put: put$1,
-    });
-    return client;
-}
-
-var EnumResource;
-(function (EnumResource) {
-    EnumResource["group"] = "group";
-    EnumResource["property"] = "property";
-    EnumResource["serviceProvider"] = "propertyManager";
-    EnumResource["registrationCode"] = "registrationCode";
-    EnumResource["unit"] = "unit";
-    EnumResource["user"] = "user";
-    EnumResource["utilisationPeriod"] = "utilisationPeriod";
-})(EnumResource || (EnumResource = {}));
-var EnumCountryCode;
-(function (EnumCountryCode) {
-    EnumCountryCode["CH"] = "CH";
-    EnumCountryCode["DE"] = "DE";
-    EnumCountryCode["FR"] = "FR";
-    EnumCountryCode["IT"] = "IT";
-    EnumCountryCode["NL"] = "NL";
-    EnumCountryCode["PT"] = "PT";
-    EnumCountryCode["US"] = "US";
-})(EnumCountryCode || (EnumCountryCode = {}));
-var EnumLocale;
-(function (EnumLocale) {
-    EnumLocale["ch_de"] = "ch_DE";
-    EnumLocale["ch_fr"] = "ch_FR";
-    EnumLocale["ch_it"] = "ch_it";
-    EnumLocale["de_DE"] = "de_DE";
-    EnumLocale["it_IT"] = "it_IT";
-    EnumLocale["fr_FR"] = "fr_FR";
-    EnumLocale["pt_PT"] = "pt_PT";
-    EnumLocale["en_US"] = "en_US";
-})(EnumLocale || (EnumLocale = {}));
-var EnumTimezone;
-(function (EnumTimezone) {
-    EnumTimezone["EuropeBerlin"] = "Europe/Berlin";
-    EnumTimezone["EuropeLondon"] = "Europe/London";
-    EnumTimezone["EuropeSofia"] = "Europe/Sofia";
-    EnumTimezone["EuropeZurich"] = "Europe/Zurich";
-    EnumTimezone["UTC"] = "UTC";
-})(EnumTimezone || (EnumTimezone = {}));
-var EnumServiceProviderType;
-(function (EnumServiceProviderType) {
-    EnumServiceProviderType["propertyManager"] = "property-manager";
-    EnumServiceProviderType["craftspeople"] = "craftspeople";
-})(EnumServiceProviderType || (EnumServiceProviderType = {}));
-var EnumCommunicationMethodType;
-(function (EnumCommunicationMethodType) {
-    EnumCommunicationMethodType["email"] = "email";
-})(EnumCommunicationMethodType || (EnumCommunicationMethodType = {}));
-var EnumInputChannel;
-(function (EnumInputChannel) {
-    EnumInputChannel["APP"] = "app";
-    EnumInputChannel["COCKPIT"] = "cockpit";
-    EnumInputChannel["CRAFTSMEN"] = "craftsmen";
-    EnumInputChannel["EMAIL"] = "email";
-    EnumInputChannel["PHONE"] = "phone";
-    EnumInputChannel["WHATS_APP"] = "whats_app";
-})(EnumInputChannel || (EnumInputChannel = {}));
-var EnumLookupUserType;
-(function (EnumLookupUserType) {
-    EnumLookupUserType["agent"] = "agent";
-    EnumLookupUserType["tenant"] = "tenant";
-})(EnumLookupUserType || (EnumLookupUserType = {}));
-
-export { EnumCommunicationMethodType, EnumCommunicationPreferenceChannel, EnumCountryCode, EnumInputChannel, EnumLocale, EnumLookupUserType, EnumResource, EnumServiceProviderType, EnumTimezone, EnumUnitObjectType, EnumUnitType, EnumUserPermissionObjectType, EnumUserPermissionRole, EnumUserRelationType, EnumUtilisationPeriodType, buildQueryString, createTokenStore, parseQueryString, restClient };