instasign 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -1,21 +1,1406 @@
-import { Envelopes } from './resources/Envelopes.js';
-import { SignRequests } from './resources/SignRequests.js';
-import { Webhooks } from './resources/Webhooks.js';
-export * from './resources/Envelopes.js';
-export * from './resources/SignRequests.js';
-export * from './resources/Webhooks.js';
-export type * from './schema.js';
-export interface IInstasignConfig {
+import { AxiosInstance } from 'axios';
+import { WebhookEventType, WebhookPayloadMap } from '@instasign/types';
+
+type Metadata = Record<string, unknown>;
+/** A sign request nested inside an envelope response */
+interface EnvelopeSignRequest {
+    requestId?: string;
+    status?: Metadata;
+    fileName?: string;
+    fileUrl?: string;
+    signedFileUrl?: string;
+    metadata?: Metadata;
+    clientReferenceId?: string;
+}
+/** A full envelope with its sign requests */
+interface Envelope {
+    signUrl?: string;
+    envelopeId?: string;
+    name?: string;
+    description?: string;
+    status?: Metadata;
+    clientReferenceId?: string;
+    signRequests?: EnvelopeSignRequest[];
+}
+/** Envelope as returned in a list (includes createdAt as ISO string) */
+interface EnvelopeListItem extends Envelope {
+    createdAt?: string;
+}
+interface CreateEnvelopeParams {
+    /** The name of the envelope */
+    name: string;
+    /** The description of the envelope */
+    description?: string;
+    /** Associated metadata for the envelope */
+    metadata?: Metadata;
+    /** The expiration date of the envelope (ISO 8601) */
+    expirationDate?: string;
+    /** External reference ID for the client */
+    clientReferenceId?: string;
+}
+interface GetEnvelopesParams {
+    /** Filter by envelope name (case-insensitive regex) */
+    name?: string;
+    /** Filter by envelope status */
+    status?: string;
+    /** Filter by client reference ID */
+    clientReferenceId?: string;
+    signRequests?: Metadata[];
+    /** Field to order by (createdAt or updatedAt) */
+    orderBy?: string;
+    /** Order direction (asc or desc) */
+    orderDirection?: string;
+    /** Filter by expiration date greater than or equal to */
+    expirationDateStart?: string;
+    /** Filter by expiration date less than or equal to */
+    expirationDateEnd?: string;
+    /** Number of items to skip for pagination */
+    skip?: number;
+    /** Maximum number of items to return */
+    limit?: number;
+}
+interface UpdateEnvelopeMetadataParams {
+    /** The unique identifier of the envelope */
+    envelopeId: string;
+    /** The metadata to be merged into the existing envelope metadata */
+    metadata: Metadata;
+}
+interface RemoveSignRequestFromEnvelopeParams {
+    /** The unique identifier of the envelope */
+    envelopeId: string;
+    /** The unique identifier of the sign request */
+    requestId: string;
+}
+interface AddSignRequestToEnvelopeParams {
+    /** The unique identifier of the envelope */
+    envelopeId: string;
+    /** The name of the file to be signed */
+    filename: string;
+    /** The base64 encoded content of the file */
+    base64File?: string;
+    /** Remote URL of the file. MUST be publicly accessible. */
+    fileUrl?: string;
+    /** Associated metadata for the sign request */
+    metadata?: Metadata;
+}
+interface CreateEnvelopeResponse {
+    envelopeId?: string;
+}
+interface OperationResponse {
+    success?: boolean;
+    message?: string;
+}
+interface UpdateEnvelopeMetadataResponse {
+    envelopeId?: string;
+    metadata?: Metadata;
+}
+interface AddSignRequestToEnvelopeResponse {
+    requestId?: string;
+    signUrl?: string;
+    envelopeSignUrl?: string;
+}
+interface CreateSignRequestParams {
+    /** The name of the file to be signed */
+    filename: string;
+    /** The base64 encoded content of the file */
+    base64File?: string;
+    /** Remote URL of the file. MUST be publicly accessible. */
+    fileUrl?: string;
+    /** Associated metadata for the sign request */
+    metadata?: Metadata;
+}
+interface CompleteSignRequestParams {
+    /** The unique identifier of the sign request to complete */
+    requestId: string;
+    /** The base64 encoded content of the signed file */
+    signedFileDataBase64: string;
+}
+interface CreateSignRequestResponse {
+    requestId?: string;
+    signUrl?: string;
+}
+interface CompleteSignRequestResponse {
+    signedFileUrl?: string;
+}
+interface SignRequestFile {
+    requestId?: string;
+    name?: string;
+    originalFile?: string;
+    signedFile?: string;
+    metadata?: Metadata;
+    status?: string;
+}
+type WebhookEvent = {
+    [T in WebhookEventType]: {
+        eventType: T;
+    } & WebhookPayloadMap[T];
+}[WebhookEventType];
+
+declare class Envelopes {
+    private client;
+    constructor(client: AxiosInstance);
+    /**
+     * Create a new envelope
+     */
+    create(params: CreateEnvelopeParams): Promise<CreateEnvelopeResponse | undefined>;
+    /**
+     * List envelopes
+     */
+    list(params?: GetEnvelopesParams): Promise<EnvelopeListItem[] | undefined>;
+    /**
+     * Retrieve a single envelope with its sign requests
+     */
+    get(envelopeId: string): Promise<Envelope | undefined>;
+    /**
+     * Complete an envelope
+     */
+    complete(envelopeId: string): Promise<OperationResponse | undefined>;
+    /**
+     * Delete an envelope
+     */
+    delete(envelopeId: string): Promise<OperationResponse | undefined>;
+    /**
+     * Update envelope metadata
+     */
+    updateMetadata(params: UpdateEnvelopeMetadataParams): Promise<UpdateEnvelopeMetadataResponse | undefined>;
+    /**
+     * Remove a sign request from an envelope
+     */
+    removeSignRequest(params: RemoveSignRequestFromEnvelopeParams): Promise<OperationResponse | undefined>;
+    /**
+     * Add a sign request to an envelope
+     */
+    addSignRequest(params: AddSignRequestToEnvelopeParams): Promise<AddSignRequestToEnvelopeResponse | undefined>;
+}
+
+declare class SignRequests {
+    private client;
+    constructor(client: AxiosInstance);
+    /**
+     * Create a new sign request
+     */
+    create(params: CreateSignRequestParams): Promise<CreateSignRequestResponse | undefined>;
+    /**
+     * Complete a sign request
+     */
+    complete(params: CompleteSignRequestParams): Promise<CompleteSignRequestResponse | undefined>;
+    /**
+     * Get the file associated with a sign request
+     */
+    getFile(requestId: string): Promise<SignRequestFile | undefined>;
+}
+
+declare class Webhooks {
+    private tolerance;
+    constructor(tolerance?: number);
+    /**
+     * Verify and parse a webhook event
+     */
+    constructEvent(payload: string, signatureHeader: string, webhookSecret: string): WebhookEvent;
+}
+
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+interface paths {
+    "/functions/addSignRequestToEnvelope": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: addSignRequestToEnvelope */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The unique identifier of the envelope */
+                        envelopeId: string;
+                        /** @description The name of the file to be signed */
+                        filename: string;
+                        /** @description The base64 encoded content of the file */
+                        base64File?: string;
+                        /** @description Remote URL of the file. MUST be publicly accessible. */
+                        fileUrl?: string;
+                        /** @description Associated metadata for the sign request */
+                        metadata?: {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                requestId?: string;
+                                signUrl?: string;
+                                envelopeSignUrl?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/completeEnvelope": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: completeEnvelope */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The unique identifier of the envelope to mark as completed */
+                        envelopeId: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                success?: boolean;
+                                message?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/createEnvelope": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: createEnvelope */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The name of the envelope */
+                        name: string;
+                        /** @description The description of the envelope */
+                        description?: string;
+                        /** @description Associated metadata for the envelope */
+                        metadata?: {
+                            [key: string]: unknown;
+                        };
+                        /**
+                         * Format: date-time
+                         * @description The expiration date of the envelope
+                         */
+                        expirationDate?: string;
+                        /** @description External reference ID for the client */
+                        clientReferenceId?: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                envelopeId?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/deleteEnvelope": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: deleteEnvelope */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The unique identifier of the envelope to delete */
+                        envelopeId: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                success?: boolean;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/getEnvelope": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: getEnvelope */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The unique identifier of the envelope */
+                        envelopeId: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                signUrl?: string;
+                                envelopeId?: string;
+                                name?: string;
+                                description?: string;
+                                status?: {
+                                    [key: string]: unknown;
+                                };
+                                clientReferenceId?: string;
+                                signRequests?: {
+                                    requestId?: string;
+                                    status?: {
+                                        [key: string]: unknown;
+                                    };
+                                    fileName?: string;
+                                    fileUrl?: string;
+                                    signedFileUrl?: string;
+                                    metadata?: {
+                                        [key: string]: unknown;
+                                    };
+                                    clientReferenceId?: string;
+                                }[];
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/getEnvelopes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: getEnvelopes */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description Filter by envelope name (case-insensitive regex) */
+                        name?: string;
+                        /** @description Filter by envelope status */
+                        status?: string;
+                        /** @description Filter by client reference ID */
+                        clientReferenceId?: string;
+                        /** @description Filter by a list of sign request IDs */
+                        signRequests?: {
+                            [key: string]: unknown;
+                        }[];
+                        /** @description Field to order by (createdAt or updatedAt) */
+                        orderBy?: string;
+                        /** @description Order direction (asc or desc) */
+                        orderDirection?: string;
+                        /** @description Filter by expiration date greater than or equal to */
+                        expirationDateStart?: string;
+                        /** @description Filter by expiration date less than or equal to */
+                        expirationDateEnd?: string;
+                        /** @description Number of items to skip for pagination */
+                        skip?: number;
+                        /** @description Maximum number of items to return */
+                        limit?: number;
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                signUrl?: string;
+                                envelopeId?: string;
+                                name?: string;
+                                description?: string;
+                                status?: {
+                                    [key: string]: unknown;
+                                };
+                                clientReferenceId?: string;
+                                signRequests?: {
+                                    requestId?: {
+                                        [key: string]: unknown;
+                                    };
+                                    status?: {
+                                        [key: string]: unknown;
+                                    };
+                                    fileName?: {
+                                        [key: string]: unknown;
+                                    };
+                                    fileUrl?: {
+                                        [key: string]: unknown;
+                                    };
+                                    signedFileUrl?: {
+                                        [key: string]: unknown;
+                                    };
+                                    metadata?: {
+                                        [key: string]: unknown;
+                                    };
+                                    clientReferenceId?: {
+                                        [key: string]: unknown;
+                                    };
+                                }[];
+                                createdAt?: {
+                                    toDateString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toTimeString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toLocaleDateString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toLocaleTimeString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getTime?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getDay?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCDay?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getTimezoneOffset?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setTime?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toUTCString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toISOString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toJSON?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getVarDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                };
+                                updatedAt?: {
+                                    toDateString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toTimeString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toLocaleDateString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toLocaleTimeString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getTime?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getDay?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCDay?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getTimezoneOffset?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setTime?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toUTCString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toISOString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toJSON?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getVarDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                };
+                                expirationDate?: {
+                                    toDateString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toTimeString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toLocaleDateString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toLocaleTimeString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getTime?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getDay?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCDay?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getUTCMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getTimezoneOffset?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setTime?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCMilliseconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCSeconds?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCMinutes?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCHours?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCMonth?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    setUTCFullYear?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toUTCString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toISOString?: {
+                                        [key: string]: unknown;
+                                    };
+                                    toJSON?: {
+                                        [key: string]: unknown;
+                                    };
+                                    getVarDate?: {
+                                        [key: string]: unknown;
+                                    };
+                                };
+                            }[];
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/removeSignRequestFromEnvelope": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: removeSignRequestFromEnvelope */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The unique identifier of the envelope */
+                        envelopeId: string;
+                        /** @description The unique identifier of the sign request */
+                        requestId: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                success?: boolean;
+                                message?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/updateEnvelopeMetadata": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: updateEnvelopeMetadata */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The unique identifier of the envelope */
+                        envelopeId: string;
+                        /** @description The metadata to be merged into the existing envelope metadata */
+                        metadata: {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                envelopeId?: string;
+                                metadata?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/completeSignRequest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: completeSignRequest */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The unique identifier of the sign request to complete */
+                        requestId: string;
+                        /** @description The base64 encoded content of the signed file */
+                        signedFileDataBase64: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                signedFileUrl?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/createSignRequest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: createSignRequest */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The name of the file to be signed */
+                        filename: string;
+                        /** @description The base64 encoded content of the file */
+                        base64File?: string;
+                        /** @description Remote URL of the file. MUST be publicly accessible. */
+                        fileUrl?: string;
+                        /** @description Associated metadata for the sign request */
+                        metadata?: {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                requestId?: string;
+                                signUrl?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/getFileFromRequestId": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: getFileFromRequestId */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The unique identifier of the sign request */
+                        requestId: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                requestId?: string;
+                                name?: string;
+                                originalFile?: string;
+                                signedFile?: string;
+                                metadata?: {
+                                    [key: string]: unknown;
+                                };
+                                status?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/getSignedFile": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: getSignedFile */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The unique identifier of the sign request */
+                        requestId: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                fileName?: string;
+                                fileUrl?: string;
+                                signedFileUrl?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/functions/updateSignRequestMetadata": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cloud Function: updateSignRequestMetadata */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The unique identifier of the sign request */
+                        requestId: string;
+                        /** @description The metadata to be merged into the existing sign request metadata */
+                        metadata: {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result?: {
+                                requestId?: string;
+                                metadata?: {
+                                    [key: string]: unknown;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+type webhooks = Record<string, never>;
+interface components {
+    schemas: {
+        ApiLog: {
+            apiKey?: string;
+            functionName?: string;
+            statusCode?: string;
+            statusMessage?: string;
+        };
+        Authentication: {
+            apiKey?: string;
+            name?: string;
+            status?: string;
+            expirationDate?: string;
+            callbackUrl?: string;
+            webhookSecret?: string;
+        };
+        Envelope: {
+            name?: string;
+            description?: string;
+            envelopeId?: string;
+            signRequests?: string;
+            status?: string;
+            metadata?: string;
+            apiKey?: string;
+            expirationDate?: string;
+            isDeleted?: string;
+            clientReferenceId?: string;
+        };
+        SignRequest: {
+            status?: string;
+            file?: string;
+            fileName?: string;
+            signedFile?: string;
+            requestId?: string;
+            metadata?: string;
+            apiKey?: string;
+            expirationDate?: string;
+            isDeleted?: string;
+            clientReferenceId?: string;
+        };
+        WebhookLog: {
+            status?: string;
+            message?: string;
+            signRequest?: string;
+            envelope?: string;
+            eventType?: string;
+            delivered?: string;
+            retryCount?: string;
+            nextRetryAt?: string;
+            payload?: string;
+            apiKey?: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+type $defs = Record<string, never>;
+type operations = Record<string, never>;
+
+interface IInstasignConfig {
     apiKey: string;
     appId?: string;
     restApiKey?: string;
     serverUrl?: string;
     webhookTolerance?: number;
 }
-export declare class Instasign {
+declare class Instasign {
     private client;
     envelopes: Envelopes;
     signRequests: SignRequests;
     webhooks: Webhooks;
     constructor(config: IInstasignConfig);
 }
+
+export { type $defs, Envelopes, type IInstasignConfig, Instasign, SignRequests, Webhooks, type components, type operations, type paths, type webhooks };