@appweaver/client 1.0.23 → 1.0.25

package/esm/clients/modules/resource-client.js

@@ -0,0 +1,173 @@
+import { BaseModule } from './base-module.js';
+export class ResourceClient extends BaseModule {
+    basePath;
+    constructor(client, basePath) {
+        super(client);
+        this.basePath = basePath;
+    }
+    /**
+     * Fetches a single resource by its numeric ID.
+     *
+     * @param {number} id - The ID of the resource to retrieve.
+     * @param {RequestOptions} options - Additional request options (headers, query params, etc.).
+     * @returns The resource record matching the given ID.
+     */
+    async find(id, options = {}) {
+        return this.sendRequest('get', `${this.basePath}/{id}`, {
+            ...options,
+            params: {
+                ...(options.params ?? {}),
+                path: {
+                    id
+                }
+            }
+        });
+    }
+    /**
+     * Executes a query against the resource collection.
+     *
+     * @param {Object} request - The query payload (filters, sorting, pagination, etc.).
+     * @param {RequestOptions}  options - Additional request options.
+     * @returns A paginated or filtered list of matching resource records.
+     */
+    async query(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/query`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Runs an aggregation query (e.g., count, sum, avg) against the resource collection.
+     *
+     * @param {Object} request - The aggregation payload describing the desired computation.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The aggregated result for the given query.
+     */
+    async aggregate(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/aggregate`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Creates a new resource record.
+     *
+     * @param {Object} resource - The data for the resource to create.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The newly created resource record.
+     */
+    async create(resource, options = {}) {
+        return this.sendRequest('post', `${this.basePath}`, {
+            ...options,
+            body: resource
+        });
+    }
+    /**
+     * Updates an existing resource record identified by `id`.
+     *
+     * @param {Object} resource - The updated field values including the mandatory `id`.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The updated resource record.
+     */
+    async update(resource, options = {}) {
+        return this.sendRequest('put', `${this.basePath}/{id}`, {
+            ...options,
+            params: {
+                ...(options.params ?? {}),
+                path: {
+                    id: resource['id']
+                }
+            },
+            body: resource
+        });
+    }
+    /**
+     * Deletes a resource record by its numeric ID.
+     *
+     * @param {number} id - The ID of the resource to delete.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The deleted resource record.
+     */
+    async delete(id, options = {}) {
+        return this.sendRequest('delete', `${this.basePath}/{id}`, {
+            ...options,
+            params: {
+                ...(options.params ?? {}),
+                path: {
+                    id
+                }
+            }
+        });
+    }
+    /**
+     * Exports resource records as a file (e.g., CSV) and returns a streaming response.
+     *
+     * @param {Object} request - The export request payload (filters, format, etc.).
+     * @param {RequestOptions} options - Additional request options.
+     * @returns {@link FileDataResponse} containing the readable stream and file metadata.
+     */
+    async export(request, options = {}) {
+        const { error, response } = await this.sendRequestRaw('post', `${this.basePath}/export`, {
+            ...options,
+            parseAs: 'stream',
+            body: request
+        });
+        if (error) {
+            this.handleError(error, response);
+        }
+        return this.toFileResponse(response);
+    }
+    /**
+     * Uploads one or more files to the resource record.
+     *
+     * Each entry in `files` maps a field name to a single `File` or an array of `File` objects.
+     *
+     * @param {number} id - The ID of the resource for which to upload files.
+     * @param {Object} files - A map of field names to the file(s) to upload.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The updated file metadata for the resource.
+     */
+    async uploadFiles(id, files, options = {}) {
+        const formData = new FormData();
+        for (const [fieldName, fileData] of Object.entries(files)) {
+            if (Array.isArray(fileData)) {
+                for (const file of fileData) {
+                    formData.append(fieldName, file);
+                }
+            }
+            else {
+                formData.append(fieldName, fileData);
+            }
+        }
+        return this.sendRequest('post', `${this.basePath}/{id}/files`, {
+            ...options,
+            body: formData,
+            params: {
+                ...(options.params ?? {}),
+                path: {
+                    id
+                }
+            }
+        });
+    }
+    /**
+     * Removes specific files from the resource record.
+     *
+     * @param {number} id - The ID of the resource for which to delete files.
+     * @param {Object} files - The file deletion payload identifying which files to remove.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The updated file metadata for the resource after deletion.
+     */
+    async deleteFiles(id, files, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/{id}/delete-files`, {
+            ...options,
+            body: files,
+            params: {
+                ...(options.params ?? {}),
+                path: {
+                    id
+                }
+            }
+        });
+    }
+}

package/esm/clients/responses/file-data-response.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Response object containing file data and metadata from a file download request.
+ * Provides helper methods to consume the stream as text, base64 data URL, or Buffer.
+ */
+export declare class FileDataResponse {
+    /** Readable stream of the file content. */
+    readonly stream: ReadableStream;
+    /** Name of the file extracted from the Content-Disposition header or provided default. */
+    readonly fileName: string;
+    /** MIME type of the file from the Content-Type header. */
+    readonly type: string;
+    /** Size of the file in bytes from the Content-Length header. */
+    readonly length: number;
+    /** Range information if the response is a partial content response (HTTP 206). */
+    readonly range?: FileContentRange;
+    /** Cache duration in seconds from the Cache-Control max-age directive. */
+    readonly maxAge?: number;
+    /** Expiration timestamp from Expires header. */
+    readonly expiresAt?: string;
+    private _buffer;
+    constructor(data: {
+        stream: ReadableStream;
+        fileName: string;
+        type: string;
+        length: number;
+        range?: FileContentRange;
+        maxAge?: number;
+        expiresAt?: string;
+    });
+    /**
+     * Reads and returns the content of the buffer as an ArrayBuffer.
+     *
+     * @return {Promise<ArrayBuffer>} A promise that resolves to an ArrayBuffer containing the data read from the buffer.
+     */
+    buffer(): Promise<ArrayBuffer>;
+    /**
+     * Reads and returns the content of the buffer as a Blob object.
+     *
+     * The method reads an ArrayBuffer from an internal data source, then constructs,
+     * and returns a Blob object using the buffer's content and a specified MIME type.
+     *
+     * @return {Promise<Blob>} A promise that resolves to a Blob object containing the read data.
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Reads and decodes the content of the buffer into a string using the TextDecoder API.
+     *
+     * @param {string} encoding - The character encoding to use for decoding. Defaults to 'utf-8'.
+     * @return {Promise<string>} A promise that resolves to the decoded string.
+     */
+    text(encoding?: string): Promise<string>;
+    /**
+     * Reads and converts the buffer into a Base64-encoded data URL string.
+     *
+     * @return {Promise<string>} A promise that resolves to a Base64-encoded string
+     * representing the file, prefixed with the appropriate data MIME type.
+     */
+    base64(): Promise<string>;
+    /**
+     * Reads and concatenates data chunks from a readable stream into a single ArrayBuffer.
+     * If the buffer has already been read, it returns the cached ArrayBuffer.
+     *
+     * @return {Promise<ArrayBuffer>} A promise that resolves to the ArrayBuffer containing
+     * the concatenated data from the stream.
+     */
+    private _readArrayBuffer;
+}
+/**
+ * Represents byte range information for partial content responses.
+ */
+export type FileContentRange = {
+    /** Starting byte position of the range (inclusive). */
+    start: number;
+    /** Ending byte position of the range (inclusive). */
+    end: number;
+    /** Total size of the complete file in bytes. */
+    total: number;
+};

package/esm/clients/responses/file-data-response.js

@@ -0,0 +1,105 @@
+/**
+ * Response object containing file data and metadata from a file download request.
+ * Provides helper methods to consume the stream as text, base64 data URL, or Buffer.
+ */
+export class FileDataResponse {
+    /** Readable stream of the file content. */
+    stream;
+    /** Name of the file extracted from the Content-Disposition header or provided default. */
+    fileName;
+    /** MIME type of the file from the Content-Type header. */
+    type;
+    /** Size of the file in bytes from the Content-Length header. */
+    length;
+    /** Range information if the response is a partial content response (HTTP 206). */
+    range;
+    /** Cache duration in seconds from the Cache-Control max-age directive. */
+    maxAge;
+    /** Expiration timestamp from Expires header. */
+    expiresAt;
+    _buffer;
+    constructor(data) {
+        this.stream = data.stream;
+        this.fileName = data.fileName;
+        this.type = data.type;
+        this.length = data.length;
+        this.range = data.range;
+        this.maxAge = data.maxAge;
+        this.expiresAt = data.expiresAt;
+    }
+    /**
+     * Reads and returns the content of the buffer as an ArrayBuffer.
+     *
+     * @return {Promise<ArrayBuffer>} A promise that resolves to an ArrayBuffer containing the data read from the buffer.
+     */
+    async buffer() {
+        return this._readArrayBuffer();
+    }
+    /**
+     * Reads and returns the content of the buffer as a Blob object.
+     *
+     * The method reads an ArrayBuffer from an internal data source, then constructs,
+     * and returns a Blob object using the buffer's content and a specified MIME type.
+     *
+     * @return {Promise<Blob>} A promise that resolves to a Blob object containing the read data.
+     */
+    async blob() {
+        const buf = await this._readArrayBuffer();
+        return new Blob([buf], { type: this.type });
+    }
+    /**
+     * Reads and decodes the content of the buffer into a string using the TextDecoder API.
+     *
+     * @param {string} encoding - The character encoding to use for decoding. Defaults to 'utf-8'.
+     * @return {Promise<string>} A promise that resolves to the decoded string.
+     */
+    async text(encoding = 'utf-8') {
+        const buf = await this._readArrayBuffer();
+        return new TextDecoder(encoding).decode(buf);
+    }
+    /**
+     * Reads and converts the buffer into a Base64-encoded data URL string.
+     *
+     * @return {Promise<string>} A promise that resolves to a Base64-encoded string
+     * representing the file, prefixed with the appropriate data MIME type.
+     */
+    async base64() {
+        const buf = await this._readArrayBuffer();
+        const bytes = new Uint8Array(buf);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        const encoded = btoa(binary);
+        return `data:${this.type};base64,${encoded}`;
+    }
+    /**
+     * Reads and concatenates data chunks from a readable stream into a single ArrayBuffer.
+     * If the buffer has already been read, it returns the cached ArrayBuffer.
+     *
+     * @return {Promise<ArrayBuffer>} A promise that resolves to the ArrayBuffer containing
+     * the concatenated data from the stream.
+     */
+    async _readArrayBuffer() {
+        if (this._buffer !== undefined) {
+            return this._buffer;
+        }
+        const reader = this.stream.getReader();
+        const chunks = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+        }
+        const totalLength = chunks.reduce((sum, c) => sum + c.byteLength, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        this._buffer = result.buffer;
+        return this._buffer;
+    }
+}

package/esm/clients/responses/index.d.ts

@@ -0,0 +1 @@
+export * from './file-data-response.js';

package/esm/clients/responses/index.js

@@ -0,0 +1 @@
+export * from './file-data-response.js';

package/esm/commands/generate-command.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function generateCommand(program: Command): void;
+export declare function relativePathFrom(firstPath: string, otherPath: string): string;

package/esm/commands/generate-command.js

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import prettier from 'prettier';
+import { InvalidArgumentError, InvalidOptionArgumentError } from 'commander';
+import { generateClient, generateTypes } from '../generators/index.js';
+import { readSchemaContent, toSchemaObject } from '../utils/index.js';
+import { FRAMEWORKS } from '../constants.js';
+export function generateCommand(program) {
+    program
+        .command('generate')
+        .alias('g')
+        .description('Generates types and client class.')
+        .argument('<schemaPath>', 'The path to the OpenAPI schema (file or URL)', parseSchema)
+        .option('--outputPath [path]', 'Output path for both generated types and client class.', './generated/client.ts')
+        .option('--typesPath [path]', 'Output path for generated types. (default: output path)')
+        .option('--clientPath [path]', 'Output path for generated client class. (default: output path)')
+        .option('--clientName [name]', 'Name for generated client class. (default: OpenAPI schema title)')
+        .option('--framework [name]', `The framework for generated client class (${FRAMEWORKS.join(', ')})`, parseFramework, 'fetch')
+        .option('--typesOnly', 'Generate TypeScript types only (without client class).')
+        .option('--clientOnly', 'Generate only client class (without TypeScript types).')
+        .option('--noTypes', 'Generate client class without TypeScript type support.')
+        .action(async (schemaPath, _, command) => {
+        const outputPath = command.getOptionValue('outputPath');
+        const typesPath = command.getOptionValue('typesPath') || outputPath;
+        const clientPath = command.getOptionValue('clientPath') || outputPath;
+        const clientName = command.getOptionValue('clientName');
+        const framework = command.getOptionValue('framework');
+        const typesOnly = command.getOptionValue('typesOnly');
+        const clientOnly = command.getOptionValue('clientOnly');
+        const noTypes = command.getOptionValue('noTypes');
+        const cwd = process.cwd();
+        const schemaContent = await readSchemaContent(schemaPath);
+        const schemaObject = await toSchemaObject(schemaContent);
+        if (!clientOnly && !noTypes) {
+            const typesContent = await generateTypes(schemaObject);
+            await formatAndWriteFile(typesPath, typesContent, typesOnly || typesPath !== clientPath);
+            console.log(`Generated types to ${path.relative(cwd, typesPath)}`);
+        }
+        if (!typesOnly) {
+            const typesImportPath = typesPath === clientPath
+                ? undefined
+                : relativePathFrom(clientPath, typesPath);
+            const clientContent = await generateClient(schemaObject, clientName, framework, typesImportPath, noTypes);
+            await formatAndWriteFile(clientPath, clientContent, true, typesPath === clientPath);
+            console.log(`Generated client to ${path.relative(cwd, clientPath)}`);
+        }
+    });
+}
+async function formatAndWriteFile(filePath, content, addGeneratedComment = true, appendIfExists = false) {
+    const dirPath = path.resolve(path.dirname(filePath));
+    const dirExists = await pathExists(dirPath);
+    if (!dirExists) {
+        await fsp.mkdir(dirPath, { recursive: true });
+    }
+    const prettierConfig = await prettier.resolveConfig(filePath);
+    let formattedContent = await prettier.format(content, {
+        ...(prettierConfig ?? { singleQuote: true, trailingComma: 'none' }),
+        filepath: filePath
+    });
+    const fileExists = await pathExists(filePath);
+    if (appendIfExists && fileExists) {
+        const existingContent = await fsp.readFile(filePath, 'utf8');
+        formattedContent = formattedContent + '\n' + existingContent;
+    }
+    if (addGeneratedComment) {
+        formattedContent =
+            '// Generated by Appweaver. Please do not edit this file manually.\n\n' +
+                formattedContent;
+    }
+    await fsp.writeFile(filePath, formattedContent, 'utf8');
+}
+async function pathExists(filePath) {
+    try {
+        await fsp.access(filePath, fsp.constants.F_OK);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export function relativePathFrom(firstPath, otherPath) {
+    const firstDir = path.dirname(path.resolve(firstPath));
+    const otherAbs = path.resolve(otherPath);
+    let rel = path.relative(firstDir, otherAbs);
+    if (!rel.startsWith('.') && rel !== '') {
+        rel = `.${path.sep}${rel}`;
+    }
+    else if (rel === '') {
+        rel = '.';
+    }
+    if (rel.endsWith('.ts')) {
+        rel = rel.replace('.d.ts', '.ts').replace('.ts', '');
+    }
+    return rel.replace(/\\/g, '/');
+}
+function parseSchema(value) {
+    let schemaUrl;
+    try {
+        schemaUrl = new URL(value);
+    }
+    catch {
+        // Schema path is not in URL format
+    }
+    if (schemaUrl) {
+        if (!['http:', 'https:', 'file:'].includes(schemaUrl.protocol)) {
+            throw new InvalidArgumentError(`Unsupported schema URL protocol: ${schemaUrl.protocol}`);
+        }
+        return value;
+    }
+    if (!fs.existsSync(value)) {
+        throw new InvalidArgumentError(`Schema path "${value}" does not exist or is not a valid URL.`);
+    }
+    return value;
+}
+function parseFramework(value) {
+    const lowerFramework = value.toLowerCase();
+    if (!FRAMEWORKS.includes(lowerFramework)) {
+        throw new InvalidOptionArgumentError(`Must be one of following: ${FRAMEWORKS.join(', ')}.`);
+    }
+    return lowerFramework;
+}

package/esm/commands/index.d.ts

@@ -0,0 +1 @@
+export * from './generate-command.js';

package/esm/commands/index.js

@@ -0,0 +1 @@
+export * from './generate-command.js';

package/esm/constants.d.ts

@@ -0,0 +1,67 @@
+/** Supported frameworks for generating the client class. */
+export declare const FRAMEWORKS: readonly ["fetch", "angular"];
+/** Custom OpenAPI extension key used for extracting route prefixes and base paths to their resources. */
+export declare const CONFIG_FIELD = "x-appweaver-config";
+/** Custom OpenAPI extension key used for extracting resources names from schema CRUD objects. */
+export declare const CONFIG_RESOURCE_FIELD = "x-appweaver-resource";
+/** Suffix used when generating the TypeScript module type name for a resource. */
+export declare const RESOURCE_MODULE_TYPE = "ResourceModuleType";
+/** Maps CRUD operation names to HTTP methods used for matching OpenAPI paths to `ResourceClient` methods. */
+export declare const RESOURCE_OPERATIONS: {
+    readonly find: "get";
+    readonly query: "post";
+    readonly aggregate: "post";
+    readonly create: "post";
+    readonly update: "put";
+    readonly delete: "delete";
+    readonly export: "post";
+    readonly uploadFiles: "post";
+    readonly deleteFiles: "post";
+};
+/** Expected type keys for a resource used for type inference. */
+export declare const RESOURCE_TYPES: readonly ["single", "multiple", "create", "update", "queryRequest", "queryResponse", "aggregateRequest", "aggregateResponse", "exportRequest", "files", "fileUpload", "fileDelete"];
+/** Type name used when generating the TypeScript module type for the auth module. */
+export declare const AUTH_MODULE_TYPE = "AuthModuleType";
+/** Maps auth operation names to HTTP methods used for matchingOpenAPI paths to `AuthClient` methods.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export declare const AUTH_OPERATIONS: {
+    readonly login: "post";
+    readonly logout: "post";
+    readonly refresh: "post";
+    readonly changePassword: "post";
+    readonly exchangeToken: "post";
+    readonly me: "get";
+};
+/** Expected type keys for the auth module used for type safety. */
+export declare const AUTH_TYPES: readonly ["loginRequest", "authenticationResponse", "logoutResponse", "changePasswordRequest", "exchangeTokenRequest", "identity"];
+/** Type name used when generating the TypeScript module type for the account module. */
+export declare const ACCOUNT_MODULE_TYPE = "AccountModuleType";
+/** Maps account operation names to HTTP methods used for matching OpenAPI paths to `AccountClient` methods.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export declare const ACCOUNT_OPERATIONS: {
+    readonly sendVerifyEmail: "post";
+    readonly verifyEmail: "post";
+    readonly verifyEmailRedirect: "get";
+    readonly sendResetPassword: "post";
+    readonly resetPassword: "post";
+    readonly send2FACode: "post";
+    readonly verify2FACode: "post";
+};
+/** Expected type keys for the account module which covers email verification, password reset, and 2FA req/resp. */
+export declare const ACCOUNT_TYPES: readonly ["sendEmailVerificationRequest", "statusResponse", "emailVerificationRequest", "sendResetPasswordRequest", "resetPasswordRequest", "send2FACodeRequest", "send2FAResponse", "verify2FARequest", "verify2FAResponse"];
+/** Type name used when generating the TypeScript module type for the health module. */
+export declare const HEALTH_MODULE_TYPE = "HealthModuleType";
+/** Maps health check operations to HTTP GET methods used for matching OpenAPI paths to `HealthClient` methods.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export declare const HEALTH_OPERATIONS: {
+    readonly check: "get";
+    readonly ready: "get";
+};
+/** Expected type keys for the health module used for `HealthClient` response typing. */
+export declare const HEALTH_TYPES: readonly ["checkResponse", "readyResponse"];
+/** Maps file-serving operations to HTTP GET methods used for identifying public and protected file endpoints.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export declare const FILE_OPERATIONS: {
+    readonly public: "get";
+    readonly protected: "get";
+};

package/esm/constants.js

@@ -0,0 +1,94 @@
+// CAUTION: The constants in this file should not be changed without good reason.
+// They are typically only modified when changes occur in other Appweaver packages
+// (such as core and common) to reflect new route paths or methods.
+/** Supported frameworks for generating the client class. */
+export const FRAMEWORKS = ['fetch', 'angular'];
+/** Custom OpenAPI extension key used for extracting route prefixes and base paths to their resources. */
+export const CONFIG_FIELD = 'x-appweaver-config';
+/** Custom OpenAPI extension key used for extracting resources names from schema CRUD objects. */
+export const CONFIG_RESOURCE_FIELD = 'x-appweaver-resource';
+/** Suffix used when generating the TypeScript module type name for a resource. */
+export const RESOURCE_MODULE_TYPE = 'ResourceModuleType';
+/** Maps CRUD operation names to HTTP methods used for matching OpenAPI paths to `ResourceClient` methods. */
+export const RESOURCE_OPERATIONS = {
+    find: 'get',
+    query: 'post',
+    aggregate: 'post',
+    create: 'post',
+    update: 'put',
+    delete: 'delete',
+    export: 'post',
+    uploadFiles: 'post',
+    deleteFiles: 'post'
+};
+/** Expected type keys for a resource used for type inference. */
+export const RESOURCE_TYPES = [
+    'single',
+    'multiple',
+    'create',
+    'update',
+    'queryRequest',
+    'queryResponse',
+    'aggregateRequest',
+    'aggregateResponse',
+    'exportRequest',
+    'files',
+    'fileUpload',
+    'fileDelete'
+];
+/** Type name used when generating the TypeScript module type for the auth module. */
+export const AUTH_MODULE_TYPE = 'AuthModuleType';
+/** Maps auth operation names to HTTP methods used for matchingOpenAPI paths to `AuthClient` methods.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export const AUTH_OPERATIONS = {
+    login: 'post',
+    logout: 'post',
+    refresh: 'post',
+    changePassword: 'post',
+    exchangeToken: 'post',
+    me: 'get'
+};
+/** Expected type keys for the auth module used for type safety. */
+export const AUTH_TYPES = [
+    'loginRequest',
+    'authenticationResponse',
+    'logoutResponse',
+    'changePasswordRequest',
+    'exchangeTokenRequest',
+    'identity'
+];
+/** Type name used when generating the TypeScript module type for the account module. */
+export const ACCOUNT_MODULE_TYPE = 'AccountModuleType';
+/** Maps account operation names to HTTP methods used for matching OpenAPI paths to `AccountClient` methods.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export const ACCOUNT_OPERATIONS = {
+    sendVerifyEmail: 'post',
+    verifyEmail: 'post',
+    verifyEmailRedirect: 'get',
+    sendResetPassword: 'post',
+    resetPassword: 'post',
+    send2FACode: 'post',
+    verify2FACode: 'post'
+};
+/** Expected type keys for the account module which covers email verification, password reset, and 2FA req/resp. */
+export const ACCOUNT_TYPES = [
+    'sendEmailVerificationRequest',
+    'statusResponse',
+    'emailVerificationRequest',
+    'sendResetPasswordRequest',
+    'resetPasswordRequest',
+    'send2FACodeRequest',
+    'send2FAResponse',
+    'verify2FARequest',
+    'verify2FAResponse'
+];
+/** Type name used when generating the TypeScript module type for the health module. */
+export const HEALTH_MODULE_TYPE = 'HealthModuleType';
+/** Maps health check operations to HTTP GET methods used for matching OpenAPI paths to `HealthClient` methods.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export const HEALTH_OPERATIONS = { check: 'get', ready: 'get' };
+/** Expected type keys for the health module used for `HealthClient` response typing. */
+export const HEALTH_TYPES = ['checkResponse', 'readyResponse'];
+/** Maps file-serving operations to HTTP GET methods used for identifying public and protected file endpoints.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export const FILE_OPERATIONS = { public: 'get', protected: 'get' };

package/esm/errors/client-error.d.ts

@@ -0,0 +1,6 @@
+export declare class ClientError extends Error {
+    errorCode: number;
+    response?: Response | undefined;
+    data?: any | undefined;
+    constructor(text: string, errorCode: number, response?: Response | undefined, data?: any | undefined);
+}

package/esm/errors/client-error.js

@@ -0,0 +1,11 @@
+export class ClientError extends Error {
+    errorCode;
+    response;
+    data;
+    constructor(text, errorCode, response, data) {
+        super(text);
+        this.errorCode = errorCode;
+        this.response = response;
+        this.data = data;
+    }
+}