@appweaver/client 1.0.23 → 1.0.24

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/{weaver-client.js → cjs/weaver-client.js}

@@ -8,7 +8,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const commander_1 = require("commander");
 const commands_1 = require("./commands");
-const pkg = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, './package.json'), 'utf8'));
+const pkg = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, '../package.json'), 'utf8'));
 const program = new commander_1.Command();
 program
     .name('weaver-client')

package/esm/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../clients/angular-client.js';

package/esm/angular/index.js

@@ -0,0 +1 @@
+export * from '../clients/angular-client.js';

package/esm/clients/angular-client.d.ts

@@ -0,0 +1,26 @@
+import { FetchResponse, MaybeOptionalInit } from 'openapi-fetch';
+import { HttpMethod, MediaType, PathsWithMethod } from 'openapi-typescript-helpers';
+import { Observable } from 'rxjs';
+import { BaseClient, ClientConfig, ClientResult, FetchHandler } from './base-client.js';
+import { ExtendedPaths, InitParam } from './base-client-interface.js';
+import { AccountClient, AccountInterface, AccountType, AuthClient, AuthInterface, AuthType, FilesClient, HealthClient, HealthInterface, HealthType, ResourceClient, ResourceInterface, ResourceType } from './modules/index.js';
+/** Maps a `Promise`-returning type to a concrete RxJS `Observable`. */
+export type PromiseToObservable<T> = T extends Promise<infer R> ? Observable<R> : T;
+/** Maps every `Promise`-returning method of `T` to return a concrete RxJS `Observable`. */
+export type ObservableMethods<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => PromiseToObservable<R> : T[K];
+};
+export declare class AngularClient<Paths extends {} = {
+    [key: string]: any;
+}> extends BaseClient<Paths, true> {
+    constructor(fetch: FetchHandler, config: ClientConfig);
+    sendRequest<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path, ...params: InitParam<Init>): Observable<NonNullable<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>['data']>>;
+    sendRequestRaw<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path, ...params: InitParam<Init>): Observable<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>>;
+    protected customRequest<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path): (...params: InitParam<Init>) => Observable<NonNullable<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>['data']>>;
+    protected resourceClient<Resource extends ResourceType, OmitFields extends readonly (keyof ResourceInterface)[] = []>(resourcePath: string): ObservableMethods<ClientResult<ResourceClient<Resource>, ResourceInterface, OmitFields>>;
+    protected authClient<Auth extends AuthType, OmitFields extends readonly (keyof AuthInterface)[] = []>(authPath: string): ObservableMethods<ClientResult<AuthClient<Auth>, AuthInterface, OmitFields>>;
+    protected accountClient<Account extends AccountType, OmitFields extends readonly (keyof AccountInterface)[] = []>(accountPath: string): ObservableMethods<ClientResult<AccountClient<Account>, AccountInterface, OmitFields>>;
+    protected healthClient<Health extends HealthType, OmitFields extends readonly (keyof HealthInterface)[] = []>(healthPath: string): ObservableMethods<ClientResult<HealthClient<Health>, HealthInterface, OmitFields>>;
+    protected filesClient<OmitFields extends readonly (keyof HealthInterface)[] = []>(filesPath: string): ObservableMethods<ClientResult<FilesClient, HealthInterface, OmitFields>>;
+    private wrapWithObservables;
+}

package/esm/clients/angular-client.js

