@attlaz/client 1.115.2 → 1.116.0

package/dist/Client.d.ts

@@ -3,6 +3,8 @@ import { ITransport, ParseErrorHandler } from './Http/Transport/ITransport.js';
 import { OAuthClient, TokenChangeHandler } from './Http/Transport/OAuthClient.js';
 import { AccessTokenEndpoint } from './Service/AccessTokenEndpoint.js';
 import { AdapterConnectionEndpoint } from './Service/AdapterConnectionEndpoint.js';
+import { ConnectionBundleEndpoint } from './Service/ConnectionBundleEndpoint.js';
+import { McpAccessEndpoint } from './Service/McpAccessEndpoint.js';
 import { AdapterEndpoint } from './Service/AdapterEndpoint.js';
 import { ChannelEndpoint } from './Service/ChannelEndpoint.js';
 import { CodeDeployEndpoint } from './Service/CodeDeployEndpoint.js';
@@ -77,6 +79,16 @@ export declare class Client {
      * Used for SPAs and other public clients that cannot keep a secret.
      */
     setPublicClient(clientId: string): void;
+    /**
+     * Overall budget for a single request. **Milliseconds** — the PHP client's `setTimeout()` takes
+     * seconds, so do not port a number across without converting.
+     *
+     * Defaults to 80 seconds, matching the PHP client. Raise it for a large upload or download: the
+     * budget covers the whole exchange, so a body big enough to take longer than this to transfer
+     * is aborted by the client itself, before the server has said anything. Pass 0 to disable the
+     * timeout entirely, which risks hanging the process on a stalled connection.
+     */
+    setTimeout(timeoutMs: number): void;
     setVersion(version: string | null): void;
     getHttpClient(): OAuthClient;
     /**
@@ -104,6 +116,8 @@ export declare class Client {
     }>;
     getAdapterEndpoint(): AdapterEndpoint;
     getAdapterConnectionEndpoint(): AdapterConnectionEndpoint;
+    getConnectionBundleEndpoint(): ConnectionBundleEndpoint;
+    getMcpAccessEndpoint(): McpAccessEndpoint;
     getProjectEndpoint(): ProjectEndpoint;
     getProjectEnvironmentEndpoint(): ProjectEnvironmentEndpoint;
     getCodeDeployEndpoint(): CodeDeployEndpoint;

package/dist/Client.js

@@ -3,6 +3,8 @@ import { OAuthClientToken } from './Http/OAuthClientToken.js';
 import { OAuthClient } from './Http/Transport/OAuthClient.js';
 import { AccessTokenEndpoint } from './Service/AccessTokenEndpoint.js';
 import { AdapterConnectionEndpoint } from './Service/AdapterConnectionEndpoint.js';
+import { ConnectionBundleEndpoint } from './Service/ConnectionBundleEndpoint.js';
+import { McpAccessEndpoint } from './Service/McpAccessEndpoint.js';
 import { AdapterEndpoint } from './Service/AdapterEndpoint.js';
 import { ChannelEndpoint } from './Service/ChannelEndpoint.js';
 import { CodeDeployEndpoint } from './Service/CodeDeployEndpoint.js';
@@ -64,6 +66,8 @@ export class Client {
         AccessTokenEndpoint,
         AdapterConnectionEndpoint,
         AdapterEndpoint,
+        ConnectionBundleEndpoint,
+        McpAccessEndpoint,
         ChannelEndpoint,
         CodeDeployEndpoint,
         ComponentEndpoint,
@@ -152,6 +156,18 @@ export class Client {
     setPublicClient(clientId) {
         this.httpClient.setClientCredentials(clientId, null, ['all']);
     }
+    /**
+     * Overall budget for a single request. **Milliseconds** — the PHP client's `setTimeout()` takes
+     * seconds, so do not port a number across without converting.
+     *
+     * Defaults to 80 seconds, matching the PHP client. Raise it for a large upload or download: the
+     * budget covers the whole exchange, so a body big enough to take longer than this to transfer
+     * is aborted by the client itself, before the server has said anything. Pass 0 to disable the
+     * timeout entirely, which risks hanging the process on a stalled connection.
+     */
+    setTimeout(timeoutMs) {
+        this.httpClient.setTimeout(timeoutMs);
+    }
     setVersion(version) {
         this.httpClient.setVersion(version);
     }
@@ -196,7 +212,7 @@ export class Client {
         this.httpClient.setTokenChangeHandler(handler);
     }
     async getApiInformation() {
-        const result = await this.httpClient.request('/system/health', null, 'GET', false);
+        const result = await this.httpClient.request('/system/info', null, 'GET', true);
         if (result.version === undefined) {
             throw new Error('Unable to get API information: invalid response');
         }
@@ -209,6 +225,12 @@ export class Client {
     getAdapterConnectionEndpoint() {
         return this.getEndpoint('adapter-connection', this.Store.AdapterConnectionEndpoint);
     }
+    getConnectionBundleEndpoint() {
+        return this.getEndpoint('connection-bundle', this.Store.ConnectionBundleEndpoint);
+    }
+    getMcpAccessEndpoint() {
+        return this.getEndpoint('mcp-access', this.Store.McpAccessEndpoint);
+    }
     getProjectEndpoint() {
         return this.getEndpoint('project', this.Store.ProjectEndpoint);
     }

package/dist/Http/Transport/OAuthClient.d.ts

@@ -54,6 +54,14 @@ export declare class OAuthClient implements ITransport {
      */
     requestBytes(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean, headers?: Record<string, string>): Promise<Uint8Array>;
     request<T>(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean): Promise<T>;
+    /**
+     * Overall budget for a single request, in milliseconds. Applies to the token request too, so a
+     * raised budget covers authentication as well.
+     *
+     * There is no separate connect timeout, unlike the PHP client: `AbortSignal.timeout` bounds the
+     * whole exchange and fetch exposes no connect phase to bound on its own.
+     */
+    setTimeout(timeoutMs: number): void;
     isAuthenticated(): boolean;
     getToken(): OAuthClientToken | null;
     setToken(token: OAuthClientToken): void;

package/dist/Http/Transport/OAuthClient.js

@@ -270,6 +270,16 @@ export class OAuthClient {
             throw error;
         }
     }
+    /**
+     * Overall budget for a single request, in milliseconds. Applies to the token request too, so a
+     * raised budget covers authentication as well.
+     *
+     * There is no separate connect timeout, unlike the PHP client: `AbortSignal.timeout` bounds the
+     * whole exchange and fetch exposes no connect phase to bound on its own.
+     */
+    setTimeout(timeoutMs) {
+        this.options.timeoutMs = timeoutMs;
+    }
     isAuthenticated() {
         // TODO: other ways to determine if the client is authenticated?
         return this.oauthClientToken !== null && this.oauthClientToken !== undefined;

package/dist/Model/Connection/ConnectionBundle.d.ts

@@ -0,0 +1,18 @@
+import { ApiRecord } from '../ApiRecord.js';
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+/**
+ * A named, reusable set of connections, scoped to one project.
+ *
+ * Note the wire names: the serializer strips a trailing `_id` and pluralises `_ids`, so the entity's
+ * `projectId` arrives as `project` and `connectionIds` as `connections`.
+ */
+export declare class ConnectionBundle implements StateAware {
+    id: string;
+    name: string;
+    projectId: string;
+    connectionIds: string[];
+    state: State;
+    createdAt: Date;
+    static parse(raw: ApiRecord): ConnectionBundle;
+}

package/dist/Model/Connection/ConnectionBundle.js

@@ -0,0 +1,26 @@
+import { Utils } from '../../Utils.js';
+import { State } from '../State.js';
+/**
+ * A named, reusable set of connections, scoped to one project.
+ *
+ * Note the wire names: the serializer strips a trailing `_id` and pluralises `_ids`, so the entity's
+ * `projectId` arrives as `project` and `connectionIds` as `connections`.
+ */
+export class ConnectionBundle {
+    id;
+    name;
+    projectId;
+    connectionIds = [];
+    state = State.Active;
+    createdAt;
+    static parse(raw) {
+        const bundle = new ConnectionBundle();
+        bundle.id = raw.id;
+        bundle.name = raw.name;
+        bundle.projectId = raw.project;
+        bundle.connectionIds = Array.isArray(raw.connections) ? raw.connections : [];
+        bundle.state = State.fromString(raw.state);
+        bundle.createdAt = Utils.parseRawDate(raw.created_at);
+        return bundle;
+    }
+}

package/dist/Model/Mcp/McpAccess.d.ts

@@ -0,0 +1,25 @@
+import { ApiRecord } from '../ApiRecord.js';
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+/**
+ * A named, revocable share of one connection or connection bundle, reachable at its own MCP URL.
+ *
+ * `target` is a type-prefixed id (`adc_…` for a connection, `cbl_…` for a bundle) and is write-once:
+ * re-pointing an access would let a token already bound to its URL reach somewhere else.
+ */
+export declare class McpAccess implements StateAware {
+    id: string;
+    name: string;
+    target: string;
+    state: State;
+    revokedAt: Date | null;
+    createdAt: Date;
+    /**
+     * The full URL to hand to a client, or null when the access has no live key — the state an
+     * interrupted rotation leaves behind, which the UI has to be able to show rather than assume away.
+     */
+    url: string | null;
+    /** Paused is reversible and keeps its tokens; revoked is final and sweeps them. */
+    isUsable(): boolean;
+    static parse(raw: ApiRecord): McpAccess;
+}

package/dist/Model/Mcp/McpAccess.js

@@ -0,0 +1,36 @@
+import { Utils } from '../../Utils.js';
+import { State } from '../State.js';
+/**
+ * A named, revocable share of one connection or connection bundle, reachable at its own MCP URL.
+ *
+ * `target` is a type-prefixed id (`adc_…` for a connection, `cbl_…` for a bundle) and is write-once:
+ * re-pointing an access would let a token already bound to its URL reach somewhere else.
+ */
+export class McpAccess {
+    id;
+    name;
+    target;
+    state = State.Active;
+    revokedAt = null;
+    createdAt;
+    /**
+     * The full URL to hand to a client, or null when the access has no live key — the state an
+     * interrupted rotation leaves behind, which the UI has to be able to show rather than assume away.
+     */
+    url = null;
+    /** Paused is reversible and keeps its tokens; revoked is final and sweeps them. */
+    isUsable() {
+        return this.revokedAt === null && this.state === State.Active && this.url !== null;
+    }
+    static parse(raw) {
+        const access = new McpAccess();
+        access.id = raw.id;
+        access.name = raw.name;
+        access.target = raw.target;
+        access.state = State.fromString(raw.state);
+        access.revokedAt = (raw.revoked_at === null || raw.revoked_at === undefined) ? null : Utils.parseRawDate(raw.revoked_at);
+        access.createdAt = Utils.parseRawDate(raw.created_at);
+        access.url = (raw.url === null || raw.url === undefined) ? null : raw.url;
+        return access;
+    }
+}

package/dist/Service/ConnectionBundleEndpoint.d.ts

@@ -0,0 +1,17 @@
+import { ConnectionBundle } from '../Model/Connection/ConnectionBundle.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class ConnectionBundleEndpoint extends Endpoint {
+    getBundles(projectId: string, pagination: CursorPagination): Promise<CollectionResult<ConnectionBundle>>;
+    getBundleById(bundleId: string): Promise<ConnectionBundle | null>;
+    createBundle(projectId: string, name: string, connectionIds?: string[]): Promise<ConnectionBundle>;
+    renameBundle(bundleId: string, name: string): Promise<ConnectionBundle>;
+    /**
+     * Add and remove address one membership at a time rather than sending the whole list, so two
+     * people editing the same bundle cannot silently drop each other's change.
+     */
+    addConnection(bundleId: string, connectionId: string): Promise<ConnectionBundle>;
+    removeConnection(bundleId: string, connectionId: string): Promise<ConnectionBundle>;
+    private changeMembership;
+}

package/dist/Service/ConnectionBundleEndpoint.js

@@ -0,0 +1,93 @@
+import { path } from '../Http/Data/Path.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { ConnectionBundle } from '../Model/Connection/ConnectionBundle.js';
+import { Endpoint } from './Endpoint.js';
+export class ConnectionBundleEndpoint extends Endpoint {
+    async getBundles(projectId, pagination) {
+        try {
+            const queryString = new QueryString(path('/projects/:projectId/connection-bundles', { projectId }));
+            queryString.addPagination(pagination);
+            return await this.requestCollection(queryString, ConnectionBundle.parse);
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load connection bundles: ', error);
+            }
+            throw error;
+        }
+    }
+    async getBundleById(bundleId) {
+        try {
+            const url = path('/connection-bundles/:bundleId', { bundleId });
+            const result = await this.requestObject(url, null, ConnectionBundle.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load connection bundle: ', error);
+            }
+            throw error;
+        }
+    }
+    async createBundle(projectId, name, connectionIds = []) {
+        try {
+            const url = path('/projects/:projectId/connection-bundles', { projectId });
+            const result = await this.requestObject(url, { name, connections: connectionIds }, ConnectionBundle.parse, 'POST');
+            const created = result.getData();
+            if (created === null) {
+                throw new Error('Connection bundle not created');
+            }
+            return created;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to create connection bundle: ', error);
+            }
+            throw error;
+        }
+    }
+    async renameBundle(bundleId, name) {
+        try {
+            const url = path('/connection-bundles/:bundleId', { bundleId });
+            const result = await this.requestObject(url, { name }, ConnectionBundle.parse, 'PATCH');
+            const updated = result.getData();
+            if (updated === null) {
+                throw new Error('Connection bundle not updated');
+            }
+            return updated;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to rename connection bundle: ', error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Add and remove address one membership at a time rather than sending the whole list, so two
+     * people editing the same bundle cannot silently drop each other's change.
+     */
+    async addConnection(bundleId, connectionId) {
+        return await this.changeMembership(bundleId, connectionId, 'PUT', 'add the connection to');
+    }
+    async removeConnection(bundleId, connectionId) {
+        return await this.changeMembership(bundleId, connectionId, 'DELETE', 'remove the connection from');
+    }
+    async changeMembership(bundleId, connectionId, method, description) {
+        try {
+            const url = path('/connection-bundles/:bundleId/connections/:connectionId', { bundleId, connectionId });
+            const result = await this.requestObject(url, null, ConnectionBundle.parse, method);
+            const updated = result.getData();
+            if (updated === null) {
+                throw new Error('Connection bundle not updated');
+            }
+            return updated;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to ' + description + ' the bundle: ', error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/Service/McpAccessEndpoint.d.ts

@@ -0,0 +1,23 @@
+import { McpAccess } from '../Model/Mcp/McpAccess.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class McpAccessEndpoint extends Endpoint {
+    /**
+     * Every access pointing at one connection or bundle, revoked ones included — a revoked access is
+     * what explains to its owner why a URL they handed out stopped working.
+     *
+     * `target` is the type-prefixed id (`adc_…`, `cbl_…`), the same form the access reports back.
+     */
+    getAccessesByTarget(target: string): Promise<CollectionResult<McpAccess>>;
+    getAccessById(accessId: string): Promise<McpAccess | null>;
+    /** Creates the access and its first URL together — an access with no URL cannot be reached. */
+    createAccess(name: string, target: string): Promise<McpAccess>;
+    /** New URL, old one dead, and every token bound to the old one revoked. */
+    rotateKey(accessId: string): Promise<McpAccess>;
+    /** Reversible, and keeps its tokens, so resuming needs no re-authentication. */
+    pauseAccess(accessId: string): Promise<McpAccess>;
+    resumeAccess(accessId: string): Promise<McpAccess>;
+    /** One-way. The row survives as the record of what was granted; its tokens do not. */
+    revokeAccess(accessId: string): Promise<McpAccess>;
+    private lifecycle;
+}

package/dist/Service/McpAccessEndpoint.js

@@ -0,0 +1,86 @@
+import { path } from '../Http/Data/Path.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { McpAccess } from '../Model/Mcp/McpAccess.js';
+import { Endpoint } from './Endpoint.js';
+export class McpAccessEndpoint extends Endpoint {
+    /**
+     * Every access pointing at one connection or bundle, revoked ones included — a revoked access is
+     * what explains to its owner why a URL they handed out stopped working.
+     *
+     * `target` is the type-prefixed id (`adc_…`, `cbl_…`), the same form the access reports back.
+     */
+    async getAccessesByTarget(target) {
+        try {
+            const queryString = new QueryString('/mcp-accesses');
+            queryString.set('target', target);
+            return await this.requestCollection(queryString, McpAccess.parse);
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load MCP accesses: ', error);
+            }
+            throw error;
+        }
+    }
+    async getAccessById(accessId) {
+        try {
+            const url = path('/mcp-accesses/:accessId', { accessId });
+            const result = await this.requestObject(url, null, McpAccess.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load MCP access: ', error);
+            }
+            throw error;
+        }
+    }
+    /** Creates the access and its first URL together — an access with no URL cannot be reached. */
+    async createAccess(name, target) {
+        try {
+            const result = await this.requestObject('/mcp-accesses', { name, target }, McpAccess.parse, 'POST');
+            const created = result.getData();
+            if (created === null) {
+                throw new Error('MCP access not created');
+            }
+            return created;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to create MCP access: ', error);
+            }
+            throw error;
+        }
+    }
+    /** New URL, old one dead, and every token bound to the old one revoked. */
+    async rotateKey(accessId) {
+        return await this.lifecycle(accessId, path('/mcp-accesses/:accessId/rotate-key', { accessId }), 'POST', 'rotate the MCP URL');
+    }
+    /** Reversible, and keeps its tokens, so resuming needs no re-authentication. */
+    async pauseAccess(accessId) {
+        return await this.lifecycle(accessId, path('/mcp-accesses/:accessId/pause', { accessId }), 'POST', 'pause the MCP access');
+    }
+    async resumeAccess(accessId) {
+        return await this.lifecycle(accessId, path('/mcp-accesses/:accessId/resume', { accessId }), 'POST', 'resume the MCP access');
+    }
+    /** One-way. The row survives as the record of what was granted; its tokens do not. */
+    async revokeAccess(accessId) {
+        return await this.lifecycle(accessId, path('/mcp-accesses/:accessId', { accessId }), 'DELETE', 'revoke the MCP access');
+    }
+    async lifecycle(accessId, url, method, description) {
+        try {
+            const result = await this.requestObject(url, null, McpAccess.parse, method);
+            const access = result.getData();
+            if (access === null) {
+                throw new Error('MCP access not found: ' + accessId);
+            }
+            return access;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to ' + description + ': ', error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/index.d.ts

@@ -31,6 +31,8 @@ export { UserAccessTokenStatus } from './Model/AccessToken/UserAccessTokenStatus
 export { Adapter } from './Model/Adapter/Adapter.js';
 export { AdapterConfiguration } from './Model/Adapter/AdapterConfiguration.js';
 export { AdapterConnection } from './Model/Adapter/AdapterConnection.js';
+export { ConnectionBundle } from './Model/Connection/ConnectionBundle.js';
+export { McpAccess } from './Model/Mcp/McpAccess.js';
 export { AdapterCategory } from './Model/Adapter/AdapterCategory.js';
 export { AdapterConnectionStatus } from './Model/Adapter/AdapterConnectionStatus.js';
 export { AdapterConnectionConfigurationValue } from './Model/Adapter/AdapterConnectionConfigurationValue.js';

package/dist/index.js

@@ -22,6 +22,8 @@ export { UserAccessTokenStatus } from './Model/AccessToken/UserAccessTokenStatus
 export { Adapter } from './Model/Adapter/Adapter.js';
 export { AdapterConfiguration } from './Model/Adapter/AdapterConfiguration.js';
 export { AdapterConnection } from './Model/Adapter/AdapterConnection.js';
+export { ConnectionBundle } from './Model/Connection/ConnectionBundle.js';
+export { McpAccess } from './Model/Mcp/McpAccess.js';
 export { AdapterCategory } from './Model/Adapter/AdapterCategory.js';
 export { AdapterConnectionStatus } from './Model/Adapter/AdapterConnectionStatus.js';
 export { AdapterConnectionConfigurationValue } from './Model/Adapter/AdapterConnectionConfigurationValue.js';

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.115.2";
+export declare const VERSION = "1.115.3";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "1.115.2";
+export const VERSION = "1.115.3";

package/package.json

@@ -1,72 +1,73 @@
-{
-  "name": "@attlaz/client",
-  "version": "1.115.2",
-  "description": "Javascript Client to access Attlaz API",
-  "types": "./dist/index.d.ts",
-  "main": "./dist/index.js",
-  "type": "module",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./*": {
-      "default": "./dist/*",
-      "types": "./dist/*"
-    }
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Attlaz-Platform/JS-Client.git"
-  },
-  "homepage": "https://attlaz.com",
-  "keywords": [
-    "attlaz",
-    "client",
-    "http",
-    "api"
-  ],
-  "files": [
-    "dist/*"
-  ],
-  "sideEffects": false,
-  "author": "Stijn Duynslaeger <stijn@attlaz.com> (stijn@attlaz.com)",
-  "license": "MIT",
-  "scripts": {
-    "prebuild": "npm run setversion",
-    "prepare": "npm run clean && tsc --project tsconfig.build.json && npm run setversion",
-    "build": "npm run clean && tsc -p tsconfig.build.json",
-    "setversion": "node -p \"'export const VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/version.ts",
-    "clean": "rimraf dist",
-    "scan": "docker run -v .:/path zricethezav/gitleaks:latest detect --source=\"/path\" ",
-    "test": "vitest run --mode unit",
-    "typecheck": "tsc --project tsconfig.json --noEmit",
-    "test-integration": "vitest run --mode integration",
-    "test-live": "vitest --mode unit"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
-  "devDependencies": {
-    "@types/node": "^26.4.0",
-    "@typescript-eslint/eslint-plugin": "^8.59.3",
-    "@typescript-eslint/parser": "^8.59.3",
-    "eslint": "^9.39.5",
-    "eslint-config-attlaz-base": "^1.8.0",
-    "eslint-import-resolver-typescript": "^4.4.5",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsdoc": "^62.9.0",
-    "eslint-plugin-prefer-arrow": "^1.2.3",
-    "eslint-plugin-promise": "^7.3.0",
-    "rimraf": "^6.1.3",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.11"
-  },
-  "directories": {
-    "test": "test"
-  }
-}
+{
+  "name": "@attlaz/client",
+  "version": "1.116.0",
+  "description": "Javascript Client to access Attlaz API",
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "type": "module",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "default": "./dist/*",
+      "types": "./dist/*"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Attlaz-Platform/JS-Client.git"
+  },
+  "homepage": "https://attlaz.com",
+  "keywords": [
+    "attlaz",
+    "client",
+    "http",
+    "api"
+  ],
+  "files": [
+    "dist/*"
+  ],
+  "sideEffects": false,
+  "author": "Stijn Duynslaeger <stijn@attlaz.com> (stijn@attlaz.com)",
+  "license": "MIT",
+  "scripts": {
+    "prebuild": "npm run setversion",
+    "prepublishOnly": "npm run typecheck && npm test",
+    "prepare": "npm run clean && tsc --project tsconfig.build.json && npm run setversion",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "setversion": "node -p \"'export const VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/version.ts",
+    "clean": "rimraf dist",
+    "scan": "docker run -v .:/path zricethezav/gitleaks:latest detect --source=\"/path\" ",
+    "test": "vitest run --mode unit",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "test-integration": "vitest run --mode integration",
+    "test-live": "vitest --mode unit"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.0",
+    "@typescript-eslint/eslint-plugin": "^8.59.3",
+    "@typescript-eslint/parser": "^8.59.3",
+    "eslint": "^9.39.5",
+    "eslint-config-attlaz-base": "^1.8.0",
+    "eslint-import-resolver-typescript": "^4.4.5",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jsdoc": "^62.9.0",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "eslint-plugin-promise": "^7.3.0",
+    "rimraf": "^6.1.3",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.11"
+  },
+  "directories": {
+    "test": "test"
+  }
+}