@allthings/sdk 5.0.0 → 5.0.2

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

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

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

@@ -1,4 +1,4 @@
 import { MethodHttpRequest } from './request';
-export declare type DeleteResult = Promise<any>;
-export declare type MethodHttpDelete = (method: string, body?: Record<string, any>, returnRawResultObject?: boolean) => DeleteResult;
+export type DeleteResult = Promise<any>;
+export type MethodHttpDelete = (method: string, body?: Record<string, any>, returnRawResultObject?: boolean) => DeleteResult;
 export default function del(request: MethodHttpRequest, method: string, body: Record<string, any>, returnRawResultObject?: boolean): DeleteResult;

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

@@ -1,4 +1,4 @@
 import { MethodHttpRequest } from './request';
-export declare type GetResult = Promise<any>;
-export declare type MethodHttpGet = (method: string, query?: Record<string, any>, returnRawResultObject?: boolean) => GetResult;
+export type GetResult = Promise<any>;
+export type MethodHttpGet = (method: string, query?: Record<string, any>, returnRawResultObject?: boolean) => GetResult;
 export default function get(request: MethodHttpRequest, method: string, query: Record<string, any>, returnRawResultObject?: boolean): GetResult;

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

@@ -1,7 +1,7 @@
 import { EnumLocale, IAllthingsRestClient } from '../types';
 import { EnumUserPermissionObjectType, EnumUserPermissionRole, IUserPermission, PartialUser, UserResult } from './user';