@@ -0,0 +1,53 @@
+import { from } from 'rxjs';
+import { BaseClient } from './base-client.js';
+export class AngularClient extends BaseClient {
+    constructor(fetch, config) {
+        super({ ...config, fetch });
+    }
+    sendRequest(method, url, ...params) {
+        return from(super.sendRequestPromise(method, url, ...params));
+    }
+    sendRequestRaw(method, url, ...params) {
+        return from(super.sendRequestRawPromise(method, url, ...params));
+    }
+    customRequest(method, url) {
+        return (...params) => from(super.sendRequestPromise(method, url, ...params));
+    }
+    resourceClient(resourcePath) {
+        const instance = super.resourceClient(resourcePath);
+        return this.wrapWithObservables(instance);
+    }
+    authClient(authPath) {
+        const instance = super.authClient(authPath);
+        return this.wrapWithObservables(instance);
+    }
+    accountClient(accountPath) {
+        const instance = super.accountClient(accountPath);
+        return this.wrapWithObservables(instance);
+    }
+    healthClient(healthPath) {
+        const instance = super.healthClient(healthPath);
+        return this.wrapWithObservables(instance);
+    }
+    filesClient(filesPath) {
+        const instance = super.filesClient(filesPath);
+        return this.wrapWithObservables(instance);
+    }
+    wrapWithObservables(instance) {
+        const isPromiseLike = (value) => value !== null &&
+            (typeof value === 'object' || typeof value === 'function') &&
+            typeof value.then === 'function';
+        return new Proxy(instance, {
+            get(target, prop, receiver) {
+                const value = Reflect.get(target, prop, receiver);
+                if (typeof value !== 'function') {
+                    return value;
+                }
+                return (...args) => {
+                    const result = value.apply(target, args);
+                    return isPromiseLike(result) ? from(result) : result;
+                };
+            }
+        });
+    }
+}

package/esm/clients/base-client-interface.d.ts

@@ -0,0 +1,86 @@
+import { FetchResponse, MaybeOptionalInit } from 'openapi-fetch';
+import { HttpMethod, MediaType, PathsWithMethod, RequiredKeysOf } from 'openapi-typescript-helpers';
+export type ExtendedPaths<Paths> = Paths & Record<string, Record<HttpMethod, {}>>;
+export type InitParam<Init> = RequiredKeysOf<Init> extends never ? [(Init & {
+    [key: string]: unknown;
+})?] : [Init & {
+    [key: string]: unknown;
+}];
+/**
+ * Minimal structural subset of an RxJS `Observable`.
+ *
+ * Keeps the base client free of any `rxjs` dependency (runtime and types) while
+ * remaining assignable from a real `Observable` — `AngularClient` narrows these
+ * return types to concrete RxJS Observables in the `@appweaver/client/angular` entry.
+ */
+export interface ObservableLike<T> {
+    subscribe(observer?: {
+        next?: (value: T) => void;
+        error?: (error: any) => void;
+        complete?: () => void;
+    }): {
+        unsubscribe(): void;
+    };
+}
+export type ObservableOrPromise<T, B extends boolean> = B extends true ? ObservableLike<T> : Promise<T>;
+export type PromiseToObservable<T> = T extends Promise<infer R> ? ObservableLike<R> : T;
+export type ObservableMethods<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => PromiseToObservable<R> : T[K];
+};
+/**
+ * Public interface for {@link BaseClient} exposing the three core request methods.
+ *
+ * @typeParam Paths - The OpenAPI path map generated by `openapi-typescript` for the target API.
+ */
+export interface BaseClientInterface<Paths extends {} = {
+    [key: string]: any;
+}, UseObservable extends boolean = false> {
+    /**
+     * Sends an HTTP request and returns the parsed response data.
+     *
+     * Throws a {@link ClientError} if the server returns an error response, including the
+     * error message and status code from the response body when available.
+     *
+     * @typeParam Method - The HTTP method (e.g. `"get"`, `"post"`).
+     * @typeParam Path - A path in `Paths` that supports `Method`.
+     * @typeParam Init - The request init inferred from the OpenAPI schema for this operation.
+     * @param {HttpMethod} method - The HTTP method to use.
+     * @param {string} url - The API path to request.
+     * @param {Object} params - Optional request parameters (body, query, headers, etc.) as defined by the schema.
+     * @returns The non-nullable `data` field from the response.
+     * @throws {ClientError} When the server returns an error response.
+     */
+    sendRequest<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path, ...params: InitParam<Init>): ObservableOrPromise<NonNullable<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>['data']>, UseObservable>;
+    /**
+     * Sends an HTTP request and returns the raw `openapi-fetch` response tuple.
+     *
+     * Unlike {@link sendRequest}, this method does **not** throw on error responses — callers
+     * receive the full `{ data, error, response }` object and are responsible for handling
+     * error cases themselves.
+     *
+     * @typeParam Method - The HTTP method (e.g. `"get"`, `"post"`).
+     * @typeParam Path - A path in `Paths` that supports `Method`.
+     * @typeParam Init - The request init inferred from the OpenAPI schema for this operation.
+     * @param {HttpMethod} method - The HTTP method to use.
+     * @param {string} url - The API path to request.
+     * @param {Object} params - Optional request parameters (body, query, headers, etc.) as defined by the schema.
+     * @returns The raw `FetchResponse` containing `data`, `error`, and the native `Response`.
+     */
+    sendRequestRaw<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path, ...params: InitParam<Init>): ObservableOrPromise<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>, UseObservable>;
+    /**
+     * Sends an HTTP request and returns the parsed response data as a Promise.
+     *
+     * This protected helper always returns a `Promise` and is intended to be called
+     * by {@link sendRequest} and overrides in subclasses such as `AngularClient`.
+     *
+     * @throws {ClientError} When the server returns an error response.
+     */
+    sendRequestPromise<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path, ...params: InitParam<Init>): Promise<NonNullable<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>['data']>>;
+    /**
+     * Sends an HTTP request and returns the raw `openapi-fetch` response tuple as a Promise.
+     *
+     * This protected helper always returns a `Promise` and is intended to be called
+     * by {@link sendRequestRaw} and overrides in subclasses such as `AngularClient`.
+     */
+    sendRequestRawPromise<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path, ...params: InitParam<Init>): Promise<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>>;
+}

