@appweaver/client 1.0.23 → 1.0.25

package/esm/clients/fetch-client.js

@@ -0,0 +1,6 @@
+import { BaseClient } from './base-client.js';
+export class FetchClient extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+}

package/esm/clients/index.d.ts

@@ -0,0 +1,4 @@
+export * from './modules/index.js';
+export * from './base-client.js';
+export * from './base-client-interface.js';
+export * from './fetch-client.js';

package/esm/clients/index.js

@@ -0,0 +1,4 @@
+export * from './modules/index.js';
+export * from './base-client.js';
+export * from './base-client-interface.js';
+export * from './fetch-client.js';

package/esm/clients/modules/account-client.d.ts

@@ -0,0 +1,69 @@
+import { BaseModule, RequestOptions } from './base-module.js';
+import { BaseClientInterface } from '../base-client-interface.js';
+import { ACCOUNT_OPERATIONS, ACCOUNT_TYPES } from '../../constants.js';
+export type AccountType = Record<(typeof ACCOUNT_TYPES)[number], unknown>;
+export type AccountInterface = {
+    [K in keyof typeof ACCOUNT_OPERATIONS]: (...args: any[]) => Promise<any>;
+};
+export declare class AccountClient<Account extends AccountType> extends BaseModule implements AccountInterface {
+    readonly basePath: string;
+    constructor(client: BaseClientInterface, basePath: string);
+    /**
+     * Sends a verification email to the user's registered email address.
+     *
+     * @param {Object} request - The payload identifying the account to send the email to.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A status response indicating whether the email was dispatched successfully.
+     */
+    sendVerifyEmail(request: Account['sendEmailVerificationRequest'], options?: RequestOptions): Promise<Account['statusResponse']>;
+    /**
+     * Verifies a user's email address using a verification token.
+     *
+     * @param {Object} request - The payload containing the verification token.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A status response indicating whether the email was verified successfully.
+     */
+    verifyEmail(request: Account['emailVerificationRequest'], options?: RequestOptions): Promise<Account['statusResponse']>;
+    /**
+     * Handles the redirect-based email verification flow by passing the token as a query parameter.
+     *
+     * Typically used as the target of a link sent in a verification email.
+     *
+     * @param {string} token - The email verification token from the redirect URL.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The server response for the redirect verification (shape depends on the API).
+     */
+    verifyEmailRedirect(token: string, options?: RequestOptions): Promise<any>;
+    /**
+     * Sends a password reset email to the user's registered email address.
+     *
+     * @param {Object} request - The payload identifying the account (e.g., email address).
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A status response indicating whether the reset email was dispatched successfully.
+     */
+    sendResetPassword(request: Account['sendResetPasswordRequest'], options?: RequestOptions): Promise<Account['statusResponse']>;
+    /**
+     * Resets the user's password using a reset token.
+     *
+     * @param {Object} request - The payload containing the reset token and the new password.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A status response indicating whether the password was reset successfully.
+     */
+    resetPassword(request: Account['resetPasswordRequest'], options?: RequestOptions): Promise<Account['statusResponse']>;
+    /**
+     * Sends a two-factor authentication (2FA) code to the user (e.g., via SMS or email).
+     *
+     * @param {Object} request - The payload identifying the account to send the code to.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A response confirming the 2FA code was sent.
+     */
+    send2FACode(request: Account['send2FACodeRequest'], options?: RequestOptions): Promise<Account['send2FAResponse']>;
+    /**
+     * Verifies a two-factor authentication (2FA) code submitted by the user.
+     *
+     * @param {Object} request - The payload containing the 2FA code to verify.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A response indicating whether the 2FA verification succeeded.
+     */
+    verify2FACode(request: Account['verify2FARequest'], options?: RequestOptions): Promise<Account['verify2FAResponse']>;
+}

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