-export declare type AgentPermissionsResult = Promise<ReadonlyArray<IUserPermission>>;
-export declare type MethodAgentCreate = (appId: string, propertyManagerId: string, username: string, data: PartialUser & {
+export type AgentPermissionsResult = Promise<ReadonlyArray<IUserPermission>>;
+export type MethodAgentCreate = (appId: string, propertyManagerId: string, username: string, data: PartialUser & {
     readonly email: string;
     readonly locale: EnumLocale;
 }, sendInvitation?: boolean, externalAgentCompany?: string) => UserResult;
@@ -9,5 +9,5 @@ export declare function agentCreate(client: IAllthingsRestClient, appId: string,
     readonly email: string;
     readonly locale: EnumLocale;
 }, sendInvitation?: boolean, externalAgentCompany?: string): UserResult;
-export declare type MethodAgentCreatePermissions = (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: 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>;

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

@@ -6,10 +6,10 @@ export interface IApp {
     readonly emailToTicketEnabled: boolean;
     readonly emailToTicketForwardingEnabled: boolean;
 }
-export declare type PartialApp = Partial<IApp>;
-export declare type AppResult = Promise<IApp>;
-export declare type CreateAppResult = Promise<IApp>;
-export declare type MethodAppCreate = (userId: string, data: PartialApp & {
+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;
@@ -19,9 +19,9 @@ export declare function appCreate(client: IAllthingsRestClient, userId: string,
     readonly siteUrl: string;
     readonly notificationsEmailAddress: string;
 }): CreateAppResult;
-export declare type MethodAppGetById = (appId: string) => AppResult;
+export type MethodAppGetById = (appId: string) => AppResult;
 export declare function appGetById(client: IAllthingsRestClient, appId: string): AppResult;
-export declare type MethodActiveUnitsGetByAppId = (appId: string) => PartialApp & {
+export type MethodActiveUnitsGetByAppId = (appId: string) => PartialApp & {
     readonly activeUnitCount: number;
 };
 export declare function activeUnitsGetByAppId(client: IAllthingsRestClient, appId: string): AppResult;

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

@@ -7,9 +7,9 @@ export interface IBooking {
     readonly message: string;
     readonly phoneNumber: string;
 }
-export declare type PartialBooking = Partial<IBooking>;
-export declare type BookingResult = Promise<IBooking>;
-export declare type MethodBookingGetById = (bookingId: string) => BookingResult;
+export type PartialBooking = Partial<IBooking>;
+export type BookingResult = Promise<IBooking>;
+export type MethodBookingGetById = (bookingId: string) => BookingResult;
 export declare function bookingGetById(client: IAllthingsRestClient, bookingId: string): BookingResult;
-export declare type MethodBookingUpdateById = (bookingId: string, data: PartialBooking) => BookingResult;
+export type MethodBookingUpdateById = (bookingId: string, data: PartialBooking) => BookingResult;
 export declare function bookingUpdateById(client: IAllthingsRestClient, bookingId: string, data: PartialBooking): BookingResult;

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

@@ -1,14 +1,14 @@
 import { IAllthingsRestClient } from '../types';
-export declare type BucketResult = Promise<IBucket>;
+export type BucketResult = Promise<IBucket>;
 export interface IBucket {
     readonly id: string;
     readonly channels: ReadonlyArray<string>;
     readonly files: ReadonlyArray<string>;
     readonly name: string;
 }
-export declare type MethodBucketGet = (bucketId: string) => BucketResult;
+export type MethodBucketGet = (bucketId: string) => BucketResult;
 export declare function bucketGet(client: IAllthingsRestClient, bucketId: string): BucketResult;
-export declare type MethodBucketCreate = (data: {
+export type MethodBucketCreate = (data: {
     readonly channels: ReadonlyArray<string>;
     readonly name: string;
 }) => BucketResult;
@@ -16,11 +16,11 @@ export declare function bucketCreate(client: IAllthingsRestClient, data: {
     readonly channels: ReadonlyArray<string>;
     readonly name: string;
 }): BucketResult;
-export declare type MethodBucketAddFile = (bucketId: string, fileId: string) => Promise<boolean>;
+export type MethodBucketAddFile = (bucketId: string, fileId: string) => Promise<boolean>;
 export declare function bucketAddFile(client: IAllthingsRestClient, bucketId: string, fileId: string): Promise<boolean>;
-export declare type MethodBucketRemoveFile = (bucketId: string, fileId: string) => Promise<boolean>;
+export type MethodBucketRemoveFile = (bucketId: string, fileId: string) => Promise<boolean>;
 export declare function bucketRemoveFile(client: IAllthingsRestClient, bucketId: string, fileId: string): Promise<boolean>;
-export declare type MethodBucketRemoveFilesInPath = (bucketId: string, data: {
+export type MethodBucketRemoveFilesInPath = (bucketId: string, data: {
     readonly path: string;
 }) => Promise<boolean>;
 export declare function bucketRemoveFilesInPath(client: IAllthingsRestClient, bucketId: string, data: {

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

@@ -31,9 +31,9 @@ export interface IMessagePayload {
     };
     readonly inputChannel?: string;
 }
-export declare type ConversationResult = Promise<IConversation>;
-export declare type ConversationCreateMessageResult = Promise<IMessage>;
-export declare type MethodConversationGetById = (conversationId: string) => ConversationResult;
+export type ConversationResult = Promise<IConversation>;
+export type ConversationCreateMessageResult = Promise<IMessage>;
+export type MethodConversationGetById = (conversationId: string) => ConversationResult;
 export declare function conversationGetById(client: IAllthingsRestClient, conversationId: string): ConversationResult;
-export declare type MethodConversationCreateMessage = (conversationId: string, messageData: IMessagePayload) => ConversationCreateMessageResult;
+export type MethodConversationCreateMessage = (conversationId: string, messageData: IMessagePayload) => ConversationCreateMessageResult;
 export declare function conversationCreateMessage(client: IAllthingsRestClient, conversationId: string, messageData: IMessagePayload): ConversationCreateMessageResult;

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IAllthingsRestClient } from '../types';
-export declare type FileResult = Promise<IFile>;
+export type FileResult = Promise<IFile>;
 interface IFileUrl {
     readonly url: string;
     readonly size: number;
@@ -26,7 +26,7 @@ export interface IFile {
         readonly thumb: IFileUrl;
     };
 }
-export declare type MethodFileCreate = (data: {
+export type MethodFileCreate = (data: {
     readonly file: Blob | Buffer | ReadableStream;
     readonly name: string;
     readonly path?: string;
@@ -36,6 +36,6 @@ export declare function fileCreate(client: IAllthingsRestClient, data: {
     readonly name: string;
     readonly path?: string;
 }): FileResult;
-export declare type MethodFileDelete = (fileId: string) => Promise<boolean>;
+export type MethodFileDelete = (fileId: string) => Promise<boolean>;
 export declare function fileDelete(client: IAllthingsRestClient, fileId: string): Promise<boolean>;
 export {};

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

@@ -27,10 +27,10 @@ export interface IGroup {
         readonly inhabitedUnits: number | null;
     };
 }
-export declare type PartialGroup = Partial<IGroup>;
-export declare type GroupResult = Promise<IGroup>;
-export declare type GroupResultList = EntityResultList<IGroup>;
-export declare type MethodGroupCreate = (propertyId: string, data: PartialGroup & {
+export type PartialGroup = Partial<IGroup>;
+export type GroupResult = Promise<IGroup>;
+export type GroupResultList = EntityResultList<IGroup>;
+export type MethodGroupCreate = (propertyId: string, data: PartialGroup & {
     readonly name: string;
     readonly propertyManagerId: string;
 }) => GroupResult;
@@ -38,9 +38,9 @@ export declare function groupCreate(client: IAllthingsRestClient, propertyId: st
     readonly name: string;
     readonly propertyManagerId: string;
 }): GroupResult;
-export declare type MethodGroupGetById = (id: string) => GroupResult;
+export type MethodGroupGetById = (id: string) => GroupResult;
 export declare function groupGetById(client: IAllthingsRestClient, groupId: string): GroupResult;
-export declare type MethodGroupUpdateById = (groupId: string, data: PartialGroup) => GroupResult;
+export type MethodGroupUpdateById = (groupId: string, data: PartialGroup) => GroupResult;
 export declare function groupUpdateById(client: IAllthingsRestClient, groupId: string, data: PartialGroup): GroupResult;
-export declare type MethodGetGroups = (page?: number, limit?: number, filter?: Record<string, any>) => GroupResultList;
+export type MethodGetGroups = (page?: number, limit?: number, filter?: Record<string, any>) => GroupResultList;
 export declare function getGroups(client: IAllthingsRestClient, page?: number, limit?: number, filter?: {}): GroupResultList;

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

@@ -1,8 +1,8 @@
 import { EnumLookupUserType, EnumResource, IAllthingsRestClient } from '../types';
-export declare type LookupIdResult = Promise<{
+export type LookupIdResult = Promise<{
     readonly [externalId: string]: string | null;
 }>;
-export declare type MethodLookupIds = (appId: string, data: {
+export type MethodLookupIds = (appId: string, data: {
     readonly resource: EnumResource;
     readonly externalIds: string | ReadonlyArray<string>;
     readonly parentId?: string;

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

@@ -46,16 +46,16 @@ export interface INotification extends IBasicNotification {
     readonly objectId: string;
     readonly referencedObjectId: string | null;
 }
-export declare type NotificationResultList = EntityResultList<INotification, {
+export type NotificationResultList = EntityResultList<INotification, {
     readonly metaData: {
         readonly unreadNotifications: number;
     };
 }>;
-export declare type MethodNotificationsGetByUser = (userId: string, page?: number, limit?: number) => NotificationResultList;
+export type MethodNotificationsGetByUser = (userId: string, page?: number, limit?: number) => NotificationResultList;
 export declare function notificationsGetByUser(client: IAllthingsRestClient, userId: string, page?: number, limit?: number): NotificationResultList;
-export declare type NotificationsUpdateReadByUserResult = Promise<null>;
-export declare type MethodNotificationsUpdateReadByUser = (userId: string, lastReadAt?: Date) => NotificationsUpdateReadByUserResult;
+export type NotificationsUpdateReadByUserResult = Promise<null>;
+export type MethodNotificationsUpdateReadByUser = (userId: string, lastReadAt?: Date) => NotificationsUpdateReadByUserResult;
 export declare function notificationsUpdateReadByUser(client: IAllthingsRestClient, userId: string, lastReadAt?: Date): NotificationsUpdateReadByUserResult;
-export declare type NotificationUpdateReadResult = Promise<INotification>;
-export declare type MethodNotificationUpdateRead = (notificationId: string) => NotificationUpdateReadResult;
+export type NotificationUpdateReadResult = Promise<INotification>;
+export type MethodNotificationUpdateRead = (notificationId: string) => NotificationUpdateReadResult;
 export declare function notificationUpdateRead(client: IAllthingsRestClient, notificationId: string): NotificationUpdateReadResult;

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

@@ -24,9 +24,9 @@ export declare enum EnumNotificationSettingsValue {
     biweekly = "biweekly",
     monthly = "monthly"
 }
-export declare type PartialNotificationSettings = Partial<INotificationSettings>;
-export declare type NotificationSettingsResult = Promise<INotificationSettings>;
-export declare type MethodNotificationSettingsUpdateByUser = (userId: string, data: PartialNotificationSettings) => NotificationSettingsResult;
+export type PartialNotificationSettings = Partial<INotificationSettings>;
+export type NotificationSettingsResult = Promise<INotificationSettings>;
+export type MethodNotificationSettingsUpdateByUser = (userId: string, data: PartialNotificationSettings) => NotificationSettingsResult;
 export declare function notificationSettingsUpdateByUser(client: IAllthingsRestClient, userId: string, data: PartialNotificationSettings): NotificationSettingsResult;
-export declare type MethodNotificationSettingsResetByUser = (userId: string) => NotificationSettingsResult;
+export type MethodNotificationSettingsResetByUser = (userId: string) => NotificationSettingsResult;
 export declare function notificationSettingsResetByUser(client: IAllthingsRestClient, userId: string): NotificationSettingsResult;

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

@@ -11,10 +11,10 @@ export interface IProperty {
     readonly readOnly: boolean;
     readonly timezone: string;
 }
-export declare type PartialProperty = Partial<IProperty>;
-export declare type PropertyResult = Promise<IProperty>;
-export declare type PropertyResultList = EntityResultList<IProperty>;
-export declare type MethodPropertyCreate = (appId: string, data: PartialProperty & {
+export type PartialProperty = Partial<IProperty>;
+export type PropertyResult = Promise<IProperty>;
+export type PropertyResultList = EntityResultList<IProperty>;
+export type MethodPropertyCreate = (appId: string, data: PartialProperty & {
     readonly name: string;
     readonly timezone: string;
 }) => PropertyResult;
@@ -22,9 +22,9 @@ export declare function propertyCreate(client: IAllthingsRestClient, appId: stri
     readonly name: string;
     readonly timezone: string;
 }): PropertyResult;
-export declare type MethodPropertyGetById = (propertyId: string) => PropertyResult;
+export type MethodPropertyGetById = (propertyId: string) => PropertyResult;
 export declare function propertyGetById(client: IAllthingsRestClient, propertyId: string): PropertyResult;
-export declare type MethodPropertyUpdateById = (propertyId: string, data: PartialProperty) => PropertyResult;
+export type MethodPropertyUpdateById = (propertyId: string, data: PartialProperty) => PropertyResult;
 export declare function propertyUpdateById(client: IAllthingsRestClient, propertyId: string, data: PartialProperty): PropertyResult;
-export declare type MethodGetProperties = (page?: number, limit?: number, filter?: Record<string, any>) => PropertyResultList;
+export type MethodGetProperties = (page?: number, limit?: number, filter?: Record<string, any>) => PropertyResultList;
 export declare function getProperties(client: IAllthingsRestClient, page?: number, limit?: number, filter?: {}): PropertyResultList;

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

@@ -21,14 +21,14 @@ export interface IRegistrationCode extends Required<IRegistrationCodeOptions> {
     readonly invitationSent: boolean;
     readonly utilisationPeriods: ReadonlyArray<string>;
 }
-export declare type PartialRegistrationCode = Partial<IRegistrationCode>;
-export declare type RegistrationCodeResult = Promise<IRegistrationCode>;
+export type PartialRegistrationCode = Partial<IRegistrationCode>;
+export type RegistrationCodeResult = Promise<IRegistrationCode>;
 export declare const remapRegistationCodeResult: (registrationCode: any) => any;
-export declare type MethodRegistrationCodeCreate = (code: string, utilisationPeriods: string | ReadonlyArray<string>, options?: IRegistrationCodeOptions) => RegistrationCodeResult;
+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 declare type MethodRegistrationCodeUpdateById = (registrationCodeId: string, data: PartialRegistrationCode) => RegistrationCodeResult;
+export type MethodRegistrationCodeUpdateById = (registrationCodeId: string, data: PartialRegistrationCode) => RegistrationCodeResult;
 export declare function registrationCodeUpdateById(client: IAllthingsRestClient, registrationCodeId: string, data: PartialRegistrationCode): RegistrationCodeResult;
-export declare type MethodRegistrationCodeGetById = (registrationCodeId: string) => RegistrationCodeResult;
+export type MethodRegistrationCodeGetById = (registrationCodeId: string) => RegistrationCodeResult;
 export declare function registrationCodeGetById(client: IAllthingsRestClient, registrationCodeId: string): RegistrationCodeResult;
-export declare type MethodRegistrationCodeDelete = (registrationCodeId: string) => RegistrationCodeResult;
+export type MethodRegistrationCodeDelete = (registrationCodeId: string) => RegistrationCodeResult;
 export declare function registrationCodeDelete(client: IAllthingsRestClient, registrationCodeId: string): Promise<boolean>;

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

@@ -20,15 +20,15 @@ export interface IServiceProvider {
     readonly type: EnumServiceProviderType;
     readonly website: string | null;
 }
-export declare type PartialServiceProvider = Partial<IServiceProvider>;
-export declare type ServiceProviderResult = Promise<IServiceProvider>;
-export declare type MethodServiceProviderCreate = (data: PartialServiceProvider & {
+export type PartialServiceProvider = Partial<IServiceProvider>;
+export type ServiceProviderResult = Promise<IServiceProvider>;
+export type MethodServiceProviderCreate = (data: PartialServiceProvider & {
     readonly name: string;
 }) => ServiceProviderResult;
 export declare function serviceProviderCreate(client: IAllthingsRestClient, data: PartialServiceProvider & {
     readonly name: string;
 }): ServiceProviderResult;
-export declare type MethodServiceProviderGetById = (propertyId: string) => ServiceProviderResult;
+export type MethodServiceProviderGetById = (propertyId: string) => ServiceProviderResult;
 export declare function serviceProviderGetById(client: IAllthingsRestClient, serviceProviderId: string): ServiceProviderResult;
-export declare type MethodServiceProviderUpdateById = (serviceProviderId: string, data: PartialServiceProvider) => ServiceProviderResult;
+export type MethodServiceProviderUpdateById = (serviceProviderId: string, data: PartialServiceProvider) => ServiceProviderResult;
 export declare function serviceProviderUpdateById(client: IAllthingsRestClient, serviceProviderId: string, data: PartialServiceProvider): ServiceProviderResult;

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

@@ -94,11 +94,11 @@ export interface ITicket {
     readonly unreadUserMessages: number;
     readonly updatedAt: string;
 }
-export declare type TicketResult = Promise<ITicket>;
-export declare type MethodTicketGetById = (ticketId: string) => TicketResult;
+export type TicketResult = Promise<ITicket>;
+export type MethodTicketGetById = (ticketId: string) => TicketResult;
 export declare function ticketGetById(client: IAllthingsRestClient, ticketId: string): TicketResult;
-export declare type MethodTicketCreateOnUser = (userId: string, utilisationPeriodId: string, payload: ITicketCreatePayload) => TicketResult;
+export type MethodTicketCreateOnUser = (userId: string, utilisationPeriodId: string, payload: ITicketCreatePayload) => TicketResult;
 export declare function ticketCreateOnUser(client: IAllthingsRestClient, userId: string, utilisationPeriodId: string, payload: ITicketCreatePayload): TicketResult;
-export declare type MethodTicketCreateOnServiceProvider = (serviceProviderId: string, payload: ITicketCreatePayload) => TicketResult;
+export type MethodTicketCreateOnServiceProvider = (serviceProviderId: string, payload: ITicketCreatePayload) => TicketResult;
 export declare function ticketCreateOnServiceProvider(client: IAllthingsRestClient, serviceProviderId: string, payload: ITicketCreatePayload): TicketResult;
 export {};

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

@@ -91,10 +91,10 @@ export interface IUnit {
     };
     readonly type: EnumUnitType;
 }
-export declare type PartialUnit = Partial<IUnit>;
-export declare type UnitResult = Promise<IUnit>;
-export declare type UnitResultList = EntityResultList<IUnit>;
-export declare type MethodUnitCreate = (groupId: string, data: PartialUnit & {
+export type PartialUnit = Partial<IUnit>;
+export type UnitResult = Promise<IUnit>;
+export type UnitResultList = EntityResultList<IUnit>;
+export type MethodUnitCreate = (groupId: string, data: PartialUnit & {
     readonly name: string;
     readonly type: EnumUnitType;
 }) => UnitResult;
@@ -102,9 +102,9 @@ export declare function unitCreate(client: IAllthingsRestClient, groupId: string
     readonly name: string;
     readonly type: EnumUnitType;
 }): UnitResult;
-export declare type MethodUnitGetById = (id: string) => UnitResult;
+export type MethodUnitGetById = (id: string) => UnitResult;
 export declare function unitGetById(client: IAllthingsRestClient, unitId: string): UnitResult;
-export declare type MethodUnitUpdateById = (unitId: string, data: PartialUnit) => UnitResult;
+export type MethodUnitUpdateById = (unitId: string, data: PartialUnit) => UnitResult;
 export declare function unitUpdateById(client: IAllthingsRestClient, unitId: string, data: PartialUnit): UnitResult;
-export declare type MethodGetUnits = (page?: number, limit?: number, filter?: Record<string, any>) => UnitResultList;
+export type MethodGetUnits = (page?: number, limit?: number, filter?: Record<string, any>) => UnitResultList;
 export declare function getUnits(client: IAllthingsRestClient, page?: number, limit?: number, filter?: {}): UnitResultList;

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

@@ -47,9 +47,9 @@ export interface IUser {
     readonly username: string;
     readonly readOnly: boolean;
 }
-export declare type PartialUser = Partial<IUser>;
-export declare type UserResult = Promise<IUser>;
-export declare type UserResultList = EntityResultList<IUser>;
+export type PartialUser = Partial<IUser>;
+export type UserResult = Promise<IUser>;
+export type UserResultList = EntityResultList<IUser>;
 export declare enum EnumUserPermissionRole {
     appAdmin = "app-admin",
     appOwner = "app-owner",
@@ -90,12 +90,12 @@ export interface IUserPermission {
     readonly startDate?: Date;
     readonly endDate?: Date;
 }
-export declare type PartialUserPermission = Partial<IUserPermission>;
-export declare type UserPermissionResult = Promise<IUserPermission>;
+export type PartialUserPermission = Partial<IUserPermission>;
+export type UserPermissionResult = Promise<IUserPermission>;
 export declare const remapEmbeddedUser: (embedded: {
     readonly [key: string]: any;
 }) => ReadonlyArray<IUser>;
-export declare type MethodUserCreate = (appId: string, username: string, data: PartialUser & {
+export type MethodUserCreate = (appId: string, username: string, data: PartialUser & {
     readonly email: string;
     readonly locale: EnumLocale;
     readonly plainPassword?: string;
@@ -105,15 +105,15 @@ export declare function userCreate(client: IAllthingsRestClient, appId: string,
     readonly locale: EnumLocale;
     readonly plainPassword?: string;
 }): UserResult;
-export declare type MethodGetUsers = (page?: number, limit?: number, filter?: Record<string, any>) => UserResultList;
+export type MethodGetUsers = (page?: number, limit?: number, filter?: Record<string, any>) => UserResultList;
 export declare function getUsers(client: IAllthingsRestClient, page?: number, limit?: number, filter?: {}): UserResultList;
-export declare type MethodGetCurrentUser = () => UserResult;
+export type MethodGetCurrentUser = () => UserResult;
 export declare function getCurrentUser(client: IAllthingsRestClient): UserResult;
-export declare type MethodUserGetById = (id: string) => UserResult;
+export type MethodUserGetById = (id: string) => UserResult;
 export declare function userGetById(client: IAllthingsRestClient, userId: string): UserResult;
-export declare type MethodUserUpdateById = (userId: string, data: PartialUser) => UserResult;
+export type MethodUserUpdateById = (userId: string, data: PartialUser) => UserResult;
 export declare function userUpdateById(client: IAllthingsRestClient, userId: string, data: PartialUser): UserResult;
-export declare type MethodUserCreatePermission = (userId: string, permission: PartialUserPermission & {
+export type MethodUserCreatePermission = (userId: string, permission: PartialUserPermission & {
     readonly objectId: string;
     readonly objectType: EnumUserPermissionObjectType;
     readonly restrictions: ReadonlyArray<object>;
@@ -129,7 +129,7 @@ export declare function userCreatePermission(client: IAllthingsRestClient, userI
     readonly startDate?: Date;
     readonly endDate?: Date;
 }): UserPermissionResult;
-export declare type MethodUserCreatePermissionBatch = (userId: string, permissions: PartialUserPermission & {
+export type MethodUserCreatePermissionBatch = (userId: string, permissions: PartialUserPermission & {
     readonly objectId: string;
     readonly objectType: EnumUserPermissionObjectType;
     readonly restrictions: ReadonlyArray<object>;
@@ -145,15 +145,15 @@ export declare function userCreatePermissionBatch(client: IAllthingsRestClient,
     readonly startDate?: Date;
     readonly endDate?: Date;
 }): Promise<boolean>;
-export declare type MethodUserGetPermissions = (userId: string) => Promise<ReadonlyArray<IUserPermission>>;
+export type MethodUserGetPermissions = (userId: string) => Promise<ReadonlyArray<IUserPermission>>;
 export declare function userGetPermissions(client: IAllthingsRestClient, userId: string): Promise<ReadonlyArray<IUserPermission>>;
-export declare type MethodUserDeletePermission = (permissionId: string) => Promise<boolean>;
+export type MethodUserDeletePermission = (permissionId: string) => Promise<boolean>;
 export declare function userDeletePermission(client: IAllthingsRestClient, permissionId: string): Promise<boolean>;
-export declare type MethodUserGetUtilisationPeriods = (userId: string) => UtilisationPeriodResults;
+export type MethodUserGetUtilisationPeriods = (userId: string) => UtilisationPeriodResults;
 export declare function userGetUtilisationPeriods(client: IAllthingsRestClient, userId: string): UtilisationPeriodResults;
-export declare type MethodUserCheckInToUtilisationPeriod = (userId: string, utilisationPeriodId: string) => UtilisationPeriodResults;
+export type MethodUserCheckInToUtilisationPeriod = (userId: string, utilisationPeriodId: string) => UtilisationPeriodResults;
 export declare function userCheckInToUtilisationPeriod(client: IAllthingsRestClient, userId: string, utilisationPeriodId: string): UtilisationPeriodResult;
-export declare type MethodUserGetByEmail = (email: string) => UserResultList;
+export type MethodUserGetByEmail = (email: string) => UserResultList;
 export declare function userGetByEmail(client: IAllthingsRestClient, email: string, page?: number, limit?: number): UserResultList;
-export declare type MethodUserChangePassword = (userId: string, currentPassword: string, newPassword: string) => Promise<boolean>;
+export type MethodUserChangePassword = (userId: string, currentPassword: string, newPassword: string) => Promise<boolean>;
 export declare function userChangePassword(client: IAllthingsRestClient, userId: string, currentPassword: string, newPassword: string): Promise<boolean>;

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

@@ -11,25 +11,25 @@ export interface IUserRelation {
     }>;
     readonly readOnly: boolean;
 }
-export declare type UserRelationResult = Promise<IUserRelation>;
-export declare type UserRelationResultList = EntityResultList<IUserRelation>;
+export type UserRelationResult = Promise<IUserRelation>;
+export type UserRelationResultList = EntityResultList<IUserRelation>;
 export declare enum EnumUserRelationType {
     isResponsible = "is-responsible"
 }
-export declare type MethodUserRelationCreate = (userId: string, data: {
+export type MethodUserRelationCreate = (userId: string, data: {
     readonly ids: ReadonlyArray<string>;
     readonly readOnly?: boolean;
     readonly role?: string;
     readonly type: EnumUserRelationType;
     readonly level: EnumResource;
 }) => UserRelationResult;
-export declare type MethodUserRelationDelete = (userId: string, data: {
+export type MethodUserRelationDelete = (userId: string, data: {
     readonly ids: ReadonlyArray<string>;
     readonly role?: string;
     readonly type: EnumUserRelationType;
     readonly level: EnumResource;
 }) => UserRelationResult;
-export declare type MethodUserRelationsGetByUser = (userId: string) => UserRelationResultList;
+export type MethodUserRelationsGetByUser = (userId: string) => UserRelationResultList;
 export declare function userRelationCreate(client: IAllthingsRestClient, userId: string, data: {
     readonly ids: ReadonlyArray<string>;
     readonly readOnly: boolean;

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

@@ -43,10 +43,10 @@ export interface IUtilisationPeriodInvite {
     readonly resendAttempts: ReadonlyArray<string>;
     readonly usedAt: string | null;
 }
-export declare type PartialUtilisationPeriod = Partial<IUtilisationPeriod>;
-export declare type UtilisationPeriodResult = Promise<IUtilisationPeriod>;
-export declare type UtilisationPeriodResults = Promise<ReadonlyArray<IUtilisationPeriod>>;
-export declare type MethodUtilisationPeriodCreate = (unitId: string, data: PartialUtilisationPeriod & {
+export type PartialUtilisationPeriod = Partial<IUtilisationPeriod>;
+export type UtilisationPeriodResult = Promise<IUtilisationPeriod>;
+export type UtilisationPeriodResults = Promise<ReadonlyArray<IUtilisationPeriod>>;
+export type MethodUtilisationPeriodCreate = (unitId: string, data: PartialUtilisationPeriod & {
     readonly startDate: string;
     readonly endDate?: string;
     readonly type?: EnumUtilisationPeriodType;
@@ -56,21 +56,21 @@ export declare function utilisationPeriodCreate(client: IAllthingsRestClient, un
     readonly endDate?: string;
     readonly type?: EnumUtilisationPeriodType;
 }): UtilisationPeriodResult;
-export declare type MethodUtilisationPeriodGetById = (id: string) => UtilisationPeriodResult;
+export type MethodUtilisationPeriodGetById = (id: string) => UtilisationPeriodResult;
 export declare function utilisationPeriodGetById(client: IAllthingsRestClient, utilisationPeriodId: string): UtilisationPeriodResult;
-export declare type MethodUtilisationPeriodUpdateById = (unitId: string, data: PartialUtilisationPeriod) => UtilisationPeriodResult;
+export type MethodUtilisationPeriodUpdateById = (unitId: string, data: PartialUtilisationPeriod) => UtilisationPeriodResult;
 export declare function utilisationPeriodUpdateById(client: IAllthingsRestClient, utilisationPeriodId: string, data: PartialUtilisationPeriod & {
     readonly startDate: string;
 }): UtilisationPeriodResult;
-export declare type MethodUtilisationPeriodDelete = (utilisationPeriodId: string) => Promise<boolean>;
+export type MethodUtilisationPeriodDelete = (utilisationPeriodId: string) => Promise<boolean>;
 export declare function utilisationPeriodDelete(client: IAllthingsRestClient, utilisationPeriodId: string): Promise<boolean>;
-export declare type MethodUtilisationPeriodCheckInUser = (utilisationPeriodId: string, data: {
+export type MethodUtilisationPeriodCheckInUser = (utilisationPeriodId: string, data: {
     readonly email: string;
 }) => UtilisationPeriodResult;
 export declare function utilisationPeriodCheckInUser(client: IAllthingsRestClient, utilisationPeriodId: string, data: {
     readonly email: string;
 }): UtilisationPeriodResult;
-export declare type MethodUtilisationPeriodCheckOutUser = (utilisationPeriodId: string, userId: string) => UtilisationPeriodResult;
+export type MethodUtilisationPeriodCheckOutUser = (utilisationPeriodId: string, userId: string) => UtilisationPeriodResult;
 export declare function utilisationPeriodCheckOutUser(client: IAllthingsRestClient, utilisationPeriodId: string, userId: string): Promise<boolean>;
-export declare type MethodUtilisationPeriodAddRegistrationCode = (utilisationPeriodId: string, code: string, tenant?: IRegistrationCodeTenant, permanent?: boolean) => Promise<IUtilisationPeriodInvite>;
+export type MethodUtilisationPeriodAddRegistrationCode = (utilisationPeriodId: string, code: string, tenant?: IRegistrationCodeTenant, permanent?: boolean) => Promise<IUtilisationPeriodInvite>;
 export declare function utilisationPeriodAddRegistrationCode(client: IAllthingsRestClient, utilisationPeriodId: string, code: string, tenant?: IRegistrationCodeTenant, permanent?: boolean): Promise<IUtilisationPeriodInvite>;

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

@@ -1,4 +1,4 @@
 import { MethodHttpRequest } from './request';
-export declare type PatchResult = Promise<any>;
-export declare type MethodHttpPatch = (method: string, body?: Record<string, any>, returnRawResultObject?: boolean) => PatchResult;
+export type PatchResult = Promise<any>;
+export type MethodHttpPatch = (method: string, body?: Record<string, any>, returnRawResultObject?: boolean) => PatchResult;
 export default function patch(request: MethodHttpRequest, method: string, body: Record<string, any>, returnRawResultObject?: boolean): PatchResult;

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

@@ -1,4 +1,4 @@
 import { MethodHttpRequest } from './request';
-export declare type PostResult = Promise<any>;
-export declare type MethodHttpPost = (method: string, body?: Record<string, any>, returnRawResultObject?: boolean) => PostResult;
+export type PostResult = Promise<any>;
+export type MethodHttpPost = (method: string, body?: Record<string, any>, returnRawResultObject?: boolean) => PostResult;
 export default function post(request: MethodHttpRequest, method: string, body: Record<string, any>, returnRawResultObject?: boolean): PostResult;

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

@@ -1,4 +1,4 @@
 import { MethodHttpRequest } from './request';
-export declare type PutResult = Promise<any>;
-export declare type MethodHttpPut = (method: string, body?: Record<string, any>, returnRawResultObject?: boolean) => PutResult;
+export type PutResult = Promise<any>;
+export type MethodHttpPut = (method: string, body?: Record<string, any>, returnRawResultObject?: boolean) => PutResult;
 export default function put(request: MethodHttpRequest, method: string, body: Record<string, any>, returnRawResultObject?: boolean): PutResult;

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

@@ -19,10 +19,10 @@ export interface IRequestOptions {
         readonly [parameter: string]: string;
     };
 }
-export declare type RequestResult = Promise<any>;
-export declare type HttpVerb = 'delete' | 'get' | 'head' | 'patch' | 'post' | 'put';
-export declare type MethodHttpRequest = (httpMethod: string, apiMethod: string, payload?: IRequestOptions, returnRawResultObject?: boolean) => RequestResult;
-export declare type IntervalSet = Set<NodeJS.Timer>;
+export type RequestResult = Promise<any>;
+export type HttpVerb = 'delete' | 'get' | 'head' | 'patch' | 'post' | 'put';
+export type MethodHttpRequest = (httpMethod: string, apiMethod: string, payload?: IRequestOptions, returnRawResultObject?: boolean) => RequestResult;
+export type IntervalSet = Set<NodeJS.Timer>;
 export declare function responseWasSuccessful(response: Response): boolean;
 export declare function makeApiRequest(oauthTokenStore: ITokenStore, oauthTokenRequester: TokenRequester, options: IAllthingsRestClientOptions, httpMethod: HttpVerb, apiMethod: string, payload?: IRequestOptions, returnRawResultObject?: boolean): (previousResult: any, iteration: number) => Promise<Response>;
 export default function request(oauthTokenStore: ITokenStore, oauthTokenRequester: TokenRequester, options: IAllthingsRestClientOptions, httpMethod: HttpVerb, apiMethod: string, payload?: IRequestOptions, returnRawResultObject?: boolean): RequestResult;

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

@@ -76,7 +76,7 @@ export declare enum EnumLookupUserType {
     agent = "agent",
     tenant = "tenant"
 }
-export declare type EntityResultList<Entity, ExtensionInterface = {}> = Promise<{
+export type EntityResultList<Entity, ExtensionInterface = {}> = Promise<{
     readonly _embedded: {
         readonly items: ReadonlyArray<Entity>;
     };

package/dist/src/utils/functional.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-export declare type List<T> = ReadonlyArray<T>;
+export type List<T> = ReadonlyArray<T>;
 export declare const partial: (fn: (...args: any[]) => any | Promise<any>, ...partialArgs: any[]) => (...args: any[]) => any;
 export declare function times<T>(fn: (item: number, index: number) => T, n: number): List<T>;
 export declare function until<A, B>(predicate: (value: B, iteration: number) => boolean | Promise<boolean>, transformer: (value: A | B | undefined, iteration: number) => B | Promise<B>, initialValue?: A | B, iterationCount?: number): Promise<B>;

package/dist/src/utils/logger.d.ts

@@ -1,4 +1,4 @@
-export declare type LogType = 'log' | 'info' | 'warn' | 'error';
+export type LogType = 'log' | 'info' | 'warn' | 'error';
 export interface ILogger {
     readonly [key: string]: (...logs: any[]) => boolean;
 }

package/dist/test/helpers.d.ts

@@ -1,7 +1,7 @@
 import { IUser } from '../src/rest/methods/user';
 import { IUtilisationPeriod } from '../src/rest/methods/utilisationPeriod';
 import { IAllthingsRestClient } from '../src/rest/types';
-export declare type CreateUserAndClientResult = Promise<{
+export type CreateUserAndClientResult = Promise<{
     readonly client: IAllthingsRestClient;
     readonly user: IUser;
 }>;