package/esm/clients/base-client-interface.js

@@ -0,0 +1 @@
+export {};

package/esm/clients/base-client.d.ts

@@ -0,0 +1,216 @@
+import { Client, FetchResponse, MaybeOptionalInit, Middleware } from 'openapi-fetch';
+import { HttpMethod, MediaType, PathsWithMethod } from 'openapi-typescript-helpers';
+import { BaseClientInterface, ExtendedPaths, InitParam, ObservableMethods, ObservableOrPromise } from './base-client-interface.js';
+import { AccountClient, AccountInterface, AccountType, AuthClient, AuthInterface, AuthType, FilesClient, HealthClient, HealthInterface, HealthType, ResourceClient, ResourceInterface, ResourceType } from './modules/index.js';
+export type ClientResult<TClient, Interface, OmitFields extends readonly (keyof Interface)[]> = [OmitFields[number]] extends [never] ? TClient : Omit<TClient, OmitFields[number]>;
+export type ClientResultMethods<T, B extends boolean> = B extends true ? ObservableMethods<T> : T;
+/**
+ * Function type for dynamically resolving authentication values per request.
+ *
+ * This function receives the outgoing `Request` and can return authentication configuration
+ * either synchronously or asynchronously. Used to provide dynamic auth values (e.g., fetching
+ * tokens from storage) instead of static strings or objects.
+ *
+ * @typeParam T - The type of authentication value to return (string, JwtAuthConfig, ApiKeyAuthConfig, or
+ * BasicAuthConfig).
+ * @param {Request} req - The outgoing HTTP request object.
+ * @returns The authentication value, either directly or wrapped in a Promise.
+ */
+export type AuthFn<T> = (req: Request) => T | Promise<T>;
+/** Configuration for JWT-based authentication. */
+export type JwtAuthConfig = {
+    /** The JWT access token to include in the `Authorization: Bearer` header. */
+    accessToken: string;
+    /** Optional refresh token for renewing expired access tokens when calling the refresh endpoint. */
+    refreshToken?: string;
+};
+/** Configuration for API key authentication. */
+export type ApiKeyAuthConfig = {
+    /** The API key value to send in the request header. */
+    key: string;
+    /** The header name to use for the API key. Defaults to `X-Api-Key`. */
+    header?: string;
+};
+/** Configuration for HTTP Basic authentication. */
+export type BasicAuthConfig = {
+    /** The username for Basic authentication. */
+    username: string;
+    /** The password for Basic authentication. */
+    password: string;
+};
+/**
+ * Authentication configuration for the client. Exactly one auth strategy must be provided.
+ *
+ * - `jwt` — attaches a `Bearer` token to the `Authorization` header.
+ * - `apiKey` — attaches a key to a configurable header (default: `X-Api-Key`).
+ * - `basic` — attaches Base64-encoded credentials to the `Authorization` header.
+ *
+ * Each value may be a static config object, a plain string shorthand, or an async function
+ * that receives the outgoing `Request` and returns the auth value dynamically.
+ */
+export type AuthConfig = {
+    jwt: string | AuthFn<string> | AuthFn<JwtAuthConfig> | JwtAuthConfig;
+} | {
+    apiKey: string | AuthFn<string> | AuthFn<ApiKeyAuthConfig> | ApiKeyAuthConfig;
+} | {
+    basic: string | AuthFn<string> | AuthFn<BasicAuthConfig> | BasicAuthConfig;
+};
+/**
+ * Type definition for a custom fetch handler implementation.
+ *
+ * This type represents a function that performs HTTP requests and returns a Promise resolving to a Response object.
+ * It is intended to be used as a replacement or extension of the default `fetch` function provided by the browser or
+ * other runtime environments.
+ *
+ * @param {RequestInfo} request - The resource that you wish to fetch, either as a string URL or a Request object.
+ * @param {RequestInit} [init] - Optional options object containing custom settings for the fetch request, such as
+ * method, headers, body, and more.
+ * @returns {Promise<Response>} A Promise that resolves to the Response to the request.
+ */
+export type FetchHandler = (request: RequestInfo, init?: RequestInit) => Promise<Response>;
+/** Configuration options for {@link FetchClient}. */
+export type ClientConfig = {
+    /** The base URL that will be prepended to every request path. */
+    baseUrl: string;
+    /** Request timeout in milliseconds. Requests that exceed this duration are aborted. */
+    timeout?: number;
+    /** Additional `openapi-fetch` middlewares applied after the built-in timeout and auth middlewares. */
+    middlewares?: Middleware[];
+    /** Authentication strategy to attach to every outgoing request. */
+    auth?: AuthConfig;
+    /** Custom fetch handler implementation for making HTTP requests and transforming responses. */
+    fetch?: FetchHandler;
+};
+/**
+ * Type-safe HTTP client built on top of `openapi-fetch`.
+ *
+ * `BaseClient` wires up a base URL, optional request timeout, optional authentication
+ * middleware, and any additional custom middlewares into a single reusable client instance.
+ * Subclasses expose domain-specific helpers by composing the protected factory methods
+ * (`resourceClient`, `authClient`, `accountClient`, `healthClient`, `fileClient`).
+ *
+ * @typeParam Paths - The OpenAPI path map generated by `openapi-typescript` for the target API.
+ * @typeParam UseObservable - Boolean flag indicating whether to return Observables (true) or Promises (false).
+ * Defaults to false for Promise-based clients like `FetchClient`. Set to true in `AngularClient` to enable RxJS
+ * Observable support.
+ */
+export declare abstract class BaseClient<Paths extends {} = {
+    [key: string]: any;
+}, UseObservable extends boolean = false> implements BaseClientInterface<Paths, UseObservable> {
+    private readonly _config;
+    private readonly _client;
+    private readonly _modules;
+    protected constructor(_config: ClientConfig);
+    /**
+     * Returns the underlying `openapi-fetch` client instance.
+     *
+     * Use this when direct access to the raw client is required to call methods
+     * not exposed by `FetchClient` directly.
+     */
+    getClient(): Client<Paths>;
+    /**
+     * Retrieves the client configuration.
+     *
+     * @return {ClientConfig} The current client configuration instance.
+     */
+    getConfig(): ClientConfig;
+    /**
+     * Sends an HTTP request and returns the parsed response data.
+     *
+     * Returns a `Promise` by default. In `AngularClient` (where `UseObservable = true`)
+     * this method is overridden to return an `Observable` instead.
+     *
+     * Throws a {@link ClientError} if the server returns an error response, including the
+     * error message and status code from the response body when available.
+     *
+     * @typeParam Method - The HTTP method (e.g. `"get"`, `"post"`).
+     * @typeParam Path - A path in `Paths` that supports `Method`.
+     * @typeParam Init - The request init inferred from the OpenAPI schema for this operation.
+     * @param {HttpMethod} method - The HTTP method to use.
+     * @param {string} url - The API path to request.
+     * @param {Object} params - Optional request parameters (body, query, headers, etc.) as defined by the schema.
+     * @returns The non-nullable `data` field from the response.
+     * @throws {ClientError} When the server returns an error response.
+     */
+    sendRequest<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path, ...params: InitParam<Init>): ObservableOrPromise<NonNullable<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>['data']>, UseObservable>;
+    /**
+     * Sends an HTTP request and returns the raw `openapi-fetch` response tuple.
+     *
+     * Returns a `Promise` by default. In `AngularClient` (where `UseObservable = true`)
+     * this method is overridden to return an `Observable` instead.
+     *
+     * Unlike {@link sendRequest}, this method does **not** throw on error responses — callers
+     * receive the full `{ data, error, response }` object and are responsible for handling
+     * error cases themselves.
+     *
+     * @typeParam Method - The HTTP method (e.g. `"get"`, `"post"`).
+     * @typeParam Path - A path in `Paths` that supports `Method`.
+     * @typeParam Init - The request init inferred from the OpenAPI schema for this operation.
+     * @param {HttpMethod} method - The HTTP method to use.
+     * @param {string} url - The API path to request.
+     * @param {Object} params - Optional request parameters (body, query, headers, etc.) as defined by the schema.
+     * @returns The raw `FetchResponse` containing `data`, `error`, and the native `Response`.
+     */
+    sendRequestRaw<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path, ...params: InitParam<Init>): ObservableOrPromise<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>, UseObservable>;
+    /**
+     * Sends an HTTP request and returns the parsed response data as a Promise.
+     *
+     * This protected helper always returns a `Promise` and is intended to be called
+     * by {@link sendRequest} and overrides in subclasses such as `AngularClient`.
+     *
+     * @throws {ClientError} When the server returns an error response.
+     */
+    sendRequestPromise<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path, ...params: InitParam<Init>): Promise<NonNullable<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>['data']>>;
+    /**
+     * Sends an HTTP request and returns the raw `openapi-fetch` response tuple as a Promise.
+     *
+     * This protected helper always returns a `Promise` and is intended to be called
+     * by {@link sendRequestRaw} and overrides in subclasses such as `AngularClient`.
+     */
+    sendRequestRawPromise<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path, ...params: InitParam<Init>): Promise<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>>;
+    /**
+     * Handles a custom HTTP request based on the provided method, URL, and initialization parameters.
+     *
+     * @param {Method} method - The HTTP method to be used (e.g., GET, POST).
+     * @param {Path} url - The endpoint URL corresponding to the specified method.
+     * @return A function that accepts initialization parameters and returns an observable or promise of the fetched data.
+     */
+    protected customRequest<Method extends HttpMethod, Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<ExtendedPaths<Paths>[Path], Method>>(method: Method, url: Path): (...params: InitParam<Init>) => ObservableOrPromise<NonNullable<FetchResponse<ExtendedPaths<Paths>[Path][Method], Init, MediaType>['data']>, UseObservable>;
+    /**
+     * Creates and returns a new instance of a ResourceClient for managing a specific resource type.
+     *
+     * @param {string} resourcePath - The API path or endpoint for the resource.
+     * @template Resource - The type of the resource being managed.
+     * @template OmitFields - An optional array of resource interface fields to omit.
+     * @return {ResourceClient} A ResourceClient instance for interacting with the specified resource.
+     */
+    protected resourceClient<Resource extends ResourceType, OmitFields extends readonly (keyof ResourceInterface)[] = []>(resourcePath: string): ClientResultMethods<ClientResult<ResourceClient<Resource>, ResourceInterface, OmitFields>, UseObservable>;
+    /**
+     * Creates and returns an AuthClient instance for managing authentication operations.
+     *
+     * @param {string} authPath - The authentication path used to configure the AuthClient instance.
+     * @return {AuthClient} An instance of AuthClient initialized with the provided authentication path.
+     */
+    protected authClient<Auth extends AuthType, OmitFields extends readonly (keyof AuthInterface)[] = []>(authPath: string): ClientResultMethods<ClientResult<AuthClient<Auth>, AuthInterface, OmitFields>, UseObservable>;
+    /**
+     * Creates and returns an AccountClient instance for managing account-related operations.
+     *
+     * @param {string} accountPath - The path to the account resource.
+     * @return {AccountClient} An instance of AccountClient configured with the provided account path.
+     */
+    protected accountClient<Account extends AccountType, OmitFields extends readonly (keyof AccountInterface)[] = []>(accountPath: string): ClientResultMethods<ClientResult<AccountClient<Account>, AccountInterface, OmitFields>, UseObservable>;
+    /**
+     * Creates and returns a HealthClient instance for interacting with health-related data.
+     *
+     * @param {string} healthPath - The path to the health resource endpoint.
+     * @return {HealthClient} An instance of HealthClient configured with the provided health path.
+     */
+    protected healthClient<Health extends HealthType, OmitFields extends readonly (keyof HealthInterface)[] = []>(healthPath: string): ClientResultMethods<ClientResult<HealthClient<Health>, HealthInterface, OmitFields>, UseObservable>;
+    /**
+     * Creates and returns an instance of `FilesClient` for the specified file path.
+     *
+     * @param {string} filesPath - The file path used to initialize the `FilesClient`.
+     * @return {FilesClient} An instance of FilesClient configured with the provided files' path.
+     */
+    protected filesClient<OmitFields extends readonly (keyof HealthInterface)[] = []>(filesPath: string): ClientResultMethods<ClientResult<FilesClient, HealthInterface, OmitFields>, UseObservable>;
+}

