attlaz-client 1.18.4 → 1.18.6

package/dist/Client.d.ts

@@ -31,12 +31,14 @@ import { SearchEndpoint } from './Service/SearchEndpoint.js';
 import { UserActionEndpoint } from './Service/UserActionEndpoint.js';
 import { AccessTokenEndpoint } from './Service/AccessTokenEndpoint.js';
 export declare class Client {
-    private endpoints;
+    private readonly endpoints;
     private httpClient;
-    private Store;
+    private readonly Store;
     private apiEndpoint;
     private parseConfig;
-    constructor(token?: string | null, config?: Record<string, unknown>);
+    constructor(token?: string | null, config?: {
+        apiEndpoint: string | undefined;
+    });
     setClientCredentials(clientId: string, clientSecret?: string): void;
     getHttpClient(): OAuthClient;
     authenticate(): Promise<boolean>;

package/dist/Client.js

@@ -71,7 +71,7 @@ export class Client {
         // TODO: go over other records in config and warn if any unknown ones
         return config;
     }
-    constructor(token = null, config = {}) {
+    constructor(token = null, config = { apiEndpoint: undefined }) {
         const parsedConfig = this.parseConfig(config);
         if (parsedConfig.apiEndpoint !== undefined) {
             this.apiEndpoint = parsedConfig.apiEndpoint;
@@ -95,10 +95,10 @@ export class Client {
     }
     async authenticate(username = null, password = null) {
         if (username === null || password === null) {
-            return this.httpClient.authenticate();
+            return await this.httpClient.authenticate();
         }
         // TODO: this is only possible when clientId and clientSecret are defined
-        return this.httpClient.authenticate(username, password);
+        return await this.httpClient.authenticate(username, password);
     }
     isAuthenticated() {
         return this.httpClient.isAuthenticated();
@@ -208,18 +208,18 @@ export class Client {
     getFirewallEndpoint() {
         return this.getEndpoint('firewall', this.Store.FirewallEndpoint);
     }
-    getEndpoint(key, className) {
+    getEndpoint(key, ClassName) {
         // const classNameString: string = className.name;
         if (!this.endpoints.has(key)) {
             // if (this.Store[classNameString] === undefined || this.Store[classNameString] === null) {
             //     throw new Error(`Class type of \'${classNameString}\' is not in the store`);
             // }
             try {
-                const endpoint = new className(this.httpClient);
+                const endpoint = new ClassName(this.httpClient);
                 this.endpoints.set(key, endpoint);
             }
-            catch (e) {
-                throw new Error('Unable to initialize ' + key + ' endpoint (' + e.message + ')');
+            catch (error) {
+                throw new Error('Unable to initialize ' + key + ' endpoint (' + error.message + ')');
             }
         }
         return this.endpoints.get(key);

package/dist/Http/ClientError.d.ts

@@ -1,8 +1,12 @@
+import { AxiosError } from 'axios';
 export declare class ClientError extends Error {
-    code: number | null;
-    name: string;
-    stack?: string;
-    constructor(name: string, code?: number | null);
-    static fromError(error: Error | any): ClientError;
+    httpStatus: number | null;
+    type: string;
+    code: string;
+    message: string;
+    param?: string | undefined;
+    stack?: string | undefined;
+    constructor(code: string, httpErrorCode?: number | null);
+    static fromError(error: Error | AxiosError): ClientError;
     static byStatus(statusCode: number, statusText: string): ClientError | null;
 }

package/dist/Http/ClientError.js

@@ -1,51 +1,88 @@
-import { HttpClient } from './HttpClient.js';
+import { AxiosError } from 'axios';
+import { HttpStatus } from './HttpStatus.js';
 export class ClientError extends Error {
+    httpStatus = null;
+    type;
     code;
-    name;
+    message;
+    param = undefined;
     stack = undefined;
-    constructor(name, code = null) {
-        super(name);
-        this.name = name;
+    constructor(code, httpErrorCode = null) {
+        super(code);
         this.code = code;
+        this.httpStatus = httpErrorCode;
     }
     static fromError(error) {
-        if (error.body !== undefined && error.body !== null && error.body.error !== undefined && error.body.error !== null) {
-            error = error.body.error;
-        }
-        let message = error;
-        if (error.message !== undefined && error.message !== null) {
-            message = error.message;
+        let clientError = new ClientError('Unknown error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
+        if (error instanceof AxiosError) {
+            if (error.status !== undefined) {
+                clientError.httpStatus = error.status;
+            }
+            // console.log('Status', clientError.httpStatus);
+            // if(clientError.httpStatus === HttpStatusCode.Ref)
+            clientError.message = error.message;
+            if (error.code !== undefined) {
+                clientError.code = error.code;
+            }
+            if (error.response === undefined) {
+                console.error('Unable to parse AxiosError response', { error });
+            }
+            else {
+                // console.debug('Parse response', {error: error, data: error.response.data});
+                const errorData = error.response.data;
+                if (errorData.type !== undefined) {
+                    clientError.type = errorData.type;
+                }
+                if (errorData.code !== undefined) {
+                    clientError.code = errorData.code;
+                }
+                if (errorData.message !== undefined) {
+                    clientError.message = errorData.message;
+                }
+                if (errorData.param !== undefined) {
+                    clientError.param = errorData.param;
+                }
+            }
+            return clientError;
         }
-        let clientError = new ClientError(message);
+        // if (error.body !== undefined && error.body !== null && error.body.error !== undefined && error.body.error !== null) {
+        //     error = error.body.error;
+        // }
+        // let message: string = error;
+        // if (error.message !== undefined && error.message !== null) {
+        //     message = error.message;
+        // }
+        //
         // console.error(error);
-        if (error.status !== null && error.status !== undefined) {
-            const statusCode = error.status;
-            const { body } = error;
+        const xError = error;
+        if (xError.status !== null && xError.status !== undefined) {
+            const statusCode = xError.status;
+            const { body } = xError;
             const clientErrorByStatus = this.byStatus(statusCode, body);
             if (clientErrorByStatus !== null) {
                 clientError = clientErrorByStatus;
             }
         }
-        else if (error.code !== null && error.code !== undefined) {
-            switch (error.code) {
+        else if (xError.code !== null && xError.code !== undefined) {
+            switch (xError.code) {
                 case 'EUNAVAILABLE':
-                    clientError.code = HttpClient.HTTP_UNAVAILABLE;
+                    clientError.httpStatus = HttpStatus.HTTP_UNAVAILABLE;
                     break;
                 case 'EAUTH':
                 case 401:
-                    clientError.code = HttpClient.HTTP_UNAUTHORIZED;
+                    clientError.httpStatus = HttpStatus.HTTP_UNAUTHORIZED;
                     break;
                 case 'ESTATUS':
                     if (error.message === 'HTTP status 503') {
-                        clientError.code = HttpClient.HTTP_UNAVAILABLE;
+                        clientError.httpStatus = HttpStatus.HTTP_UNAVAILABLE;
                     }
                     break;
                 case 500:
-                    clientError.code = HttpClient.HTTP_INTERNAL_SERVER_ERROR;
+                    clientError.httpStatus = HttpStatus.HTTP_INTERNAL_SERVER_ERROR;
                     break;
                 default:
-                    console.warn('[Client error] Error code `' + error.code + '` not recognised');
-                    clientError.code = error.code;
+                    console.warn('[Client error] Error code `' + xError.code + '` not recognised');
+                    clientError.httpStatus = HttpStatus.HTTP_INTERNAL_SERVER_ERROR;
             }
         }
         clientError.name = error.name;
@@ -60,29 +97,28 @@ export class ClientError extends Error {
             case 202:
                 return null;
             case 400:
-                return new ClientError('Bad Request', HttpClient.HTTP_BAD_REQUEST);
+                return new ClientError('Bad Request', HttpStatus.HTTP_BAD_REQUEST);
             case 401:
-                return new ClientError('Unauthorized', HttpClient.HTTP_UNAUTHORIZED);
+                return new ClientError('Unauthorized', HttpStatus.HTTP_UNAUTHORIZED);
             case 403:
-                return new ClientError('Forbidden', HttpClient.HTTP_FORBIDDEN);
+                return new ClientError('Forbidden', HttpStatus.HTTP_FORBIDDEN);
             case 404:
-                return new ClientError('Not Found', HttpClient.HTTP_NOTFOUND);
+                return new ClientError('Not Found', HttpStatus.HTTP_NOTFOUND);
             case 405:
-                return new ClientError('Not allowed', HttpClient.HTTP_NOT_ALLOWED);
+                return new ClientError('Not allowed', HttpStatus.HTTP_NOT_ALLOWED);
             case 422:
-                return new ClientError('Unprocessable Entity', HttpClient.HTTP_UNPROCESSABLE_ENTITY);
+                return new ClientError('Unprocessable Entity', HttpStatus.HTTP_UNPROCESSABLE_ENTITY);
             case 500:
-                return new ClientError('Internal Server Error', HttpClient.HTTP_INTERNAL_SERVER_ERROR);
+                return new ClientError('Internal Server Error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
             case 502:
-                return new ClientError('Bad gateway', HttpClient.HTTP_BAD_GATEWAY);
+                return new ClientError('Bad gateway', HttpStatus.HTTP_BAD_GATEWAY);
             case 503:
-                return new ClientError('Service not available', HttpClient.HTTP_UNAVAILABLE);
+                return new ClientError('Service not available', HttpStatus.HTTP_UNAVAILABLE);
             case 504:
-                return new ClientError('Gateway Time-out', HttpClient.HTTP_TIMEOUT);
+                return new ClientError('Gateway Time-out', HttpStatus.HTTP_TIMEOUT);
             default:
                 console.error('Unknown status code "' + statusCode + '"', { code: statusCode, text: statusText });
                 return new ClientError('Status code ' + statusCode + ': ' + statusText, statusCode);
         }
-        return null;
     }
 }

package/dist/Http/ContentTypeHelper.d.ts

@@ -0,0 +1,6 @@
+export declare class ContentTypeHelper {
+    static formatContentType(input: string): {
+        type: string;
+        options: string | null;
+    };
+}

package/dist/Http/ContentTypeHelper.js

@@ -0,0 +1,13 @@
+export class ContentTypeHelper {
+    static formatContentType(input) {
+        const arrInput = input.split(';');
+        if (arrInput.length === 1) {
+            return { type: arrInput[0], options: null };
+        }
+        if (arrInput.length === 2) {
+            return { type: arrInput[0], options: arrInput[1].trim() };
+        }
+        console.error('Unable to parse content type "' + input + '"');
+        return { type: input, options: null };
+    }
+}

package/dist/Http/HttpClient.d.ts

@@ -1,21 +1,6 @@
 import { HttpClientRequest } from './HttpClientRequest.js';
 import { HttpClientResponse } from './HttpClientResponse.js';
 export declare class HttpClient {
-    static HTTP_BAD_REQUEST: number;
-    static HTTP_UNAUTHORIZED: number;
-    static HTTP_FORBIDDEN: number;
-    static HTTP_NOTFOUND: number;
-    static HTTP_NOT_ALLOWED: number;
-    static HTTP_UNPROCESSABLE_ENTITY: number;
-    static HTTP_INTERNAL_SERVER_ERROR: number;
-    static HTTP_BAD_GATEWAY: number;
-    static HTTP_UNAVAILABLE: number;
-    static HTTP_TIMEOUT: number;
     static request(request: HttpClientRequest): Promise<HttpClientResponse>;
     private static axiosRequest;
-    private static isJson;
-    static formatContentType(input: string): {
-        type: string;
-        options: string | null;
-    };
 }

package/dist/Http/HttpClient.js

@@ -1,26 +1,18 @@
-import axios, { AxiosError } from 'axios';
+import axios from 'axios';
 import { HttpClientResponse } from './HttpClientResponse.js';
 import { ClientError } from './ClientError.js';
 export class HttpClient {
-    static HTTP_BAD_REQUEST = 400;
-    static HTTP_UNAUTHORIZED = 401;
-    static HTTP_FORBIDDEN = 403;
-    static HTTP_NOTFOUND = 404;
-    static HTTP_NOT_ALLOWED = 405;
-    static HTTP_UNPROCESSABLE_ENTITY = 422;
-    static HTTP_INTERNAL_SERVER_ERROR = 500;
-    static HTTP_BAD_GATEWAY = 502;
-    static HTTP_UNAVAILABLE = 503;
-    static HTTP_TIMEOUT = 504;
     static async request(request) {
         const response = await HttpClient.axiosRequest(request);
-        const error = ClientError.byStatus(response.status, response.statusText);
-        if (error !== null && error !== undefined) {
-            if (response.body !== null && response.body !== undefined && response.body.error !== null && response.body.error !== undefined && response.body.error.message !== null && response.body.error.message !== undefined) {
-                error.message = response.body.error.message;
-            }
-            throw error;
-        }
+        // const error: ClientError | null = ClientError.byStatus(response.status, response.statusText);
+        // if (error !== null && error !== undefined) {
+        //     if (response.body !== null && response.body !== undefined && response.body.error !== null && response.body.error !== undefined && response.body.error.message !== null && response.body.error.message !== undefined
+        //     ) {
+        //         error.message = response.body.error.message;
+        //     }
+        //
+        //     throw error;
+        // }
         return response;
     }
     static async axiosRequest(request) {
@@ -45,33 +37,17 @@ export class HttpClient {
             httpResponse.body = await rawResponse.data;
             return httpResponse;
         }
-        catch (e) {
-            if (e instanceof AxiosError) {
-                const status = e.status === undefined ? 500 : e.status;
-                const statusCode = e.code === undefined ? 'Error' : e.code;
-                const response = new HttpClientResponse(status, statusCode);
-                if (e.response !== undefined) {
-                    response.body = e.response.data;
-                }
-                return response;
-            }
-            console.error('Unable to perform request', { error: e });
-            const response = new HttpClientResponse(500, '');
-            return response;
-        }
-    }
-    static isJson(response) {
-        return response.getContentType() === 'application/json';
-    }
-    static formatContentType(input) {
-        const d = input.split(';');
-        if (d.length === 1) {
-            return { type: d[0], options: null };
-        }
-        if (d.length === 2) {
-            return { type: d[0], options: d[1].trim() };
+        catch (requestError) {
+            // if (requestError instanceof AxiosError) {
+            //     const status: number = requestError.status === undefined ? 500 : requestError.status;
+            //     const statusCode: string = requestError.code === undefined ? 'Error' : requestError.code;
+            //
+            //     const response: HttpClientResponse = new HttpClientResponse(status, statusCode);
+            //
+            //
+            //     throw ClientError.fromError(requestError);
+            // }
+            throw ClientError.fromError(requestError);
         }
-        console.error('Unable to parse content type "' + input + '"');
-        return { type: input, options: null };
     }
 }

package/dist/Http/HttpClientResponse.d.ts

@@ -6,4 +6,5 @@ export declare class HttpClientResponse {
     headers: Headers;
     constructor(status: number, statusText: string);
     getContentType(): string | null;
+    isJson(): boolean;
 }

package/dist/Http/HttpClientResponse.js

@@ -1,4 +1,4 @@
-import { HttpClient } from './HttpClient.js';
+import { ContentTypeHelper } from './ContentTypeHelper.js';
 export class HttpClientResponse {
     status;
     statusText;
@@ -20,7 +20,10 @@ export class HttpClientResponse {
         if (contentType === null || contentType === undefined) {
             return null;
         }
-        const parsedContentType = HttpClient.formatContentType(contentType);
+        const parsedContentType = ContentTypeHelper.formatContentType(contentType);
         return parsedContentType.type;
     }
+    isJson() {
+        return this.getContentType() === 'application/json';
+    }
 }

package/dist/Http/HttpStatus.d.ts

@@ -0,0 +1,12 @@
+export declare class HttpStatus {
+    static HTTP_BAD_REQUEST: number;
+    static HTTP_UNAUTHORIZED: number;
+    static HTTP_FORBIDDEN: number;
+    static HTTP_NOTFOUND: number;
+    static HTTP_NOT_ALLOWED: number;
+    static HTTP_UNPROCESSABLE_ENTITY: number;
+    static HTTP_INTERNAL_SERVER_ERROR: number;
+    static HTTP_BAD_GATEWAY: number;
+    static HTTP_UNAVAILABLE: number;
+    static HTTP_TIMEOUT: number;
+}

package/dist/Http/HttpStatus.js

@@ -0,0 +1,12 @@
+export class HttpStatus {
+    static HTTP_BAD_REQUEST = 400;
+    static HTTP_UNAUTHORIZED = 401;
+    static HTTP_FORBIDDEN = 403;
+    static HTTP_NOTFOUND = 404;
+    static HTTP_NOT_ALLOWED = 405;
+    static HTTP_UNPROCESSABLE_ENTITY = 422;
+    static HTTP_INTERNAL_SERVER_ERROR = 500;
+    static HTTP_BAD_GATEWAY = 502;
+    static HTTP_UNAVAILABLE = 503;
+    static HTTP_TIMEOUT = 504;
+}

package/dist/Http/OAuthClient.js

@@ -28,14 +28,23 @@ export class OAuthClient {
             // Client credentials flow
             const getClientCredentials = clientCredentials(this.getAxiosInstance(), this.getApiEndpointUrl(this.options.accessTokenUri), this.options.clientId === null ? undefined : this.options.clientId, this.options.clientSecret === null ? undefined : this.options.clientSecret);
             const rawAuthToken = await getClientCredentials(this.options.scopes.join(' '));
+            // console.log('Raw token', rawAuthToken);
             this.oathClientToken = this.tokenToOauthClientToken(rawAuthToken);
+            // const getRefreshToken = refreshToken(
+            //     this.getAxiosInstance(),
+            //     this.getApiEndpointUrl(this.options.accessTokenUri),
+            //     this.options.clientId === null ? undefined : this.options.clientId,
+            //     this.options.clientSecret === null ? undefined : this.options.clientSecret,
+            // );
+            // const auth = await getRefreshToken(this.oathClientToken.access_token, this.options.scopes.join(' '))
+            // console.log('Refresh token', auth);
             return true;
         }
-        catch (e) {
+        catch (requestError) {
             if (this.debug) {
-                console.debug('[Client] Error during authentication', e);
+                console.debug('[Client] Error during authentication', requestError);
             }
-            throw ClientError.fromError(e);
+            throw ClientError.fromError(requestError);
         }
     }
     async refreshToken() {
@@ -112,6 +121,9 @@ export class OAuthClient {
                     }
                     throw clientError;
                 }
+                if (this.debug) {
+                    console.error('[Client] Error:', { error });
+                }
                 throw error;
             }
         }

package/dist/Service/Endpoint.js

@@ -1,12 +1,12 @@
 import { CollectionResult } from '../Model/Result/CollectionResult.js';
 import { ObjectResult } from '../Model/Result/ObjectResult.js';
-import { HttpClient } from '../Http/HttpClient.js';
 import { Utils } from '../Utils.js';
 import { ObjectWrapper } from '../Model/Result/ObjectWrapper.js';
 import { DataValueCollection } from '../Model/DataValueCollection.js';
 import { JsonSerializable } from '../Model/JsonSerializable.js';
 import { LogStreamId } from '../Model/Log/LogStreamId.js';
 import { QueryString } from '../Http/Data/QueryString.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
 export class Endpoint {
     httpClient;
     constructor(httpClient) {
@@ -74,6 +74,10 @@ export class Endpoint {
         if (action instanceof QueryString) {
             action = action.build();
         }
+        try {
+        }
+        catch (e) {
+        }
         const requestResponse = await this.httpClient.request(action, parameters, method, signWithOauthToken);
         const result = new CollectionResult();
         /**
@@ -119,7 +123,7 @@ export class Endpoint {
             result.setData(this.parseObject(requestResponse, parser));
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 result.setData(null);
             }
             else {

package/dist/Service/FlowEndpoint.js

@@ -1,8 +1,8 @@
 import { Endpoint } from './Endpoint.js';
 import { Utils } from '../Utils.js';
-import { HttpClient } from '../Http/HttpClient.js';
 import { Flow } from '../Model/Flow/Flow.js';
 import { FlowSummary } from '../Model/Flow/FlowSummary.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
 export class FlowEndpoint extends Endpoint {
     async getByProject(projectId) {
         try {
@@ -23,7 +23,7 @@ export class FlowEndpoint extends Endpoint {
             return result.getData();
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 return null;
             }
             if (this.httpClient.isDebugEnabled()) {

package/dist/Service/ProjectEnvironmentEndpoint.js

@@ -1,7 +1,7 @@
 import { Endpoint } from './Endpoint.js';
 import { ProjectEnvironment } from '../Model/Project/ProjectEnvironment.js';
-import { HttpClient } from '../Http/HttpClient.js';
 import { ProjectEnvironmentConfiguration } from '../Model/Project/ProjectEnvironmentConfiguration.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
 export class ProjectEnvironmentEndpoint extends Endpoint {
     async getByProject(id) {
         try {
@@ -21,7 +21,7 @@ export class ProjectEnvironmentEndpoint extends Endpoint {
             return rawProjectEnvironment.getData();
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 return null;
             }
             if (this.httpClient.isDebugEnabled()) {
@@ -60,7 +60,7 @@ export class ProjectEnvironmentEndpoint extends Endpoint {
             return rawProjectEnvironment.getData();
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 return null;
             }
             if (this.httpClient.isDebugEnabled()) {

package/dist/Service/SourcesAccountEndpoint.js

@@ -1,10 +1,10 @@
 import { Endpoint } from './Endpoint.js';
 import { CodeSourceAccount } from '../Model/Deployment/CodeSourceAccount.js';
 import { CodeSource } from '../Model/Deployment/CodeSource.js';
-import { HttpClient } from '../Http/HttpClient.js';
 import { SourcesAccountRepository } from '../Model/Deployment/SourcesAccountRepository.js';
 import { SourcesAccountRepositoryBranch } from '../Model/Deployment/SourcesAccountRepositoryBranch.js';
 import { QueryString } from '../Http/Data/QueryString.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
 export class SourcesAccountEndpoint extends Endpoint {
     async getAllCodeSources(workspaceId, pagination = null) {
         const queryString = new QueryString('workspaces/' + workspaceId + '/codesources');
@@ -24,7 +24,7 @@ export class SourcesAccountEndpoint extends Endpoint {
             return rawSourcesAccounts.getData();
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 return null;
             }
             if (this.httpClient.isDebugEnabled()) {
@@ -44,7 +44,7 @@ export class SourcesAccountEndpoint extends Endpoint {
             return result.getData();
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 return null;
             }
             if (this.httpClient.isDebugEnabled()) {

package/dist/index.d.ts

@@ -11,6 +11,8 @@ export { OAuthClient } from './Http/OAuthClient.js';
 export { OAuthClientOptions } from './Http/OAuthClientOptions.js';
 export { OAuthClientToken } from './Http/OAuthClientToken.js';
 export { ClientError } from './Http/ClientError.js';
+export { HttpStatus } from './Http/HttpStatus.js';
+export { ContentTypeHelper } from './Http/ContentTypeHelper.js';
 /**
  * Models
  */

package/dist/index.js

@@ -6,6 +6,8 @@ export { OAuthClient } from './Http/OAuthClient.js';
 export { OAuthClientOptions } from './Http/OAuthClientOptions.js';
 export { OAuthClientToken } from './Http/OAuthClientToken.js';
 export { ClientError } from './Http/ClientError.js';
+export { HttpStatus } from './Http/HttpStatus.js';
+export { ContentTypeHelper } from './Http/ContentTypeHelper.js';
 /**
  * Models
  */

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.16.3";
+export declare const VERSION = "1.18.5";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "1.16.3";
+export const VERSION = "1.18.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attlaz-client",
-  "version": "1.18.4",
+  "version": "1.18.6",
   "description": "Javascript Client to access Attlaz API",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",