instasign 1.0.3 → 1.1.2

package/dist/index.d.ts

@@ -1,21 +1,1421 @@
-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];
+type EnvelopeCreatedEvent = Extract<WebhookEvent, {
+    eventType: 'envelope_created';
+}>;
+type EnvelopeExpiredEvent = Extract<WebhookEvent, {
+    eventType: 'envelope_expired';
+}>;
+type SignRequestCreatedEvent = Extract<WebhookEvent, {
+    eventType: 'sign_request_created';
+}>;
+type SignRequestSignedEvent = Extract<WebhookEvent, {
+    eventType: 'sign_request_signed';
+}>;
+type SignRequestExpiredEvent = Extract<WebhookEvent, {
+    eventType: 'sign_request_expired';
+}>;
+
+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, type AddSignRequestToEnvelopeParams, type AddSignRequestToEnvelopeResponse, type CompleteSignRequestParams, type CompleteSignRequestResponse, type CreateEnvelopeParams, type CreateEnvelopeResponse, type CreateSignRequestParams, type CreateSignRequestResponse, type Envelope, type EnvelopeCreatedEvent, type EnvelopeExpiredEvent, type EnvelopeListItem, type EnvelopeSignRequest, Envelopes, type GetEnvelopesParams, type IInstasignConfig, Instasign, type Metadata, type OperationResponse, type RemoveSignRequestFromEnvelopeParams, type SignRequestCreatedEvent, type SignRequestExpiredEvent, type SignRequestFile, type SignRequestSignedEvent, SignRequests, type UpdateEnvelopeMetadataParams, type UpdateEnvelopeMetadataResponse, type WebhookEvent, Webhooks, type components, type operations, type paths, type webhooks };