@attlaz/client 1.77.1

package/README.md

@@ -0,0 +1,30 @@
+Attlaz Javascript/Node client
+==========
+
+[Attlaz](https://attlaz.com) is a cloud-based iPaas (Integration Platform as a Service), automation and data management
+platform.
+
+[![Latest Stable Version](https://img.shields.io/npm/v/@attlaz/client.svg)](https://www.npmjs.com/package/@attlaz/client)
+
+Getting Started
+---------------
+
+Install Attlaz using `yarn`:
+
+```bash
+yarn add attlaz-client
+```
+
+Or npm, if you wish:
+
+```bash
+npm install attlaz-client
+```
+
+Getting Help
+------------
+
+* [Issue Tracker](https://github.com/Attlaz-Platform) for questions, feature requests, bug reports and
+  general discussion related to these packages. Try searching before you create a new issue.
+* Check the [Attlaz Documentation](https://docs.attlaz.com).
+* [Email us](developers@attlaz.com) in Attlaz developer support: `developers@attlaz.com`

package/dist/AttlazResource.d.ts

@@ -0,0 +1,3 @@
+export declare class AttlazResource {
+    convertToAttlazObject(data: any, opts: any): void;
+}

package/dist/AttlazResource.js

@@ -0,0 +1,4 @@
+export class AttlazResource {
+    convertToAttlazObject(data, opts) {
+    }
+}

package/dist/Client.d.ts

@@ -0,0 +1,114 @@
+import { OAuthClientToken } from './Http/OAuthClientToken.js';
+import { ITransport, ParseErrorHandler } from './Http/Transport/ITransport.js';
+import { OAuthClient } from './Http/Transport/OAuthClient.js';
+import { AccessTokenEndpoint } from './Service/AccessTokenEndpoint.js';
+import { AdapterConnectionEndpoint } from './Service/AdapterConnectionEndpoint.js';
+import { AdapterEndpoint } from './Service/AdapterEndpoint.js';
+import { ChannelEndpoint } from './Service/ChannelEndpoint.js';
+import { CodeDeployEndpoint } from './Service/CodeDeployEndpoint.js';
+import { CodeSourceStrategiesEndpoint } from './Service/CodeSourceStrategiesEndpoint.js';
+import { CollectionsEndpoint } from './Service/CollectionsEndpoint.js';
+import { CommandExecutionEndpoint } from './Service/CommandExecutionEndpoint.js';
+import { ConfigEndpoint } from './Service/ConfigEndpoint.js';
+import { ConfigurationEndpoint } from './Service/ConfigurationEndpoint.js';
+import { FirewallEndpoint } from './Service/FirewallEndpoint.js';
+import { FlowEndpoint } from './Service/FlowEndpoint.js';
+import { FlowRunEndpoint } from './Service/FlowRunEndpoint.js';
+import { FlowRunRequestEndpoint } from './Service/FlowRunRequestEndpoint.js';
+import { FlowRunStatsEndpoint } from './Service/FlowRunStatsEndpoint.js';
+import { HealthAlertEndpoint } from './Service/HealthAlertEndpoint.js';
+import { InboxEndpoint } from './Service/InboxEndpoint.js';
+import { LogEndpoint } from './Service/LogEndpoint.js';
+import { PlatformEndpoint } from './Service/PlatformEndpoint.js';
+import { PlatformLanguageEndpoint } from './Service/PlatformLanguageEndpoint.js';
+import { ProjectEndpoint } from './Service/ProjectEndpoint.js';
+import { ProjectEnvironmentEndpoint } from './Service/ProjectEnvironmentEndpoint.js';
+import { ProviderTokenEndpoint } from './Service/ProviderTokenEndpoint.js';
+import { RunnerEndpoint } from './Service/RunnerEndpoint.js';
+import { RunnerPoolEndpoint } from './Service/RunnerPoolEndpoint.js';
+import { SearchEndpoint } from './Service/SearchEndpoint.js';
+import { SourcesAccountEndpoint } from './Service/SourcesAccountEndpoint.js';
+import { StorageEndpoint } from './Service/StorageEndpoint.js';
+import { SubscriberEndpoint } from './Service/SubscriberEndpoint.js';
+import { TriggerEndpoint } from './Service/TriggerEndpoint.js';
+import { UserActionEndpoint } from './Service/UserActionEndpoint.js';
+import { UserEndpoint } from './Service/UserEndpoint.js';
+import { WorkspaceEndpoint } from './Service/WorkspaceEndpoint.js';
+import { WorkspaceMemberEndpoint } from './Service/WorkspaceMemberEndpoint.js';
+export declare class Client {
+    private readonly endpoints;
+    private httpClient;
+    private transport;
+    private readonly Store;
+    private readonly apiEndpoint;
+    constructor(token?: string | null, config?: {
+        apiEndpoint?: string;
+    });
+    /**
+     * Create a Client that uses a custom transport instead of OAuth.
+     * Intended for internal service-to-service calls (e.g. using DirectTransport).
+     */
+    static withTransport(transport: ITransport, config?: {
+        apiEndpoint: string | undefined;
+    }): Client;
+    setClientCredentials(clientId: string, clientSecret?: string): void;
+    /**
+     * Configure this client as a public OAuth client (no client_secret).
+     * Used for SPAs and other public clients that cannot keep a secret.
+     */
+    setPublicClient(clientId: string): void;
+    setVersion(version: string | null): void;
+    getHttpClient(): OAuthClient;
+    /**
+     * Set a handler for non-fatal response parse failures (schema drift). Defaults to
+     * console.error; wire this to your logger / error tracker to observe drift in production
+     * without breaking views. Pass null to restore the default. Set on the active transport,
+     * so it applies whether the client uses OAuth or a custom transport.
+     */
+    setParseErrorHandler(handler: ParseErrorHandler | null): void;
+    authenticate(): Promise<boolean>;
+    authenticate(username: string, password: string): Promise<boolean>;
+    isAuthenticated(): boolean;
+    getToken(): OAuthClientToken | null;
+    setToken(token: OAuthClientToken): void;
+    unsetAccessToken(): void;
+    getApiInformation(): Promise<{
+        version: string;
+    }>;
+    getAdapterEndpoint(): AdapterEndpoint;
+    getAdapterConnectionEndpoint(): AdapterConnectionEndpoint;
+    getProjectEndpoint(): ProjectEndpoint;
+    getProjectEnvironmentEndpoint(): ProjectEnvironmentEndpoint;
+    getCodeDeployEndpoint(): CodeDeployEndpoint;
+    getChannelEndpoint(): ChannelEndpoint;
+    getConfigEndpoint(): ConfigEndpoint;
+    getInboxEndpoint(): InboxEndpoint;
+    getPlatformEndpoint(): PlatformEndpoint;
+    getSubscriberEndpoint(): SubscriberEndpoint;
+    getLogEndPoint(): LogEndpoint;
+    getFlowEndpoint(): FlowEndpoint;
+    getFlowRunEndpoint(): FlowRunEndpoint;
+    getFlowRunRequestEndpoint(): FlowRunRequestEndpoint;
+    getFlowRunStatsEndpoint(): FlowRunStatsEndpoint;
+    getWorkspaceEndpoint(): WorkspaceEndpoint;
+    getTriggerEndpoint(): TriggerEndpoint;
+    getUserEndpoint(): UserEndpoint;
+    getWorkspaceMemberEndpoint(): WorkspaceMemberEndpoint;
+    getRunnerEndpoint(): RunnerEndpoint;
+    getSourcesAccountEndpoint(): SourcesAccountEndpoint;
+    getLanguageEndpoint(): PlatformLanguageEndpoint;
+    getStorageEndpoint(): StorageEndpoint;
+    getConfigurationEndpoint(): ConfigurationEndpoint;
+    getHealthAlertEndpoint(): HealthAlertEndpoint;
+    getCodeSourceStrategiesEndpoint(): CodeSourceStrategiesEndpoint;
+    getSearchEndpoint(): SearchEndpoint;
+    getUserActionEndpoint(): UserActionEndpoint;
+    getCommandExecutionEndpoint(): CommandExecutionEndpoint;
+    getAccessTokenEndpoint(): AccessTokenEndpoint;
+    getCollectionsEndpoint(): CollectionsEndpoint;
+    getRunnerPoolEndpoint(): RunnerPoolEndpoint;
+    getProviderTokenEndpoint(): ProviderTokenEndpoint;
+    getFirewallEndpoint(): FirewallEndpoint;
+    private getEndpoint;
+    getVersion(): string;
+}

package/dist/Client.js

@@ -0,0 +1,278 @@
+import { OAuthClientOptions } from './Http/OAuthClientOptions.js';
+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 { AdapterEndpoint } from './Service/AdapterEndpoint.js';
+import { ChannelEndpoint } from './Service/ChannelEndpoint.js';
+import { CodeDeployEndpoint } from './Service/CodeDeployEndpoint.js';
+import { CodeSourceStrategiesEndpoint } from './Service/CodeSourceStrategiesEndpoint.js';
+import { CollectionsEndpoint } from './Service/CollectionsEndpoint.js';
+import { CommandExecutionEndpoint } from './Service/CommandExecutionEndpoint.js';
+import { ConfigEndpoint } from './Service/ConfigEndpoint.js';
+import { ConfigurationEndpoint } from './Service/ConfigurationEndpoint.js';
+import { FirewallEndpoint } from './Service/FirewallEndpoint.js';
+import { FlowEndpoint } from './Service/FlowEndpoint.js';
+import { FlowRunEndpoint } from './Service/FlowRunEndpoint.js';
+import { FlowRunRequestEndpoint } from './Service/FlowRunRequestEndpoint.js';
+import { FlowRunStatsEndpoint } from './Service/FlowRunStatsEndpoint.js';
+import { HealthAlertEndpoint } from './Service/HealthAlertEndpoint.js';
+import { InboxEndpoint } from './Service/InboxEndpoint.js';
+import { LogEndpoint } from './Service/LogEndpoint.js';
+import { PlatformEndpoint } from './Service/PlatformEndpoint.js';
+import { PlatformLanguageEndpoint } from './Service/PlatformLanguageEndpoint.js';
+import { ProjectEndpoint } from './Service/ProjectEndpoint.js';
+import { ProjectEnvironmentEndpoint } from './Service/ProjectEnvironmentEndpoint.js';
+import { ProviderTokenEndpoint } from './Service/ProviderTokenEndpoint.js';
+import { RunnerEndpoint } from './Service/RunnerEndpoint.js';
+import { RunnerPoolEndpoint } from './Service/RunnerPoolEndpoint.js';
+import { SearchEndpoint } from './Service/SearchEndpoint.js';
+import { SourcesAccountEndpoint } from './Service/SourcesAccountEndpoint.js';
+import { StorageEndpoint } from './Service/StorageEndpoint.js';
+import { SubscriberEndpoint } from './Service/SubscriberEndpoint.js';
+import { TriggerEndpoint } from './Service/TriggerEndpoint.js';
+import { UserActionEndpoint } from './Service/UserActionEndpoint.js';
+import { UserEndpoint } from './Service/UserEndpoint.js';
+import { WorkspaceEndpoint } from './Service/WorkspaceEndpoint.js';
+import { WorkspaceMemberEndpoint } from './Service/WorkspaceMemberEndpoint.js';
+import { VERSION } from './version.js';
+export class Client {
+    endpoints = new Map();
+    httpClient;
+    transport;
+    Store = {
+        AccessTokenEndpoint,
+        AdapterConnectionEndpoint,
+        AdapterEndpoint,
+        ChannelEndpoint,
+        CodeDeployEndpoint,
+        CodeSourceStrategiesEndpoint,
+        CommandExecutionEndpoint,
+        ConfigEndpoint,
+        FirewallEndpoint,
+        FlowEndpoint,
+        FlowRunEndpoint,
+        FlowRunRequestEndpoint,
+        FlowRunStatsEndpoint,
+        HealthAlertEndpoint,
+        InboxEndpoint,
+        LogEndpoint,
+        PlatformEndpoint,
+        PlatformLanguageEndpoint,
+        ProjectEndpoint,
+        ProjectEnvironmentEndpoint,
+        SearchEndpoint,
+        SourcesAccountEndpoint,
+        StorageEndpoint,
+        SubscriberEndpoint,
+        TriggerEndpoint,
+        UserActionEndpoint,
+        UserEndpoint,
+        ConfigurationEndpoint,
+        RunnerEndpoint,
+        WorkspaceEndpoint,
+        WorkspaceMemberEndpoint,
+        CollectionsEndpoint,
+        RunnerPoolEndpoint,
+        ProviderTokenEndpoint,
+    };
+    apiEndpoint = 'https://api.attlaz.com';
+    constructor(token = null, config = {}) {
+        if (config.apiEndpoint !== undefined) {
+            this.apiEndpoint = config.apiEndpoint;
+        }
+        const options = new OAuthClientOptions(this.apiEndpoint);
+        this.httpClient = new OAuthClient(options);
+        if (token !== null) {
+            const clientToken = new OAuthClientToken(token, 'Bearer', '', '');
+            this.httpClient.setToken(clientToken);
+        }
+        this.transport = this.httpClient;
+    }
+    /**
+     * Create a Client that uses a custom transport instead of OAuth.
+     * Intended for internal service-to-service calls (e.g. using DirectTransport).
+     */
+    static withTransport(transport, config = { apiEndpoint: undefined }) {
+        const client = new Client(null, config);
+        client.transport = transport;
+        return client;
+    }
+    setClientCredentials(clientId, clientSecret = '') {
+        const options = new OAuthClientOptions(this.apiEndpoint, clientId, clientSecret);
+        // TODO: how to know these scopes?
+        options.scopes = ['all'];
+        // TODO: do we need to create a new oauth client, or can we update with these credentials?
+        this.httpClient = new OAuthClient(options);
+        this.transport = this.httpClient;
+    }
+    /**
+     * Configure this client as a public OAuth client (no client_secret).
+     * Used for SPAs and other public clients that cannot keep a secret.
+     */
+    setPublicClient(clientId) {
+        const options = new OAuthClientOptions(this.apiEndpoint, clientId, null);
+        options.scopes = ['all'];
+        this.httpClient = new OAuthClient(options);
+        this.transport = this.httpClient;
+    }
+    setVersion(version) {
+        this.httpClient.setVersion(version);
+    }
+    getHttpClient() {
+        return this.httpClient;
+    }
+    /**
+     * Set a handler for non-fatal response parse failures (schema drift). Defaults to
+     * console.error; wire this to your logger / error tracker to observe drift in production
+     * without breaking views. Pass null to restore the default. Set on the active transport,
+     * so it applies whether the client uses OAuth or a custom transport.
+     */
+    setParseErrorHandler(handler) {
+        this.transport.setParseErrorHandler(handler);
+    }
+    async authenticate(username = null, password = null) {
+        if (username === null || password === null) {
+            return await this.httpClient.authenticate();
+        }
+        // TODO: this is only possible when clientId and clientSecret are defined
+        return await this.httpClient.authenticate(username, password);
+    }
+    isAuthenticated() {
+        return this.httpClient.isAuthenticated();
+    }
+    getToken() {
+        return this.httpClient.getToken();
+    }
+    setToken(token) {
+        this.httpClient.setToken(token);
+    }
+    unsetAccessToken() {
+        this.httpClient.unsetToken();
+    }
+    async getApiInformation() {
+        const result = await this.httpClient.request('/system/health', null, 'GET', false);
+        if (result.version === undefined) {
+            throw new Error('Unable to get API information: invalid response');
+        }
+        return { version: result.version };
+    }
+    /* Endpoints */
+    getAdapterEndpoint() {
+        return this.getEndpoint('adapter', this.Store.AdapterEndpoint);
+    }
+    getAdapterConnectionEndpoint() {
+        return this.getEndpoint('adapter-connection', this.Store.AdapterConnectionEndpoint);
+    }
+    getProjectEndpoint() {
+        return this.getEndpoint('project', this.Store.ProjectEndpoint);
+    }
+    getProjectEnvironmentEndpoint() {
+        return this.getEndpoint('project-environment', this.Store.ProjectEnvironmentEndpoint);
+    }
+    getCodeDeployEndpoint() {
+        return this.getEndpoint('code-deploy', this.Store.CodeDeployEndpoint);
+    }
+    getChannelEndpoint() {
+        return this.getEndpoint('channel', this.Store.ChannelEndpoint);
+    }
+    getConfigEndpoint() {
+        return this.getEndpoint('config', this.Store.ConfigEndpoint);
+    }
+    getInboxEndpoint() {
+        return this.getEndpoint('inbox', this.Store.InboxEndpoint);
+    }
+    getPlatformEndpoint() {
+        return this.getEndpoint('platform', this.Store.PlatformEndpoint);
+    }
+    getSubscriberEndpoint() {
+        return this.getEndpoint('subscriber', this.Store.SubscriberEndpoint);
+    }
+    getLogEndPoint() {
+        return this.getEndpoint('log', this.Store.LogEndpoint);
+    }
+    getFlowEndpoint() {
+        return this.getEndpoint('flow', this.Store.FlowEndpoint);
+    }
+    getFlowRunEndpoint() {
+        return this.getEndpoint('flow-run', this.Store.FlowRunEndpoint);
+    }
+    getFlowRunRequestEndpoint() {
+        return this.getEndpoint('flow-run-request', this.Store.FlowRunRequestEndpoint);
+    }
+    getFlowRunStatsEndpoint() {
+        return this.getEndpoint('flow-run-stats', this.Store.FlowRunStatsEndpoint);
+    }
+    getWorkspaceEndpoint() {
+        return this.getEndpoint('workspaces', this.Store.WorkspaceEndpoint);
+    }
+    getTriggerEndpoint() {
+        return this.getEndpoint('trigger', this.Store.TriggerEndpoint);
+    }
+    getUserEndpoint() {
+        return this.getEndpoint('user', this.Store.UserEndpoint);
+    }
+    getWorkspaceMemberEndpoint() {
+        return this.getEndpoint('member', this.Store.WorkspaceMemberEndpoint);
+    }
+    getRunnerEndpoint() {
+        return this.getEndpoint('worker', this.Store.RunnerEndpoint);
+    }
+    getSourcesAccountEndpoint() {
+        return this.getEndpoint('sources-account', this.Store.SourcesAccountEndpoint);
+    }
+    getLanguageEndpoint() {
+        return this.getEndpoint('language', this.Store.PlatformLanguageEndpoint);
+    }
+    getStorageEndpoint() {
+        return this.getEndpoint('storage', this.Store.StorageEndpoint);
+    }
+    getConfigurationEndpoint() {
+        return this.getEndpoint('configuration', this.Store.ConfigurationEndpoint);
+    }
+    getHealthAlertEndpoint() {
+        return this.getEndpoint('health-alert', this.Store.HealthAlertEndpoint);
+    }
+    getCodeSourceStrategiesEndpoint() {
+        return this.getEndpoint('code-source-strategies', this.Store.CodeSourceStrategiesEndpoint);
+    }
+    getSearchEndpoint() {
+        return this.getEndpoint('search', this.Store.SearchEndpoint);
+    }
+    getUserActionEndpoint() {
+        return this.getEndpoint('useraction', this.Store.UserActionEndpoint);
+    }
+    getCommandExecutionEndpoint() {
+        return this.getEndpoint('commandexecution', this.Store.CommandExecutionEndpoint);
+    }
+    getAccessTokenEndpoint() {
+        return this.getEndpoint('accesstoken', this.Store.AccessTokenEndpoint);
+    }
+    getCollectionsEndpoint() {
+        return this.getEndpoint('collections', this.Store.CollectionsEndpoint);
+    }
+    getRunnerPoolEndpoint() {
+        return this.getEndpoint('runner_pool', this.Store.RunnerPoolEndpoint);
+    }
+    getProviderTokenEndpoint() {
+        return this.getEndpoint('provider_token', this.Store.ProviderTokenEndpoint);
+    }
+    getFirewallEndpoint() {
+        return this.getEndpoint('firewall', this.Store.FirewallEndpoint);
+    }
+    getEndpoint(key, ClassName) {
+        if (!this.endpoints.has(key)) {
+            try {
+                this.endpoints.set(key, new ClassName(this.transport));
+            }
+            catch (error) {
+                const errorMsg = (error !== null && typeof error === 'object' && 'message' in error && typeof error.message === 'string') ? error.message : 'Unknown';
+                throw new Error('Unable to initialize ' + key + ' endpoint (' + errorMsg + ')');
+            }
+        }
+        return this.endpoints.get(key);
+    }
+    getVersion() {
+        return VERSION;
+    }
+}

package/dist/Core/MetaDataAware.d.ts

@@ -0,0 +1,11 @@
+import { DataValueCollection } from '../Model/DataValueCollection.js';
+import { ApiRecord } from '../Model/ApiRecord.js';
+export declare abstract class MetaDataAware {
+    abstract id: string;
+    name: string;
+    description: string | null;
+    metadata: DataValueCollection;
+    updatedAt: Date | null;
+    createdAt: Date | null;
+    static parseMetaData<T extends MetaDataAware>(input: T, raw: ApiRecord): T;
+}

package/dist/Core/MetaDataAware.js

@@ -0,0 +1,27 @@
+import { DataValueCollection } from '../Model/DataValueCollection.js';
+import { Utils } from '../Utils.js';
+export class MetaDataAware {
+    name;
+    description = null;
+    // public icon: string | null = null;
+    metadata;
+    updatedAt = null;
+    createdAt = null;
+    static parseMetaData(input, raw) {
+        input.id = raw.id;
+        input.name = raw.name;
+        input.description = raw.description;
+        // input.icon = raw.icon as string | null;
+        // TODO: parse meta data
+        if (Object.prototype.hasOwnProperty.call(raw, 'metadata')) {
+            // input.metadata = DataValueCollection.fromObject(raw.metadata as any);
+            input.metadata = DataValueCollection.fromObject(raw.metadata);
+        }
+        else {
+            input.metadata = new DataValueCollection();
+        }
+        input.updatedAt = (raw.updated === null || raw.updated === undefined) ? null : Utils.parseRawDate(raw.updated);
+        input.createdAt = (raw.created === null || raw.created === undefined) ? null : Utils.parseRawDate(raw.created);
+        return input;
+    }
+}

package/dist/Core/MetaDataWithIconAware.d.ts

@@ -0,0 +1,13 @@
+import { ApiRecord } from '../Model/ApiRecord.js';
+import { DataValueCollection } from '../Model/DataValueCollection.js';
+export declare abstract class MetaDataWithIconAware {
+    abstract id: string;
+    icon: string | null;
+    name: string;
+    description: string | null;
+    metadata: DataValueCollection;
+    updatedAt: Date | null;
+    createdAt: Date | null;
+    static parseMetaData<T extends MetaDataWithIconAware>(input: T, raw: ApiRecord): T;
+    static parseIcon(icon: unknown): string | null;
+}

package/dist/Core/MetaDataWithIconAware.js

@@ -0,0 +1,26 @@
+import { MetaDataAware } from './MetaDataAware.js';
+export class MetaDataWithIconAware {
+    icon;
+    name;
+    description = null;
+    metadata;
+    updatedAt = null;
+    createdAt = null;
+    static parseMetaData(input, raw) {
+        input = MetaDataAware.parseMetaData(input, raw);
+        input.icon = MetaDataWithIconAware.parseIcon(raw.icon);
+        return input;
+    }
+    static parseIcon(icon) {
+        if (icon === null) {
+            return null;
+        }
+        if (typeof icon === 'object') {
+            if ('type' in icon && 'data' in icon) {
+                return icon.data;
+            }
+            console.log('Icon', { icon });
+        }
+        return icon;
+    }
+}

package/dist/Helper/LoadAllHelper.d.ts

@@ -0,0 +1,8 @@
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { EntityId } from '../Model/EntityId.js';
+export declare class LoadAllHelper {
+    static loadAll<T extends {
+        id: string | EntityId;
+    }>(call: (pagination: CursorPagination) => Promise<CollectionResult<T>>, limit?: number): Promise<T[]>;
+}

package/dist/Helper/LoadAllHelper.js

@@ -0,0 +1,25 @@
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+export class LoadAllHelper {
+    static async loadAll(call, limit = 100) {
+        const totalResult = [];
+        let hasMore = true;
+        let lastRef = null;
+        while (hasMore) {
+            const firstPagination = new CursorPagination();
+            firstPagination.limit = limit;
+            firstPagination.startingAfter = lastRef;
+            const data = await call(firstPagination);
+            const records = data.getData();
+            // Spread is faster than a per-element loop but can exceed the call stack for very large collections (50k+)
+            if (totalResult.length + records.length > 50_000) {
+                throw new Error('loadAll exceeded 50,000 records (' + (totalResult.length + records.length) + '). This method is not intended for large datasets.');
+            }
+            totalResult.push(...records);
+            if (records.length > 0) {
+                lastRef = records[records.length - 1].id.toString();
+            }
+            hasMore = data.hasMore;
+        }
+        return totalResult;
+    }
+}

package/dist/Helper/ResponseParser.d.ts

@@ -0,0 +1,2 @@
+export declare class ResponseParser {
+}

package/dist/Helper/ResponseParser.js

@@ -0,0 +1,2 @@
+export class ResponseParser {
+}

package/dist/Http/ClientError.d.ts

@@ -0,0 +1,22 @@
+export declare class ClientError extends Error {
+    httpStatus: number | null;
+    message: string;
+    response: unknown;
+    constructor(message: string, httpErrorCode?: number | null);
+    /**
+     * Type guard: true when `error` is a ClientError (or a subclass such as ApiError). Use it to
+     * narrow before reading typed fields (`httpStatus`, `message`, …). Relies on instanceof, which
+     * is reliable when there's a single copy of this package (e.g. a bundled web app). For a status
+     * check that must survive multiple package copies / realm boundaries, prefer statusOf().
+     */
+    static is(error: unknown): error is ClientError;
+    /**
+     * The HTTP status carried by a ClientError/ApiError, or null for anything else (e.g. a plain
+     * Error or a non-error value). Robust across module/realm boundaries: when instanceof fails
+     * (two copies of this package in one process) it falls back to reading a numeric httpStatus
+     * field. This is the safe way to ask "what status did this error carry?".
+     */
+    static statusOf(error: unknown): number | null;
+    static fromError(error: Error): ClientError;
+    static byStatus(statusCode: number, statusText: string): ClientError | null;
+}

package/dist/Http/ClientError.js

@@ -0,0 +1,79 @@
+import { HttpStatus } from './HttpStatus.js';
+export class ClientError extends Error {
+    httpStatus = null;
+    message;
+    response;
+    constructor(message, httpErrorCode = null) {
+        super(message);
+        this.message = message;
+        this.httpStatus = httpErrorCode;
+    }
+    /**
+     * Type guard: true when `error` is a ClientError (or a subclass such as ApiError). Use it to
+     * narrow before reading typed fields (`httpStatus`, `message`, …). Relies on instanceof, which
+     * is reliable when there's a single copy of this package (e.g. a bundled web app). For a status
+     * check that must survive multiple package copies / realm boundaries, prefer statusOf().
+     */
+    static is(error) {
+        return error instanceof ClientError;
+    }
+    /**
+     * The HTTP status carried by a ClientError/ApiError, or null for anything else (e.g. a plain
+     * Error or a non-error value). Robust across module/realm boundaries: when instanceof fails
+     * (two copies of this package in one process) it falls back to reading a numeric httpStatus
+     * field. This is the safe way to ask "what status did this error carry?".
+     */
+    static statusOf(error) {
+        if (error instanceof ClientError) {
+            return error.httpStatus;
+        }
+        const status = error?.httpStatus;
+        return typeof status === 'number' ? status : null;
+    }
+    static fromError(error) {
+        // Already a ClientError (or a subclass such as ApiError) — preserve it as-is.
+        if (error instanceof ClientError) {
+            return error;
+        }
+        // The transport uses fetch, which throws TypeError on network failures (DNS, refused
+        // connection, TLS, etc.). Anything else reaching here is unexpected — surface it as a
+        // generic 500 while keeping the original name/stack for debugging.
+        const clientError = error instanceof TypeError
+            ? new ClientError('Service not available', HttpStatus.HTTP_UNAVAILABLE)
+            : new ClientError('Unknown error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
+        clientError.name = error.name;
+        clientError.stack = error.stack;
+        return clientError;
+    }
+    static byStatus(statusCode, statusText) {
+        switch (statusCode) {
+            case 200:
+            case 201:
+            case 202:
+                return null;
+            case 400:
+                return new ClientError('Bad Request', HttpStatus.HTTP_BAD_REQUEST);
+            case 401:
+                return new ClientError('Unauthorized', HttpStatus.HTTP_UNAUTHORIZED);
+            case 403:
+                return new ClientError('Forbidden', HttpStatus.HTTP_FORBIDDEN);
+            case 404:
+                return new ClientError('Not Found', HttpStatus.HTTP_NOTFOUND);
+            case 405:
+                return new ClientError('Not allowed', HttpStatus.HTTP_NOT_ALLOWED);
+            case 422:
+                return new ClientError('Unprocessable Entity', HttpStatus.HTTP_UNPROCESSABLE_ENTITY);
+            case 500:
+                return new ClientError('Internal Server Error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
+            case 502:
+                return new ClientError('Bad gateway', HttpStatus.HTTP_BAD_GATEWAY);
+            case 503:
+                return new ClientError('Service not available', HttpStatus.HTTP_UNAVAILABLE);
+            case 504:
+                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);
+        }
+    }
+}

package/dist/Http/ContentTypeHelper.d.ts

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