@allthings/sdk 6.0.0 → 6.2.0-1

package/dist/src/aws/index.d.ts

@@ -0,0 +1,11 @@
+import { DEFAULT_CLIENT_CONFIG as DEFAULT_PARAMETER_STORE_CLIENT_CONFIG, IParameterStore } from './parameterStore';
+declare const DEFAULT_AWS_CONFIGURATION: {
+    region: string;
+};
+export { DEFAULT_AWS_CONFIGURATION, DEFAULT_PARAMETER_STORE_CLIENT_CONFIG, IParameterStore, };
+declare const _default: {
+    parameterStore: (userConfig: IParameterStore) => {
+        getSecret: (param: string) => Promise<string>;
+    };
+};
+export default _default;

package/dist/src/aws/parameterStore.d.ts

@@ -0,0 +1,13 @@
+import { SSMClientConfig } from '@aws-sdk/client-ssm';
+export interface IParameterStore {
+    clientConfig?: SSMClientConfig;
+    defaultValue?: string;
+    logger?: (message: string) => void;
+    onlyDefault?: boolean;
+    prefix?: string;
+}
+export declare const DEFAULT_CLIENT_CONFIG: IParameterStore;
+declare const parameterStore: (userConfig: IParameterStore) => {
+    getSecret: (param: string) => Promise<string>;
+};
+export default parameterStore;

package/dist/src/index.d.ts

@@ -1,8 +1,8 @@
-export { default as restClient, EnumCommunicationPreferenceChannel, EnumUserPermissionRole, EnumUnitObjectType, EnumUnitType, EnumUserPermissionObjectType, EnumUserRelationType, EnumUtilisationPeriodType, } from './rest';
-export { EnumCountryCode, EnumLocale, EnumLookupUserType, EnumResource, EnumServiceProviderType, EnumTimezone, EnumCommunicationMethodType, EnumInputChannel, IAllthingsRestClient, IAllthingsRestClientOptions, } from './rest/types';
-export { IUser } from './rest/methods/user';
-export { ITicket } from './rest/methods/ticket';
+export { default as createTokenStore } from './oauth/createTokenStore';
+export { EnumCommunicationPreferenceChannel, EnumUnitObjectType, EnumUnitType, EnumUserPermissionObjectType, EnumUserPermissionRole, EnumUserRelationType, EnumUtilisationPeriodType, default as restClient, } from './rest';
 export { IApp } from './rest/methods/app';
 export { IProperty } from './rest/methods/property';
+export { ITicket } from './rest/methods/ticket';
+export { IUser } from './rest/methods/user';
 export { IUtilisationPeriod } from './rest/methods/utilisationPeriod';
-export { default as createTokenStore } from './oauth/createTokenStore';
+export { EnumCommunicationMethodType, EnumCountryCode, EnumInputChannel, EnumLocale, EnumLookupUserType, EnumResource, EnumServiceProviderType, EnumTimezone, IAllthingsRestClient, IAllthingsRestClientOptions, } from './rest/types';

package/dist/src/oauth/types.d.ts

@@ -4,8 +4,8 @@ export interface IOAuthToken {
     readonly refreshToken?: string;
 }
 export interface ITokenStore {
-    readonly set: (token: IOAuthToken) => void;
     readonly get: (key: keyof IOAuthToken) => string | undefined;
     readonly reset: () => void;
+    readonly set: (token: IOAuthToken) => void;
 }
 export type TokenRequester = (params: Record<string, any>) => Promise<IOAuthToken>;

package/dist/src/rest/index.d.ts