@@ -0,0 +1,107 @@
+import { BaseModule } from './base-module.js';
+export class AccountClient extends BaseModule {
+    basePath;
+    constructor(client, basePath) {
+        super(client);
+        this.basePath = basePath;
+    }
+    /**
+     * Sends a verification email to the user's registered email address.
+     *
+     * @param {Object} request - The payload identifying the account to send the email to.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A status response indicating whether the email was dispatched successfully.
+     */
+    async sendVerifyEmail(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/send-verify-email`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Verifies a user's email address using a verification token.
+     *
+     * @param {Object} request - The payload containing the verification token.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A status response indicating whether the email was verified successfully.
+     */
+    async verifyEmail(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/verify-email`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Handles the redirect-based email verification flow by passing the token as a query parameter.
+     *
+     * Typically used as the target of a link sent in a verification email.
+     *
+     * @param {string} token - The email verification token from the redirect URL.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The server response for the redirect verification (shape depends on the API).
+     */
+    async verifyEmailRedirect(token, options = {}) {
+        return this.sendRequest('get', `${this.basePath}/verify-email-redirect`, {
+            ...options,
+            params: {
+                ...(options.params ?? {}),
+                query: {
+                    ...(options.params?.query ?? {}),
+                    token
+                }
+            }
+        });
+    }
+    /**
+     * Sends a password reset email to the user's registered email address.
+     *
+     * @param {Object} request - The payload identifying the account (e.g., email address).
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A status response indicating whether the reset email was dispatched successfully.
+     */
+    async sendResetPassword(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/send-reset-password`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Resets the user's password using a reset token.
+     *
+     * @param {Object} request - The payload containing the reset token and the new password.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A status response indicating whether the password was reset successfully.
+     */
+    async resetPassword(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/reset-password`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Sends a two-factor authentication (2FA) code to the user (e.g., via SMS or email).
+     *
+     * @param {Object} request - The payload identifying the account to send the code to.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A response confirming the 2FA code was sent.
+     */
+    async send2FACode(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/send-2fa-code`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Verifies a two-factor authentication (2FA) code submitted by the user.
+     *
+     * @param {Object} request - The payload containing the 2FA code to verify.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A response indicating whether the 2FA verification succeeded.
+     */
+    async verify2FACode(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/account/verify-2fa-code`, {
+            ...options,
+            body: request
+        });
+    }
+}

package/esm/clients/modules/auth-client.d.ts

@@ -0,0 +1,56 @@
+import { BaseModule, RequestOptions } from './base-module.js';
+import { BaseClientInterface } from '../base-client-interface.js';
+import { AUTH_OPERATIONS, AUTH_TYPES } from '../../constants.js';
+export type AuthType = Record<(typeof AUTH_TYPES)[number], unknown>;
+export type AuthInterface = {
+    [K in keyof typeof AUTH_OPERATIONS]: (...args: any[]) => Promise<any>;
+};
+export declare class AuthClient<Auth extends AuthType> extends BaseModule implements AuthInterface {
+    readonly basePath: string;
+    constructor(client: BaseClientInterface, basePath: string);
+    /**
+     * Authenticates a user with the provided credentials.
+     *
+     * @param {Object} request - The login payload (e.g., email and password).
+     * @param {RequestOptions} options - Additional request options.
+     * @returns An authentication response containing tokens and session info.
+     */
+    login(request: Auth['loginRequest'], options?: RequestOptions): Promise<Auth['authenticationResponse']>;
+    /**
+     * Logs out the currently authenticated user and invalidates the session.
+     *
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The logout response from the server.
+     */
+    logout(options?: RequestOptions): Promise<Auth['logoutResponse']>;
+    /**
+     * Refreshes the current authentication session and issues new tokens.
+     *
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A fresh authentication response with updated tokens.
+     */
+    refresh(options?: RequestOptions): Promise<Auth['authenticationResponse']>;
+    /**
+     * Changes the authenticated user's password.
+     *
+     * @param {Object} request - The change-password payload (e.g., current and new password).
+     * @param {RequestOptions} options - Additional request options.
+     * @returns An updated authentication response after the password change.
+     */
+    changePassword(request: Auth['changePasswordRequest'], options?: RequestOptions): Promise<Auth['authenticationResponse']>;
+    /**
+     * Exchanges a third-party or external token for an application authentication token.
+     *
+     * @param {Object} request - The token exchange payload (e.g., an OAuth code or external token).
+     * @param {RequestOptions} options - Additional request options.
+     * @returns An authentication response containing the issued application tokens.
+     */
+    exchangeToken(request: Auth['exchangeTokenRequest'], options?: RequestOptions): Promise<Auth['authenticationResponse']>;
+    /**
+     * Retrieves the identity of the currently authenticated user.
+     *
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The identity object for the authenticated user.
+     */
+    me(options?: RequestOptions): Promise<Auth['identity']>;
+}

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

@@ -0,0 +1,74 @@
+import { BaseModule } from './base-module.js';
+export class AuthClient extends BaseModule {
+    basePath;
+    constructor(client, basePath) {
+        super(client);
+        this.basePath = basePath;
+    }
+    /**
+     * Authenticates a user with the provided credentials.
+     *
+     * @param {Object} request - The login payload (e.g., email and password).
+     * @param {RequestOptions} options - Additional request options.
+     * @returns An authentication response containing tokens and session info.
+     */
+    async login(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/login`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Logs out the currently authenticated user and invalidates the session.
+     *
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The logout response from the server.
+     */
+    async logout(options = {}) {
+        return this.sendRequest('post', `${this.basePath}/logout`, options);
+    }
+    /**
+     * Refreshes the current authentication session and issues new tokens.
+     *
+     * @param {RequestOptions} options - Additional request options.
+     * @returns A fresh authentication response with updated tokens.
+     */
+    async refresh(options = {}) {
+        return this.sendRequest('post', `${this.basePath}/refresh`, options);
+    }
+    /**
+     * Changes the authenticated user's password.
+     *
+     * @param {Object} request - The change-password payload (e.g., current and new password).
+     * @param {RequestOptions} options - Additional request options.
+     * @returns An updated authentication response after the password change.
+     */
+    async changePassword(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/change-password`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Exchanges a third-party or external token for an application authentication token.
+     *
+     * @param {Object} request - The token exchange payload (e.g., an OAuth code or external token).
+     * @param {RequestOptions} options - Additional request options.
+     * @returns An authentication response containing the issued application tokens.
+     */
+    async exchangeToken(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/exchange-token`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Retrieves the identity of the currently authenticated user.
+     *
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The identity object for the authenticated user.
+     */
+    async me(options = {}) {
+        return this.sendRequest('get', `${this.basePath}/me`, options);
+    }
+}

package/esm/clients/modules/base-module.d.ts

@@ -0,0 +1,17 @@
+import { FetchOptions } from 'openapi-fetch';
+import { HttpMethod } from 'openapi-typescript-helpers';
+import { BaseClientInterface, InitParam } from '../base-client-interface.js';
+import { FileDataResponse } from '../responses/index.js';
+export type RequestOptions<T = any> = FetchOptions<T>;
+export declare abstract class BaseModule {
+    private readonly _client;
+    protected constructor(_client: BaseClientInterface);
+    protected sendRequest<Resp = any>(method: HttpMethod, path: string, ...params: InitParam<any>): Promise<Resp>;
+    protected sendRequestRaw<Resp = any>(method: HttpMethod, path: string, ...params: InitParam<any>): Promise<{
+        data: Resp;
+        error: any;
+        response: Response;
+    }>;
+    protected toFileResponse(response: Response, defaultName?: string): FileDataResponse;
+    protected handleError(error: any, response: Response): void;
+}

package/esm/clients/modules/base-module.js

@@ -0,0 +1,49 @@
+import { FileDataResponse } from '../responses/index.js';
+import { ClientError } from '../../errors/index.js';
+export class BaseModule {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async sendRequest(method, path, ...params) {
+        return this._client.sendRequestPromise(method, path, ...params);
+    }
+    async sendRequestRaw(method, path, ...params) {
+        return (await this._client.sendRequestRawPromise(method, path, ...params));
+    }
+    toFileResponse(response, defaultName = 'unknown') {
+        const fileName = response.headers
+            .get('Content-Disposition')
+            ?.split('filename=')[1]
+            ?.replace(/"/g, '') ?? defaultName;
+        const length = response.headers.get('Content-Length') ?? '0';
+        const maxAge = response.headers
+            .get('Cache-Control')
+            ?.split('max-age=')[1]
+            ?.replace(/"/g, '');
+        const matchRangeParts = response.headers
+            .get('Content-Range')
+            ?.match(/^bytes (\d+)-(\d+)\/(\d+)$/);
+        let range = undefined;
+        if (matchRangeParts) {
+            const [, start, end, total] = matchRangeParts;
+            range = {
+                start: parseInt(start, 10),
+                end: parseInt(end, 10),
+                total: parseInt(total, 10)
+            };
+        }
+        return new FileDataResponse({
+            fileName,
+            stream: response.body,
+            type: response.headers.get('Content-Type') ?? '',
+            length: parseInt(length, 10),
+            range,
+            maxAge: maxAge ? parseInt(maxAge, 10) : undefined,
+            expiresAt: response.headers.get('Expires') ?? undefined
+        });
+    }
+    handleError(error, response) {
+        throw new ClientError(error.message ?? response.statusText ?? 'Unknown error', error.errorCode ?? response.status, response, error);
+    }
+}

package/esm/clients/modules/files-client.d.ts

@@ -0,0 +1,27 @@
+import { BaseModule, RequestOptions } from './base-module.js';
+import { BaseClientInterface } from '../base-client-interface.js';
+import { FileDataResponse } from '../responses/index.js';
+import { FILE_OPERATIONS } from '../../constants.js';
+export type FilesInterface = {
+    [K in keyof typeof FILE_OPERATIONS]: (...args: any[]) => Promise<any>;
+};
+export declare class FilesClient extends BaseModule implements FilesInterface {
+    readonly basePath: string;
+    constructor(client: BaseClientInterface, basePath: string);
+    /**
+     * Downloads a publicly accessible file by its path/name.
+     *
+     * @param {string} fileName - The path or name of the file to retrieve from the public storage.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns {@link FileDataResponse} containing the readable stream and file metadata.
+     */
+    public(fileName: string, options?: RequestOptions): Promise<FileDataResponse>;
+    /**
+     * Downloads a protected file by its path/name. Requires the request to be authenticated.
+     *
+     * @param {string} fileName - The path or name of the file to retrieve from the protected storage.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns {@link FileDataResponse} containing the readable stream and file metadata.
+     */
+    protected(fileName: string, options?: RequestOptions): Promise<FileDataResponse>;
+}

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

@@ -0,0 +1,42 @@
+import { BaseModule } from './base-module.js';
+export class FilesClient extends BaseModule {
+    basePath;
+    constructor(client, basePath) {
+        super(client);
+        this.basePath = basePath;
+    }
+    /**
+     * Downloads a publicly accessible file by its path/name.
+     *
+     * @param {string} fileName - The path or name of the file to retrieve from the public storage.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns {@link FileDataResponse} containing the readable stream and file metadata.
+     */
+    async public(fileName, options = {}) {
+        const { error, response } = await this.sendRequestRaw('get', `${this.basePath}/public/${fileName}`, {
+            ...options,
+            parseAs: 'stream'
+        });
+        if (error) {
+            this.handleError(error, response);
+        }
+        return this.toFileResponse(response, fileName);
+    }
+    /**
+     * Downloads a protected file by its path/name. Requires the request to be authenticated.
+     *
+     * @param {string} fileName - The path or name of the file to retrieve from the protected storage.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns {@link FileDataResponse} containing the readable stream and file metadata.
+     */
+    async protected(fileName, options = {}) {
+        const { error, response } = await this.sendRequestRaw('get', `${this.basePath}/protected/${fileName}`, {
+            ...options,
+            parseAs: 'stream'
+        });
+        if (error) {
+            this.handleError(error, response);
+        }
+        return this.toFileResponse(response, fileName);
+    }
+}

package/esm/clients/modules/health-client.d.ts

@@ -0,0 +1,25 @@
+import { BaseModule, RequestOptions } from './base-module.js';
+import { BaseClientInterface } from '../base-client-interface.js';
+import { HEALTH_OPERATIONS, HEALTH_TYPES } from '../../constants.js';
+export type HealthType = Record<(typeof HEALTH_TYPES)[number], unknown>;
+export type HealthInterface = {
+    [K in keyof typeof HEALTH_OPERATIONS]: (...args: any[]) => Promise<any>;
+};
+export declare class HealthClient<Health extends HealthType> extends BaseModule implements HealthInterface {
+    readonly basePath: string;
+    constructor(client: BaseClientInterface, basePath: string);
+    /**
+     * Performs a basic health check against the server.
+     *
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The health check response indicating overall server and it's services status.
+     */
+    check(options?: RequestOptions): Promise<Health['checkResponse']>;
+    /**
+     * Checks whether the server is ready to accept traffic (e.g., database connected, migrations applied).
+     *
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The readiness response indicating whether the server is fully operational.
+     */
+    ready(options?: RequestOptions): Promise<Health['readyResponse']>;
+}

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

@@ -0,0 +1,30 @@
+import { BaseModule } from './base-module.js';
+export class HealthClient extends BaseModule {
+    basePath;
+    constructor(client, basePath) {
+        super(client);
+        this.basePath = basePath;
+    }
+    /**
+     * Performs a basic health check against the server.
+     *
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The health check response indicating overall server and it's services status.
+     */
+    async check(options = {}) {
+        const { data, error, response } = await this.sendRequestRaw('get', `${this.basePath}/check`, options);
+        if (error && response.status !== 503) {
+            this.handleError(error, response);
+        }
+        return data ?? error;
+    }
+    /**
+     * Checks whether the server is ready to accept traffic (e.g., database connected, migrations applied).
+     *
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The readiness response indicating whether the server is fully operational.
+     */
+    async ready(options = {}) {
+        return this.sendRequest('get', `${this.basePath}/ready`, options);
+    }
+}

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

@@ -0,0 +1,6 @@
+export * from './account-client.js';
+export * from './auth-client.js';
+export * from './base-module.js';
+export * from './files-client.js';
+export * from './health-client.js';
+export * from './resource-client.js';

package/esm/clients/modules/index.js

@@ -0,0 +1,6 @@
+export * from './account-client.js';
+export * from './auth-client.js';
+export * from './base-module.js';
+export * from './files-client.js';
+export * from './health-client.js';
+export * from './resource-client.js';

package/esm/clients/modules/resource-client.d.ts

@@ -0,0 +1,90 @@
+import { BaseModule, RequestOptions } from './base-module.js';
+import { BaseClientInterface } from '../base-client-interface.js';
+import { FileDataResponse } from '../responses/index.js';
+import { RESOURCE_OPERATIONS, RESOURCE_TYPES } from '../../constants.js';
+export type ResourceType = Record<(typeof RESOURCE_TYPES)[number], unknown>;
+export type ResourceInterface = {
+    [K in keyof typeof RESOURCE_OPERATIONS]: (...args: any[]) => Promise<any>;
+};
+export declare class ResourceClient<Resource extends ResourceType> extends BaseModule implements ResourceInterface {
+    readonly basePath: string;
+    constructor(client: BaseClientInterface, basePath: string);
+    /**
+     * 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.
+     */
+    find(id: number, options?: RequestOptions): Promise<Resource['single']>;
+    /**
+     * 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.
+     */
+    query(request: Resource['queryRequest'], options?: RequestOptions): Promise<Resource['queryResponse']>;
+    /**
+     * 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.
+     */
+    aggregate(request: Resource['aggregateRequest'], options?: RequestOptions): Promise<Resource['aggregateResponse']>;
+    /**
+     * 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.
+     */
+    create(resource: Resource['create'], options?: RequestOptions): Promise<Resource['single']>;
+    /**
+     * 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.
+     */
+    update(resource: Resource['update'] & {
+        id: number;
+    }, options?: RequestOptions): Promise<Resource['single']>;
+    /**
+     * 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.
+     */
+    delete(id: number, options?: RequestOptions): Promise<Resource['single']>;
+    /**
+     * 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.
+     */
+    export(request: Resource['exportRequest'], options?: RequestOptions): Promise<FileDataResponse>;
+    /**
+     * 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.
+     */
+    uploadFiles(id: number, files: Resource['fileUpload'], options?: RequestOptions): Promise<Resource['files']>;
+    /**
+     * 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.
+     */
+    deleteFiles(id: number, files: Resource['fileDelete'], options?: RequestOptions): Promise<Resource['files']>;
+}