package/esm/clients/base-client.js

@@ -0,0 +1,242 @@
+import createClient from 'openapi-fetch';
+import { AccountClient, AuthClient, FilesClient, HealthClient, ResourceClient } from './modules/index.js';
+import { ClientError } from '../errors/index.js';
+/**
+ * Type-safe HTTP client built on top of `openapi-fetch`.
+ *
+ * `BaseClient` wires up a base URL, optional request timeout, optional authentication
+ * middleware, and any additional custom middlewares into a single reusable client instance.
+ * Subclasses expose domain-specific helpers by composing the protected factory methods
+ * (`resourceClient`, `authClient`, `accountClient`, `healthClient`, `fileClient`).
+ *
+ * @typeParam Paths - The OpenAPI path map generated by `openapi-typescript` for the target API.
+ * @typeParam UseObservable - Boolean flag indicating whether to return Observables (true) or Promises (false).
+ * Defaults to false for Promise-based clients like `FetchClient`. Set to true in `AngularClient` to enable RxJS
+ * Observable support.
+ */
+export class BaseClient {
+    _config;
+    _client;
+    _modules = {
+        resources: []
+    };
+    constructor(_config) {
+        this._config = _config;
+        const { baseUrl, timeout, middlewares, auth, fetch } = _config;
+        this._client = createClient({ baseUrl, fetch });
+        if (timeout) {
+            this._client.use({
+                onRequest: async ({ request }) => {
+                    const timeoutSignal = AbortSignal.timeout(timeout);
+                    return new Request(request, {
+                        signal: request.signal
+                            ? AbortSignal.any([request.signal, timeoutSignal])
+                            : timeoutSignal
+                    });
+                }
+            });
+        }
+        if (auth) {
+            this._client.use({
+                onRequest: async ({ request, schemaPath }) => {
+                    const headers = new Headers(request.headers);
+                    if ('jwt' in auth) {
+                        const jwt = typeof auth.jwt === 'function'
+                            ? await auth.jwt(request)
+                            : auth.jwt;
+                        let token;
+                        if (typeof jwt === 'object') {
+                            token = jwt.accessToken;
+                            const refreshPath = `/${this._modules.auth?.basePath}/refresh`.replace(/\/+/g, '/');
+                            if (schemaPath === refreshPath && jwt.refreshToken) {
+                                token = jwt.refreshToken;
+                            }
+                        }
+                        else {
+                            token = jwt;
+                        }
+                        headers.set('Authorization', `Bearer ${token}`);
+                    }
+                    else if ('basic' in auth) {
+                        const basic = typeof auth.basic === 'function'
+                            ? await auth.basic(request)
+                            : auth.basic;
+                        const secret = typeof basic === 'string'
+                            ? basic
+                            : btoa(`${basic.username}:${basic.password}`);
+                        headers.set('Authorization', `Basic ${secret}`);
+                    }
+                    if ('apiKey' in auth) {
+                        const apiKey = typeof auth.apiKey === 'function'
+                            ? await auth.apiKey(request)
+                            : auth.apiKey;
+                        const key = typeof apiKey === 'string' ? apiKey : apiKey.key;
+                        const header = typeof apiKey !== 'string' ? apiKey?.header : undefined;
+                        headers.set(header ?? 'X-Api-Key', key);
+                    }
+                    return new Request(request, {
+                        headers
+                    });
+                }
+            });
+        }
+        if (middlewares) {
+            for (const middleware of middlewares) {
+                this._client.use(middleware);
+            }
+        }
+    }
+    /**
+     * Returns the underlying `openapi-fetch` client instance.
+     *
+     * Use this when direct access to the raw client is required to call methods
+     * not exposed by `FetchClient` directly.
+     */
+    getClient() {
+        return this._client;
+    }
+    /**
+     * Retrieves the client configuration.
+     *
+     * @return {ClientConfig} The current client configuration instance.
+     */
+    getConfig() {
+        return this._config;
+    }
+    /**
+     * Sends an HTTP request and returns the parsed response data.
+     *
+     * Returns a `Promise` by default. In `AngularClient` (where `UseObservable = true`)
+     * this method is overridden to return an `Observable` instead.
+     *
+     * Throws a {@link ClientError} if the server returns an error response, including the
+     * error message and status code from the response body when available.
+     *
+     * @typeParam Method - The HTTP method (e.g. `"get"`, `"post"`).
+     * @typeParam Path - A path in `Paths` that supports `Method`.
+     * @typeParam Init - The request init inferred from the OpenAPI schema for this operation.
+     * @param {HttpMethod} method - The HTTP method to use.
+     * @param {string} url - The API path to request.
+     * @param {Object} params - Optional request parameters (body, query, headers, etc.) as defined by the schema.
+     * @returns The non-nullable `data` field from the response.
+     * @throws {ClientError} When the server returns an error response.
+     */
+    sendRequest(method, url, ...params) {
+        return this.sendRequestPromise(method, url, ...params);
+    }
+    /**
+     * Sends an HTTP request and returns the raw `openapi-fetch` response tuple.
+     *
+     * Returns a `Promise` by default. In `AngularClient` (where `UseObservable = true`)
+     * this method is overridden to return an `Observable` instead.
+     *
+     * Unlike {@link sendRequest}, this method does **not** throw on error responses — callers
+     * receive the full `{ data, error, response }` object and are responsible for handling
+     * error cases themselves.
+     *
+     * @typeParam Method - The HTTP method (e.g. `"get"`, `"post"`).
+     * @typeParam Path - A path in `Paths` that supports `Method`.
+     * @typeParam Init - The request init inferred from the OpenAPI schema for this operation.
+     * @param {HttpMethod} method - The HTTP method to use.
+     * @param {string} url - The API path to request.
+     * @param {Object} params - Optional request parameters (body, query, headers, etc.) as defined by the schema.
+     * @returns The raw `FetchResponse` containing `data`, `error`, and the native `Response`.
+     */
+    sendRequestRaw(method, url, ...params) {
+        return this.sendRequestRawPromise(method, url, ...params);
+    }
+    /**
+     * Sends an HTTP request and returns the parsed response data as a Promise.
+     *
+     * This protected helper always returns a `Promise` and is intended to be called
+     * by {@link sendRequest} and overrides in subclasses such as `AngularClient`.
+     *
+     * @throws {ClientError} When the server returns an error response.
+     */
+    async sendRequestPromise(method, url, ...params) {
+        const { data, error, response } = await this._client.request(method, url, ...params);
+        if (error) {
+            const err = error;
+            throw new ClientError(err.message ?? response.statusText ?? 'Unknown error', err.errorCode ?? response.status, response, error);
+        }
+        return data;
+    }
+    /**
+     * Sends an HTTP request and returns the raw `openapi-fetch` response tuple as a Promise.
+     *
+     * This protected helper always returns a `Promise` and is intended to be called
+     * by {@link sendRequestRaw} and overrides in subclasses such as `AngularClient`.
+     */
+    sendRequestRawPromise(method, url, ...params) {
+        return this._client.request(method, url, ...params);
+    }
+    /**
+     * Handles a custom HTTP request based on the provided method, URL, and initialization parameters.
+     *
+     * @param {Method} method - The HTTP method to be used (e.g., GET, POST).
+     * @param {Path} url - The endpoint URL corresponding to the specified method.
+     * @return A function that accepts initialization parameters and returns an observable or promise of the fetched data.
+     */
+    customRequest(method, url) {
+        return (...params) => {
+            return this.sendRequest(method, url, ...params);
+        };
+    }
+    /**
+     * Creates and returns a new instance of a ResourceClient for managing a specific resource type.
+     *
+     * @param {string} resourcePath - The API path or endpoint for the resource.
+     * @template Resource - The type of the resource being managed.
+     * @template OmitFields - An optional array of resource interface fields to omit.
+     * @return {ResourceClient} A ResourceClient instance for interacting with the specified resource.
+     */
+    resourceClient(resourcePath) {
+        const resource = new ResourceClient(this, resourcePath);
+        this._modules.resources.push(resource);
+        return resource;
+    }
+    /**
+     * Creates and returns an AuthClient instance for managing authentication operations.
+     *
+     * @param {string} authPath - The authentication path used to configure the AuthClient instance.
+     * @return {AuthClient} An instance of AuthClient initialized with the provided authentication path.
+     */
+    authClient(authPath) {
+        const auth = new AuthClient(this, authPath);
+        this._modules.auth = auth;
+        return auth;
+    }
+    /**
+     * Creates and returns an AccountClient instance for managing account-related operations.
+     *
+     * @param {string} accountPath - The path to the account resource.
+     * @return {AccountClient} An instance of AccountClient configured with the provided account path.
+     */
+    accountClient(accountPath) {
+        const account = new AccountClient(this, accountPath);
+        this._modules.account = account;
+        return account;
+    }
+    /**
+     * Creates and returns a HealthClient instance for interacting with health-related data.
+     *
+     * @param {string} healthPath - The path to the health resource endpoint.
+     * @return {HealthClient} An instance of HealthClient configured with the provided health path.
+     */
+    healthClient(healthPath) {
+        const health = new HealthClient(this, healthPath);
+        this._modules.health = health;
+        return health;
+    }
+    /**
+     * Creates and returns an instance of `FilesClient` for the specified file path.
+     *
+     * @param {string} filesPath - The file path used to initialize the `FilesClient`.
+     * @return {FilesClient} An instance of FilesClient configured with the provided files' path.
+     */
+    filesClient(filesPath) {
+        const files = new FilesClient(this, filesPath);
+        this._modules.files = files;
+        return files;
+    }
+}

package/esm/clients/fetch-client.d.ts

@@ -0,0 +1,6 @@
+import { ClientConfig, BaseClient } from './base-client.js';
+export declare class FetchClient<Paths extends {} = {
+    [key: string]: any;
+}> extends BaseClient<Paths> {
+    constructor(config: ClientConfig);
+}