@@ -3,5 +3,5 @@ import { EnumCommunicationPreferenceChannel, EnumUserPermissionObjectType, EnumU
 import { EnumUserRelationType } from './methods/userRelation';
 import { EnumUtilisationPeriodType } from './methods/utilisationPeriod';
 import { IAllthingsRestClient, IAllthingsRestClientOptions } from './types';
-export { EnumCommunicationPreferenceChannel, EnumUserPermissionRole, EnumUnitObjectType, EnumUnitType, EnumUserPermissionObjectType, EnumUserRelationType, EnumUtilisationPeriodType, };
+export { EnumCommunicationPreferenceChannel, EnumUnitObjectType, EnumUnitType, EnumUserPermissionObjectType, EnumUserPermissionRole, EnumUserRelationType, EnumUtilisationPeriodType, };
 export default function restClient(userOptions?: Partial<IAllthingsRestClientOptions>): IAllthingsRestClient;

package/dist/src/rest/methods/agent.d.ts

@@ -1,6 +1,6 @@
 import { EnumLocale, IAllthingsRestClient } from '../types';
 import { EnumUserPermissionObjectType, EnumUserPermissionRole, IUserPermission, PartialUser, UserResult } from './user';
-export type AgentPermissionsResult = Promise<ReadonlyArray<IUserPermission>>;
+export type AgentPermissionsResult = Promise<readonly IUserPermission[]>;
 export type MethodAgentCreate = (appId: string, propertyManagerId: string, username: string, data: PartialUser & {
     readonly email: string;
     readonly locale: EnumLocale;
@@ -9,5 +9,5 @@ export declare function agentCreate(client: IAllthingsRestClient, appId: string,
     readonly email: string;
     readonly locale: EnumLocale;
 }, sendInvitation?: boolean, externalAgentCompany?: string): UserResult;
-export type MethodAgentCreatePermissions = (agentId: string, objectId: string, objectType: EnumUserPermissionObjectType, permissions: ReadonlyArray<EnumUserPermissionRole>, startDate?: Date, endDate?: Date) => Promise<boolean>;
-export declare function agentCreatePermissions(client: IAllthingsRestClient, agentId: string, objectId: string, objectType: EnumUserPermissionObjectType, permissions: ReadonlyArray<EnumUserPermissionRole>, startDate?: Date, endDate?: Date): Promise<boolean>;
+export type MethodAgentCreatePermissions = (agentId: string, objectId: string, objectType: EnumUserPermissionObjectType, permissions: readonly EnumUserPermissionRole[], startDate?: Date, endDate?: Date) => Promise<boolean>;
+export declare function agentCreatePermissions(client: IAllthingsRestClient, agentId: string, objectId: string, objectType: EnumUserPermissionObjectType, permissions: readonly EnumUserPermissionRole[], startDate?: Date, endDate?: Date): Promise<boolean>;

package/dist/src/rest/methods/app.d.ts

@@ -1,23 +1,23 @@
 import { IAllthingsRestClient } from '../types';
 export interface IApp {
+    readonly emailToTicketEnabled: boolean;
+    readonly emailToTicketForwardingEnabled: boolean;
     readonly id: string;
     readonly name: string;
     readonly siteUrl: string;
-    readonly emailToTicketEnabled: boolean;
-    readonly emailToTicketForwardingEnabled: boolean;
 }
 export type PartialApp = Partial<IApp>;
 export type AppResult = Promise<IApp>;
 export type CreateAppResult = Promise<IApp>;
 export type MethodAppCreate = (userId: string, data: PartialApp & {
     readonly name: string;
-    readonly siteUrl: string;
     readonly notificationsEmailAddress: string;
+    readonly siteUrl: string;
 }) => CreateAppResult;
 export declare function appCreate(client: IAllthingsRestClient, userId: string, data: PartialApp & {
     readonly name: string;
-    readonly siteUrl: string;
     readonly notificationsEmailAddress: string;
+    readonly siteUrl: string;
 }): CreateAppResult;
 export type MethodAppGetById = (appId: string) => AppResult;
 export declare function appGetById(client: IAllthingsRestClient, appId: string): AppResult;

package/dist/src/rest/methods/bucket.d.ts

@@ -1,19 +1,19 @@
 import { IAllthingsRestClient } from '../types';
 export type BucketResult = Promise<IBucket>;
 export interface IBucket {
+    readonly channels: readonly string[];
+    readonly files: readonly string[];
     readonly id: string;
-    readonly channels: ReadonlyArray<string>;
-    readonly files: ReadonlyArray<string>;
     readonly name: string;
 }
 export type MethodBucketGet = (bucketId: string) => BucketResult;
 export declare function bucketGet(client: IAllthingsRestClient, bucketId: string): BucketResult;
 export type MethodBucketCreate = (data: {
-    readonly channels: ReadonlyArray<string>;
+    readonly channels: readonly string[];
     readonly name: string;
 }) => BucketResult;
 export declare function bucketCreate(client: IAllthingsRestClient, data: {
-    readonly channels: ReadonlyArray<string>;
+    readonly channels: readonly string[];
     readonly name: string;
 }): BucketResult;
 export type MethodBucketAddFile = (bucketId: string, fileId: string) => Promise<boolean>;

package/dist/src/rest/methods/conversation.d.ts

@@ -1,14 +1,16 @@
 /// <reference types="node" />
 import { EnumCommunicationMethodType, EnumInputChannel, IAllthingsRestClient } from '../types';
 export interface IConversation {
-    readonly id: string;
     readonly createdAt: string;
+    readonly id: string;
 }
 export interface IMessage {
+    readonly _embedded?: any;
+    readonly _links?: any;
     readonly content: {
         readonly content?: string;
         readonly description?: string;
-        readonly files?: ReadonlyArray<string>;
+        readonly files?: readonly string[];
     };
     readonly createdAt: string;
     readonly id: string;
@@ -16,14 +18,12 @@ export interface IMessage {
     readonly internal: boolean;
     readonly read: boolean;
     readonly type: string;
-    readonly _embedded?: any;
-    readonly _links?: any;
 }
 export interface IMessagePayload {
-    readonly attachments?: ReadonlyArray<{
+    readonly attachments?: readonly {
         readonly content: Buffer;
         readonly filename: string;
-    }>;
+    }[];
     readonly body: string;
     readonly createdBy: {
         readonly type: EnumCommunicationMethodType;

package/dist/src/rest/methods/file.d.ts

@@ -2,29 +2,29 @@
 import { IAllthingsRestClient } from '../types';
 export type FileResult = Promise<IFile>;
 interface IFileUrl {
-    readonly url: string;
+    readonly height: number;
     readonly size: number;
+    readonly url: string;
     readonly width: number;
-    readonly height: number;
 }
 export interface IFile {
-    readonly id: string;
-    readonly name: string;
-    readonly type: string;
-    readonly size: number;
-    readonly description: string;
-    readonly originalFilename: string;
-    readonly extension: string;
     readonly category: string;
-    readonly path: string;
     readonly deletedAt: string;
+    readonly description: string;
+    readonly extension: string;
     readonly files: {
-        readonly original: IFileUrl;
         readonly big: IFileUrl;
         readonly medium: IFileUrl;
+        readonly original: IFileUrl;
         readonly small: IFileUrl;
         readonly thumb: IFileUrl;
     };
+    readonly id: string;
+    readonly name: string;
+    readonly originalFilename: string;
+    readonly path: string;
+    readonly size: number;
+    readonly type: string;
 }
 export type MethodFileCreate = (data: {
     readonly file: Blob | Buffer | ReadableStream;

package/dist/src/rest/methods/group.d.ts

@@ -20,11 +20,11 @@ export interface IGroup {
     readonly propertyOwner: string;
     readonly readOnly: boolean;
     readonly stats: {
-        readonly tenantCount: number | null;
+        readonly inhabitedUnits: number | null;
         readonly invitationCount: number | null;
         readonly occupancy: number | null;
+        readonly tenantCount: number | null;
         readonly unitCount: number | null;
-        readonly inhabitedUnits: number | null;
     };
 }
 export type PartialGroup = Partial<IGroup>;

package/dist/src/rest/methods/idLookup.d.ts

@@ -3,14 +3,14 @@ export type LookupIdResult = Promise<{
     readonly [externalId: string]: string | null;
 }>;
 export type MethodLookupIds = (appId: string, data: {
-    readonly resource: EnumResource;
-    readonly externalIds: string | ReadonlyArray<string>;
+    readonly externalIds: string | readonly string[];
     readonly parentId?: string;
+    readonly resource: EnumResource;
     readonly userType?: EnumLookupUserType;
 }) => LookupIdResult;
 export declare function lookupIds(client: IAllthingsRestClient, appId: string, data: {
-    readonly resource: EnumResource;
-    readonly externalIds: string | ReadonlyArray<string>;
+    readonly externalIds: string | readonly string[];
     readonly parentId?: string;
+    readonly resource: EnumResource;
     readonly userType?: EnumLookupUserType;
 }): LookupIdResult;

package/dist/src/rest/methods/registrationCode.d.ts

@@ -1,15 +1,15 @@
 import { IAllthingsRestClient } from '../types';
 export interface IRegistrationCodeTenant {
     readonly email?: string;
-    readonly phone?: string;
     readonly name?: string;
+    readonly phone?: string;
 }
 export interface IRegistrationCodeOptions {
     readonly externalId?: string;
+    readonly instantTenantInviteActive?: boolean;
     readonly permanent?: boolean;
-    readonly tenant?: IRegistrationCodeTenant;
     readonly readOnly?: boolean;
-    readonly instantTenantInviteActive?: boolean;
+    readonly tenant?: IRegistrationCodeTenant;
 }
 export interface IRegistrationCode extends Required<IRegistrationCodeOptions> {
     readonly code: string;
@@ -18,13 +18,13 @@ export interface IRegistrationCode extends Required<IRegistrationCodeOptions> {
     readonly externalId: string;
     readonly id: string;
     readonly invitationSent: boolean;
-    readonly utilisationPeriods: ReadonlyArray<string>;
+    readonly utilisationPeriods: readonly string[];
 }
 export type PartialRegistrationCode = Partial<IRegistrationCode>;
 export type RegistrationCodeResult = Promise<IRegistrationCode>;
 export declare const remapRegistationCodeResult: (registrationCode: any) => any;
-export type MethodRegistrationCodeCreate = (code: string, utilisationPeriods: string | ReadonlyArray<string>, options?: IRegistrationCodeOptions) => RegistrationCodeResult;
-export declare function registrationCodeCreate(client: IAllthingsRestClient, code: string, utilisationPeriods: string | ReadonlyArray<string>, options?: IRegistrationCodeOptions): RegistrationCodeResult;
+export type MethodRegistrationCodeCreate = (code: string, utilisationPeriods: string | readonly string[], options?: IRegistrationCodeOptions) => RegistrationCodeResult;
+export declare function registrationCodeCreate(client: IAllthingsRestClient, code: string, utilisationPeriods: string | readonly string[], options?: IRegistrationCodeOptions): RegistrationCodeResult;
 export type MethodRegistrationCodeUpdateById = (registrationCodeId: string, data: PartialRegistrationCode) => RegistrationCodeResult;
 export declare function registrationCodeUpdateById(client: IAllthingsRestClient, registrationCodeId: string, data: PartialRegistrationCode): RegistrationCodeResult;
 export type MethodRegistrationCodeGetById = (registrationCodeId: string) => RegistrationCodeResult;

package/dist/src/rest/methods/ticket.d.ts

@@ -25,24 +25,24 @@ export interface ICustomSettingsItem {
     readonly value: string;
 }
 export interface ITicketCreatePayload {
-    readonly files?: ReadonlyArray<{
-        readonly content: Buffer;
-        readonly filename: string;
-    }>;
     readonly category: string;
     readonly channel?: string;
     readonly createdByCommunicationMethod?: {
         readonly type: string;
         readonly value: string;
     };
+    readonly customSettings?: readonly ICustomSettingsItem[];
     readonly description: string;
+    readonly files?: readonly {
+        readonly content: Buffer;
+        readonly filename: string;
+    }[];
     readonly inputChannel: string;
-    readonly title: string;
     readonly phoneNumber?: string;
-    readonly customSettings?: ReadonlyArray<ICustomSettingsItem>;
+    readonly title: string;
 }
 interface ITicketParticipant extends IUser {
-    readonly roles: ReadonlyArray<string>;
+    readonly roles: readonly string[];
 }
 export interface ITicket {
     readonly _embedded: {
@@ -51,18 +51,18 @@ export interface ITicket {
             readonly id: string;
             readonly name: IMessage;
         };
-        readonly conversations: ReadonlyArray<{
-            readonly id: string;
+        readonly conversations: readonly {
             readonly _embedded: {
-                readonly participants: ReadonlyArray<ITicketParticipant>;
+                readonly participants: readonly ITicketParticipant[];
             };
-        }>;
+            readonly id: string;
+        }[];
         readonly createdBy: IUser;
-        readonly files: ReadonlyArray<IFile>;
+        readonly files: readonly IFile[];
         readonly group: {
             readonly address: object;
         };
-        readonly labels: ReadonlyArray<ITicketLabel>;
+        readonly labels: readonly ITicketLabel[];
         readonly property: {
             readonly id: string;
             readonly name: string;
@@ -72,24 +72,24 @@ export interface ITicket {
         };
     };
     readonly category: string;
-    readonly channels: ReadonlyArray<string>;
+    readonly channels: readonly string[];
     readonly commentCount: number;
     readonly createdAt: string;
+    readonly customSettings?: readonly ICustomSettingsItem[];
     readonly customerWaitingSinceIndicator: ETrafficLightColor;
-    readonly customSettings?: ReadonlyArray<ICustomSettingsItem>;
     readonly description: string;
-    readonly files: ReadonlyArray<string>;
+    readonly files: readonly string[];
     readonly id: string;
-    readonly token?: string;
     readonly incrementID: string;
-    readonly labels: ReadonlyArray<string>;
+    readonly labels: readonly string[];
     readonly lastStatusUpdate: string;
     readonly phoneNumber: string;
     readonly read: boolean;
     readonly sortHash: string;
     readonly status: ETicketStatus;
-    readonly tags: ReadonlyArray<string>;
+    readonly tags: readonly string[];
     readonly title: string;
+    readonly token?: string;
     readonly unreadAdminMessages: number;
     readonly unreadUserMessages: number;
     readonly updatedAt: string;

package/dist/src/rest/methods/user.d.ts

@@ -17,10 +17,10 @@ export declare enum EnumCommunicationPreferenceChannel {
     email = "email"
 }
 export interface IUser {
-    readonly communicationPreferences: ReadonlyArray<{
-        readonly channels: ReadonlyArray<EnumCommunicationPreferenceChannel>;
+    readonly communicationPreferences: readonly {
+        readonly channels: readonly EnumCommunicationPreferenceChannel[];
         readonly event: string;
-    }>;
+    }[];
     readonly createdAt: string;
     readonly deletionRequestedAt: string | null;
     readonly description: string;
@@ -32,20 +32,20 @@ export interface IUser {
     readonly inviteEmailSent: boolean;
     readonly lastLogin: string | null;
     readonly locale: EnumLocale;
-    readonly nativeAppInstallIds: ReadonlyArray<string> | null;
+    readonly nativeAppInstallIds: readonly string[] | null;
     readonly passwordChanged: boolean;
     readonly phoneNumber: string | null;
     readonly profileImage: string | null;
-    readonly properties: ReadonlyArray<string> | null;
+    readonly properties: readonly string[] | null;
     readonly publicProfile: boolean;
+    readonly readOnly: boolean;
     readonly receiveAdminNotifications: boolean;
-    readonly roles: ReadonlyArray<string>;
+    readonly roles: readonly string[];
     readonly tenantIds: {
         readonly [key: string]: string;
     };
     readonly type: EnumUserType | null;
     readonly username: string;
-    readonly readOnly: boolean;
 }
 export type PartialUser = Partial<IUser>;
 export type UserResult = Promise<IUser>;
@@ -80,21 +80,21 @@ export declare enum EnumUserPermissionObjectType {
     unit = "Unit"
 }
 export interface IUserPermission {
+    readonly endDate?: Date;
     readonly id: string;
     readonly label: string;
-    readonly restricted: boolean;
-    readonly restrictions: ReadonlyArray<object>;
-    readonly role: string;
     readonly objectId: string;
     readonly objectType: EnumUserPermissionObjectType;
+    readonly restricted: boolean;
+    readonly restrictions: readonly object[];
+    readonly role: string;
     readonly startDate?: Date;
-    readonly endDate?: Date;
 }
 export type PartialUserPermission = Partial<IUserPermission>;
 export type UserPermissionResult = Promise<IUserPermission>;
 export declare const remapEmbeddedUser: (embedded: {
     readonly [key: string]: any;
-}) => ReadonlyArray<IUser>;
+}) => readonly IUser[];
 export type MethodUserCreate = (appId: string, username: string, data: PartialUser & {
     readonly email: string;
     readonly locale: EnumLocale;
@@ -114,39 +114,39 @@ export declare function userGetById(client: IAllthingsRestClient, userId: string
 export type MethodUserUpdateById = (userId: string, data: PartialUser) => UserResult;
 export declare function userUpdateById(client: IAllthingsRestClient, userId: string, data: PartialUser): UserResult;
 export type MethodUserCreatePermission = (userId: string, permission: PartialUserPermission & {
+    readonly endDate?: Date;
     readonly objectId: string;
     readonly objectType: EnumUserPermissionObjectType;
-    readonly restrictions: ReadonlyArray<object>;
+    readonly restrictions: readonly object[];
     readonly role: EnumUserPermissionRole;
     readonly startDate?: Date;
-    readonly endDate?: Date;
 }) => UserPermissionResult;
 export declare function userCreatePermission(client: IAllthingsRestClient, userId: string, data: PartialUserPermission & {
+    readonly endDate?: Date;
     readonly objectId: string;
     readonly objectType: EnumUserPermissionObjectType;
-    readonly restrictions: ReadonlyArray<object>;
+    readonly restrictions: readonly object[];
     readonly role: EnumUserPermissionRole;
     readonly startDate?: Date;
-    readonly endDate?: Date;
 }): UserPermissionResult;
 export type MethodUserCreatePermissionBatch = (userId: string, permissions: PartialUserPermission & {
+    readonly endDate?: Date;
     readonly objectId: string;
     readonly objectType: EnumUserPermissionObjectType;
-    readonly restrictions: ReadonlyArray<object>;
-    readonly roles: ReadonlyArray<EnumUserPermissionRole>;
+    readonly restrictions: readonly object[];
+    readonly roles: readonly EnumUserPermissionRole[];
     readonly startDate?: Date;
-    readonly endDate?: Date;
 }) => Promise<boolean>;
 export declare function userCreatePermissionBatch(client: IAllthingsRestClient, userId: string, permissions: PartialUserPermission & {
+    readonly endDate?: Date;
     readonly objectId: string;
     readonly objectType: EnumUserPermissionObjectType;
-    readonly restrictions: ReadonlyArray<object>;
-    readonly roles: ReadonlyArray<EnumUserPermissionRole>;
+    readonly restrictions: readonly object[];
+    readonly roles: readonly EnumUserPermissionRole[];
     readonly startDate?: Date;
-    readonly endDate?: Date;
 }): Promise<boolean>;
-export type MethodUserGetPermissions = (userId: string) => Promise<ReadonlyArray<IUserPermission>>;
-export declare function userGetPermissions(client: IAllthingsRestClient, userId: string): Promise<ReadonlyArray<IUserPermission>>;
+export type MethodUserGetPermissions = (userId: string) => Promise<readonly IUserPermission[]>;
+export declare function userGetPermissions(client: IAllthingsRestClient, userId: string): Promise<readonly IUserPermission[]>;
 export type MethodUserDeletePermission = (permissionId: string) => Promise<boolean>;
 export declare function userDeletePermission(client: IAllthingsRestClient, permissionId: string): Promise<boolean>;
 export type MethodUserGetUtilisationPeriods = (userId: string) => UtilisationPeriodResults;

package/dist/src/rest/methods/userRelation.d.ts

@@ -1,15 +1,15 @@
 import { EntityResultList, EnumResource, IAllthingsRestClient } from '../types';
 export interface IUserRelation {
     readonly id: string;
-    readonly user: string;
-    readonly type: string;
-    readonly responsibilities: ReadonlyArray<{
+    readonly readOnly: boolean;
+    readonly responsibilities: readonly {
+        readonly groups: readonly string[];
         readonly id: string;
+        readonly properties: readonly string[];
         readonly role?: string;
-        readonly properties: ReadonlyArray<string>;
-        readonly groups: ReadonlyArray<string>;
-    }>;
-    readonly readOnly: boolean;
+    }[];
+    readonly type: string;
+    readonly user: string;
 }
 export type UserRelationResult = Promise<IUserRelation>;
 export type UserRelationResultList = EntityResultList<IUserRelation>;
@@ -17,30 +17,30 @@ export declare enum EnumUserRelationType {
     isResponsible = "is-responsible"
 }
 export type MethodUserRelationCreate = (userId: string, data: {
-    readonly ids: ReadonlyArray<string>;
+    readonly ids: readonly string[];
+    readonly level: EnumResource;
     readonly readOnly?: boolean;
     readonly role?: string;
     readonly type: EnumUserRelationType;
-    readonly level: EnumResource;
 }) => UserRelationResult;
 export type MethodUserRelationDelete = (userId: string, data: {
-    readonly ids: ReadonlyArray<string>;
+    readonly ids: readonly string[];
+    readonly level: EnumResource;
     readonly role?: string;
     readonly type: EnumUserRelationType;
-    readonly level: EnumResource;
 }) => UserRelationResult;
 export type MethodUserRelationsGetByUser = (userId: string) => UserRelationResultList;
 export declare function userRelationCreate(client: IAllthingsRestClient, userId: string, data: {
-    readonly ids: ReadonlyArray<string>;
+    readonly ids: readonly string[];
+    readonly level: EnumResource;
     readonly readOnly: boolean;
     readonly role?: string;
     readonly type: EnumUserRelationType;
-    readonly level: EnumResource;
 }): UserRelationResult;
 export declare function userRelationDelete(client: IAllthingsRestClient, userId: string, data: {
-    readonly ids: ReadonlyArray<string>;
+    readonly ids: readonly string[];
+    readonly level: EnumResource;
     readonly role?: string;
     readonly type: EnumUserRelationType;
-    readonly level: EnumResource;
 }): UserRelationResult;
 export declare function userRelationsGetByUser(client: IAllthingsRestClient, userId: string): UserRelationResultList;

package/dist/src/rest/methods/utilisationPeriod.d.ts

@@ -8,52 +8,52 @@ export declare enum EnumUtilisationPeriodType {
 }
 export interface IUtilisationPeriod {
     readonly _embedded: {
-        readonly invitations: ReadonlyArray<any>;
         readonly [key: string]: any;
+        readonly invitations: readonly any[];
     };
     readonly endDate: string | null;
     readonly externalId: string | null;
     readonly id: string;
-    readonly invitations: ReadonlyArray<IUtilisationPeriodInvite>;
+    readonly invitations: readonly IUtilisationPeriodInvite[];
     readonly name: string;
+    readonly readOnly: boolean;
     readonly startDate: string;
     readonly stats: {
-        readonly tenantCount: number | null;
         readonly invitationCount: number | null;
+        readonly tenantCount: number | null;
     };
-    readonly tenantIds: ReadonlyArray<string>;
+    readonly tenantIds: readonly string[];
     readonly type: EnumUtilisationPeriodType;
     readonly userCount: number | null;
-    readonly users: ReadonlyArray<IUser>;
-    readonly readOnly: boolean;
+    readonly users: readonly IUser[];
 }
 export interface IUtilisationPeriodInvite {
-    readonly id: string;
     readonly code: string;
     readonly createdAt: string;
     readonly email: string | null;
     readonly expiresAt: string | null;
-    readonly permanent: boolean;
-    readonly utilisationPeriods: ReadonlyArray<string>;
-    readonly invitationSent: boolean;
     readonly externalId: string;
-    readonly organizations: ReadonlyArray<string>;
-    readonly teams: ReadonlyArray<string>;
+    readonly id: string;
+    readonly invitationSent: boolean;
+    readonly organizations: readonly string[];
+    readonly permanent: boolean;
+    readonly resendAttempts: readonly string[];
+    readonly teams: readonly string[];
     readonly tenant: IRegistrationCodeTenant;
-    readonly resendAttempts: ReadonlyArray<string>;
     readonly usedAt: string | null;
+    readonly utilisationPeriods: readonly string[];
 }
 export type PartialUtilisationPeriod = Partial<IUtilisationPeriod>;
 export type UtilisationPeriodResult = Promise<IUtilisationPeriod>;
-export type UtilisationPeriodResults = Promise<ReadonlyArray<IUtilisationPeriod>>;
+export type UtilisationPeriodResults = Promise<readonly IUtilisationPeriod[]>;
 export type MethodUtilisationPeriodCreate = (unitId: string, data: PartialUtilisationPeriod & {
-    readonly startDate: string;
     readonly endDate?: string;
+    readonly startDate: string;
     readonly type?: EnumUtilisationPeriodType;
 }) => UtilisationPeriodResult;
 export declare function utilisationPeriodCreate(client: IAllthingsRestClient, unitId: string, data: PartialUtilisationPeriod & {
-    readonly startDate: string;
     readonly endDate?: string;
+    readonly startDate: string;
     readonly type?: EnumUtilisationPeriodType;
 }): UtilisationPeriodResult;
 export type MethodUtilisationPeriodGetById = (id: string) => UtilisationPeriodResult;

package/dist/src/rest/request.d.ts

@@ -2,7 +2,7 @@
 import { ITokenStore, TokenRequester } from '../oauth/types';
 import { IAllthingsRestClientOptions } from './types';
 interface IFormOptions {
-    readonly [key: string]: ReadonlyArray<any>;
+    readonly [key: string]: readonly any[];
 }
 interface IBodyFormData {
     readonly formData: IFormOptions;