@frogbotai/piece-resend 0.22.0 → 0.24.0

package/dist/index.d.ts

@@ -1,50 +1,581 @@
-import { type PieceFactoryConfig } from 'frogbot/pieces';
-export declare const resendActions: readonly ["send_email"];
+export declare const resendActions: readonly ["send", "sendBatchEmails", "getEmailStatus", "listEmails", "cancelScheduledEmail", "rescheduleEmail", "createContact", "updateContact", "deleteContact", "listContacts", "listDomains", "createDomain", "deleteDomain", "verifyDomain", "listAudiences", "createAudience", "deleteAudience", "listBroadcasts", "createBroadcast", "sendBroadcast", "deleteBroadcast", "customApiCall"];
 export declare const resendScopes: readonly [];
-export declare function createResend(config?: PieceFactoryConfig): import("frogbot/pieces").Piece & {
-    /** Send Email: Send a text or HTML email */
-    sendEmail: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Batch Emails: Send up to 100 emails in a single API call */
-    sendBatchEmails: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Get Email Status: Retrieve the delivery status of a sent email */
-    getEmailStatus: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** List Sent Emails: Retrieve a list of emails sent from your Resend account */
-    listEmails: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Cancel Scheduled Email: Cancel a scheduled email before it is sent */
-    cancelScheduledEmail: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Reschedule Email: Update the send time of a scheduled email */
-    rescheduleEmail: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Create Contact: Add a contact to a Resend audience */
-    createContact: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Update Contact: Update the name or subscription status of a contact in an audience */
-    updateContact: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Delete Contact: Remove a contact from an audience */
-    deleteContact: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** List Contacts: Retrieve all contacts in an audience */
-    listContacts: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** List Domains: Retrieve all domains added to your Resend account */
-    listDomains: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Create Domain: Add a sending domain to your Resend account and get the DNS records to verify it */
-    createDomain: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Delete Domain: Remove a domain from your Resend account */
-    deleteDomain: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Verify Domain: Trigger a DNS verification check for a domain */
-    verifyDomain: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** List Audiences: Retrieve all contact audiences in your Resend account */
-    listAudiences: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Create Audience: Create a new contact audience in Resend */
-    createAudience: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Delete Audience: Permanently delete an audience and all its contacts */
-    deleteAudience: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** List Broadcasts: Retrieve all broadcasts in your Resend account */
-    listBroadcasts: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Create Broadcast: Create a new broadcast email to send to an audience */
-    createBroadcast: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Broadcast: Send or schedule a broadcast email to its audience */
-    sendBroadcast: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Delete Broadcast: Permanently delete a broadcast from your Resend account */
-    deleteBroadcast: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Custom API Call: Make a custom API call to a specific endpoint */
-    customApiCall: import("node_modules/frogbot/dist/tools/types").AnyTool;
-};
+export declare const createResend: import("frogbot").PieceFactory<{
+    slug: string;
+    label: string;
+    admin: {
+        description: string;
+        group: string;
+    };
+    auth: import("zod").ZodObject<{
+        apiKey: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+    options: import("zod").ZodObject<{
+        from: import("zod").ZodOptional<import("zod").ZodObject<{
+            address: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    client: ({ auth }: {
+        auth: {
+            apiKey: string;
+        };
+        options: {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        };
+    }) => {
+        request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+    };
+    actions: ({
+        slug: "cancelScheduledEmail";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            email_id: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            [k: string]: unknown;
+            email_id: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "createAudience";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            name: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "createBroadcast";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            audience_id: import("zod").ZodString;
+            from: import("zod").ZodString;
+            subject: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            reply_to: import("zod").ZodOptional<import("zod").ZodString>;
+            preview_text: import("zod").ZodOptional<import("zod").ZodString>;
+            content_type: import("zod").ZodEnum<{
+                text: "text";
+                html: "html";
+            }>;
+            content: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            audience_id: string;
+            from: string;
+            subject: string;
+            name?: string;
+            reply_to?: string;
+            preview_text?: string;
+            content_type: "html" | "text";
+            content: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "createContact";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            audience_id: import("zod").ZodString;
+            email: import("zod").ZodString;
+            first_name: import("zod").ZodOptional<import("zod").ZodString>;
+            last_name: import("zod").ZodOptional<import("zod").ZodString>;
+            unsubscribed: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            audience_id: string;
+            email: string;
+            first_name?: string;
+            last_name?: string;
+            unsubscribed?: boolean;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "createDomain";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            region: import("zod").ZodOptional<import("zod").ZodEnum<{
+                "us-east-1": "us-east-1";
+                "eu-west-1": "eu-west-1";
+                "ap-northeast-1": "ap-northeast-1";
+                "sa-east-1": "sa-east-1";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            name: string;
+            region?: "us-east-1" | "eu-west-1" | "ap-northeast-1" | "sa-east-1";
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<{
+            id: unknown;
+            name: unknown;
+            status: unknown;
+            region: unknown;
+            created_at: unknown;
+            sending: {};
+            receiving: {};
+            dns_records: unknown;
+        }>;
+    } | {
+        slug: "customApiCall";
+        description: string;
+        input: import("zod").ZodObject<{
+            method: import("zod").ZodString;
+            url: import("zod").ZodString;
+            headers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+            queryParams: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            body_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                none: "none";
+                json: "json";
+                form_data: "form_data";
+                raw: "raw";
+            }>>;
+            body: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            response_is_binary: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            failsafe: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+            followRedirects: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        run({ input, client, req }: import("frogbot").PieceRunArgs<{
+            method: string;
+            url: string;
+            headers?: {
+                [k: string]: string;
+            };
+            queryParams?: {
+                [k: string]: unknown;
+            };
+            body_type?: "none" | "json" | "form_data" | "raw";
+            body?: unknown;
+            response_is_binary?: boolean;
+            failsafe?: boolean;
+            timeout?: number;
+            followRedirects?: boolean;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "deleteAudience";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            audience_id: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            [k: string]: unknown;
+            audience_id: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "deleteBroadcast";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            broadcast_id: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            [k: string]: unknown;
+            broadcast_id: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "deleteContact";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            audience_id: import("zod").ZodString;
+            contact_id: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            [k: string]: unknown;
+            audience_id: string;
+            contact_id: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "deleteDomain";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            domain_id: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            [k: string]: unknown;
+            domain_id: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "getEmailStatus";
+        description: string;
+        idempotent: true;
+        input: import("zod").ZodObject<{
+            email_id: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            [k: string]: unknown;
+            email_id: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "listAudiences";
+        description: string;
+        idempotent: true;
+        input: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+        run({ client }: import("frogbot").PieceRunArgs<{}, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<import("frogbot").PieceJSON[]>;
+    } | {
+        slug: "listBroadcasts";
+        description: string;
+        idempotent: true;
+        input: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+        run({ client }: import("frogbot").PieceRunArgs<{}, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<{
+            id: unknown;
+            name: {};
+            audience_id: unknown;
+            from: unknown;
+            subject: unknown;
+            reply_to: {};
+            preview_text: {};
+            status: unknown;
+            created_at: unknown;
+            scheduled_at: {};
+            sent_at: {};
+        }[]>;
+    } | {
+        slug: "listContacts";
+        description: string;
+        idempotent: true;
+        input: import("zod").ZodObject<{
+            audience_id: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            [k: string]: unknown;
+            audience_id: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<import("frogbot").PieceJSON[]>;
+    } | {
+        slug: "listDomains";
+        description: string;
+        idempotent: true;
+        input: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+        run({ client }: import("frogbot").PieceRunArgs<{}, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<{
+            id: unknown;
+            name: unknown;
+            status: unknown;
+            region: unknown;
+            created_at: unknown;
+            sending: {};
+            receiving: {};
+        }[]>;
+    } | {
+        slug: "listEmails";
+        description: string;
+        idempotent: true;
+        input: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+        run({ client }: import("frogbot").PieceRunArgs<{}, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<{
+            id: unknown;
+            from: unknown;
+            to: string;
+            subject: unknown;
+            last_event: unknown;
+            created_at: unknown;
+            scheduled_at: {};
+            cc: string;
+            bcc: string;
+            reply_to: string;
+        }[]>;
+    } | {
+        slug: "rescheduleEmail";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            email_id: import("zod").ZodString;
+            scheduled_at: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            [k: string]: unknown;
+            email_id: string;
+            scheduled_at: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "send";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            to: import("zod").ZodArray<import("zod").ZodString>;
+            from_name: import("zod").ZodString;
+            from: import("zod").ZodString;
+            bcc: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            cc: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            reply_to: import("zod").ZodOptional<import("zod").ZodString>;
+            subject: import("zod").ZodString;
+            content_type: import("zod").ZodEnum<{
+                text: "text";
+                html: "html";
+            }>;
+            content: import("zod").ZodString;
+            scheduled_at: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            to: string[];
+            from_name: string;
+            from: string;
+            bcc?: string[];
+            cc?: string[];
+            reply_to?: string;
+            subject: string;
+            content_type: "html" | "text";
+            content: string;
+            scheduled_at?: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "sendBatchEmails";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            emails: import("zod").ZodArray<import("zod").ZodObject<{
+                from: import("zod").ZodString;
+                to: import("zod").ZodString;
+                subject: import("zod").ZodString;
+                content_type: import("zod").ZodEnum<{
+                    text: "text";
+                    html: "html";
+                }>;
+                content: import("zod").ZodString;
+                reply_to: import("zod").ZodOptional<import("zod").ZodString>;
+                cc: import("zod").ZodOptional<import("zod").ZodString>;
+                bcc: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            idempotency_key: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            emails: {
+                from: string;
+                to: string;
+                subject: string;
+                content_type: "html" | "text";
+                content: string;
+                reply_to?: string;
+                cc?: string;
+                bcc?: string;
+            }[];
+            idempotency_key?: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<import("frogbot").PieceJSON[]>;
+    } | {
+        slug: "sendBroadcast";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            broadcast_id: import("zod").ZodString;
+            scheduled_at: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$loose>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            [k: string]: unknown;
+            broadcast_id: string;
+            scheduled_at?: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "updateContact";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            audience_id: import("zod").ZodString;
+            contact_id: import("zod").ZodString;
+            first_name: import("zod").ZodOptional<import("zod").ZodString>;
+            last_name: import("zod").ZodOptional<import("zod").ZodString>;
+            unsubscribed: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            audience_id: string;
+            contact_id: string;
+            first_name?: string;
+            last_name?: string;
+            unsubscribed?: boolean;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    } | {
+        slug: "verifyDomain";
+        description: string;
+        idempotent: false;
+        input: import("zod").ZodObject<{
+            domain_id: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+        run({ input, client }: import("frogbot").PieceRunArgs<{
+            [k: string]: unknown;
+            domain_id: string;
+        }, {
+            from?: {
+                address: string;
+                name?: string;
+            };
+        }, {
+            request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+        }>): Promise<unknown>;
+    })[];
+    email: {
+        send({ message, client, options }: {
+            message: {
+                [x: string]: NodemailerSendMailOptions;
+                [x: number]: NodemailerSendMailOptions;
+                [x: symbol]: NodemailerSendMailOptions;
+                from?: ({
+                    address: string;
+                    name?: string;
+                } | string) | undefined;
+            };
+            client: {
+                request({ allowFailure, binary, body, headers, method, path, query, rawBody, redirect, response: includeResponse, signal, }: import("./client.js").ResendRequestOptions): Promise<unknown>;
+            };
+            options: {
+                from?: {
+                    address: string;
+                    name?: string;
+                };
+            };
+            req: import("frogbot").FrogbotRequest;
+        }): Promise<unknown>;
+    };
+}>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAElF,eAAO,MAAM,aAAa,yBAA0B,CAAC;AACrD,eAAO,MAAM,YAAY,aAAc,CAAC;AAExC,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,kBAAkB;IAUpD,4CAA4C;;IAE5C,oEAAoE;;IAEpE,qEAAqE;;IAErE,gFAAgF;;IAEhF,yEAAyE;;IAEzE,kEAAkE;;IAElE,yDAAyD;;IAEzD,yFAAyF;;IAEzF,wDAAwD;;IAExD,0DAA0D;;IAE1D,sEAAsE;;IAEtE,sGAAsG;;IAEtG,8DAA8D;;IAE9D,mEAAmE;;IAEnE,4EAA4E;;IAE5E,+DAA+D;;IAE/D,2EAA2E;;IAE3E,sEAAsE;;IAEtE,4EAA4E;;IAE5E,yEAAyE;;IAEzE,gFAAgF;;IAEhF,qEAAqE;;EAGxE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,aAAa,kYAuBhB,CAAC;AAEX,eAAO,MAAM,YAAY,aAAc,CAAC;AAExC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;oBAtD+B,CAAC;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAUzC,CAAC;kBAAsB,CAAC;mBACvC,CAAC;;;;;;oBAXsD,CAAC;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;oBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;wBAAD,CAAC;;;;;;EAsFF,CAAC"}