@mastra/connect 0.1.0 → 0.2.0-alpha.1

package/dist/providers/resend/tools/get-contact-import.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getContactImportInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getContactImportOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        in_progress: "in_progress";
+        queued: "queued";
+    }>, z.ZodString]>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    counts: z.ZodOptional<z.ZodObject<{
+        total: z.ZodOptional<z.ZodNumber>;
+        created: z.ZodOptional<z.ZodNumber>;
+        updated: z.ZodOptional<z.ZodNumber>;
+        skipped: z.ZodOptional<z.ZodNumber>;
+        failed: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare function getContactImportTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+    status?: string | undefined;
+    created_at?: string | undefined;
+    completed_at?: string | null | undefined;
+    counts?: {
+        [x: string]: unknown;
+        total?: number | undefined;
+        created?: number | undefined;
+        updated?: number | undefined;
+        skipped?: number | undefined;
+        failed?: number | undefined;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_contact_import", unknown>;
+//# sourceMappingURL=get-contact-import.d.ts.map

package/dist/providers/resend/tools/get-contact-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-contact-import.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-contact-import.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,2BAA2B;;iBAA6C,CAAC;AAsBtF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;yIAkBxD"}

package/dist/providers/resend/tools/get-contact-property.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getContactPropertyInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getContactPropertyOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    key: z.ZodString;
+    type: z.ZodUnion<[z.ZodEnum<{
+        number: "number";
+        string: "string";
+    }>, z.ZodString]>;
+    fallback_value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function getContactPropertyTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id: string;
+    key: string;
+    type: string;
+    fallback_value?: string | number | undefined;
+    created_at?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_contact_property", unknown>;
+//# sourceMappingURL=get-contact-property.d.ts.map

package/dist/providers/resend/tools/get-contact-property.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-contact-property.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-contact-property.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,6BAA6B;;iBAA6C,CAAC;AAaxF,eAAO,MAAM,8BAA8B;;;;;;;;;;iBAAyB,CAAC;AAErE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;2IAkB1D"}

package/dist/providers/resend/tools/get-contact.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getContactInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getContactOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    first_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    last_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    unsubscribed: z.ZodOptional<z.ZodBoolean>;
+    properties: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$loose>;
+export declare function getContactTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+    email?: string | undefined;
+    first_name?: string | null | undefined;
+    last_name?: string | null | undefined;
+    created_at?: string | undefined;
+    unsubscribed?: boolean | undefined;
+    properties?: {
+        [x: string]: unknown;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_contact", unknown>;
+//# sourceMappingURL=get-contact.d.ts.map

package/dist/providers/resend/tools/get-contact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-contact.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-contact.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,qBAAqB;;iBAA6C,CAAC;AAehF,eAAO,MAAM,sBAAsB;;;;;;;;;iBAAyB,CAAC;AAE7D,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;kIAkBlD"}

package/dist/providers/resend/tools/get-domain-claim.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getDomainClaimInputSchema: z.ZodObject<{
+    domain_id: z.ZodString;
+}, z.core.$loose>;
+export declare const getDomainClaimOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+        blocked: "blocked";
+        canceled: "canceled";
+        completed: "completed";
+        expired: "expired";
+        failed: "failed";
+        pending: "pending";
+        superseded: "superseded";
+        verified: "verified";
+    }>, z.ZodString]>>;
+    domain_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    region: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodEnum<{
+        "ap-northeast-1": "ap-northeast-1";
+        "eu-west-1": "eu-west-1";
+        "sa-east-1": "sa-east-1";
+        "us-east-1": "us-east-1";
+    }>, z.ZodString]>>>;
+    record: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodLiteral<"TXT">>;
+        name: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodString>;
+        ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    blocked_reason: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodEnum<{
+        grace_period: "grace_period";
+        pending_scheduled_emails: "pending_scheduled_emails";
+        recent_owner_activity: "recent_owner_activity";
+    }>, z.ZodString]>>>;
+    failure_reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function getDomainClaimTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    domain_id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    status?: string | undefined;
+    domain_id?: string | null | undefined;
+    region?: string | null | undefined;
+    record?: {
+        [x: string]: unknown;
+        type?: "TXT" | undefined;
+        name?: string | undefined;
+        value?: string | undefined;
+        ttl?: string | undefined;
+    } | undefined;
+    blocked_reason?: string | null | undefined;
+    failure_reason?: string | null | undefined;
+    created_at?: string | undefined;
+    expires_at?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_domain_claim", unknown>;
+//# sourceMappingURL=get-domain-claim.d.ts.map

package/dist/providers/resend/tools/get-domain-claim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-domain-claim.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-domain-claim.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,yBAAyB;;iBAAoD,CAAC;AAiC3F,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAEjE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;uIAkBtD"}

package/dist/providers/resend/tools/get-domain.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getDomainInputSchema: z.ZodObject<{
+    domain_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getDomainOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+        failed: "failed";
+        not_started: "not_started";
+        partially_failed: "partially_failed";
+        partially_verified: "partially_verified";
+        pending: "pending";
+        verified: "verified";
+    }>, z.ZodString]>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    open_tracking: z.ZodOptional<z.ZodBoolean>;
+    click_tracking: z.ZodOptional<z.ZodBoolean>;
+    tracking_subdomain: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        sending: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+            disabled: "disabled";
+            enabled: "enabled";
+        }>, z.ZodString]>>;
+        receiving: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+            disabled: "disabled";
+            enabled: "enabled";
+        }>, z.ZodString]>>;
+    }, z.core.$loose>>;
+    records: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        record: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+            DKIM: "DKIM";
+            Receiving: "Receiving";
+            SPF: "SPF";
+            Tracking: "Tracking";
+            TrackingCAA: "TrackingCAA";
+        }>, z.ZodString]>>;
+        name: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+            CAA: "CAA";
+            CNAME: "CNAME";
+            MX: "MX";
+            TXT: "TXT";
+        }>, z.ZodString]>>;
+        ttl: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+            failed: "failed";
+            not_started: "not_started";
+            pending: "pending";
+            temporary_failure: "temporary_failure";
+            verified: "verified";
+        }>, z.ZodString]>>;
+        value: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare function getDomainTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    domain_id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    status?: string | undefined;
+    created_at?: string | undefined;
+    region?: string | undefined;
+    open_tracking?: boolean | undefined;
+    click_tracking?: boolean | undefined;
+    tracking_subdomain?: string | undefined;
+    capabilities?: {
+        [x: string]: unknown;
+        sending?: string | undefined;
+        receiving?: string | undefined;
+    } | undefined;
+    records?: {
+        [x: string]: unknown;
+        record?: string | undefined;
+        name?: string | undefined;
+        type?: string | undefined;
+        ttl?: string | undefined;
+        status?: string | undefined;
+        value?: string | undefined;
+        priority?: number | undefined;
+    }[] | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_domain", unknown>;
+//# sourceMappingURL=get-domain.d.ts.map

package/dist/providers/resend/tools/get-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-domain.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-domain.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,oBAAoB;;iBAAsC,CAAC;AA4CxE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAE5D,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;iIAkBjD"}

package/dist/providers/resend/tools/get-email-attachment.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getEmailAttachmentInputSchema: z.ZodObject<{
+    email_id: z.ZodString;
+    attachment_id: z.ZodString;
+}, z.core.$loose>;
+export declare const getEmailAttachmentOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    content_type: z.ZodOptional<z.ZodString>;
+    content_id: z.ZodOptional<z.ZodString>;
+    content_disposition: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodEnum<{
+        attachment: "attachment";
+        inline: "inline";
+    }>, z.ZodString]>>>;
+    download_url: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export declare function getEmailAttachmentTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    email_id: string;
+    attachment_id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+    filename?: string | null | undefined;
+    content_type?: string | undefined;
+    content_id?: string | undefined;
+    content_disposition?: string | null | undefined;
+    download_url?: string | undefined;
+    expires_at?: string | undefined;
+    size?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_email_attachment", unknown>;
+//# sourceMappingURL=get-email-attachment.d.ts.map

package/dist/providers/resend/tools/get-email-attachment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-email-attachment.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-email-attachment.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,6BAA6B;;;iBAE1B,CAAC;AAgBjB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAAyB,CAAC;AAErE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;2IAkB1D"}

package/dist/providers/resend/tools/get-email-metrics.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getEmailMetricsInputSchema: z.ZodObject<{
+    start_date: z.ZodOptional<z.ZodString>;
+    end_date: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+    granularity: z.ZodOptional<z.ZodEnum<{
+        daily: "daily";
+        hourly: "hourly";
+        monthly: "monthly";
+        weekly: "weekly";
+    }>>;
+    metrics: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        bounce_rate: "bounce_rate";
+        bounced: "bounced";
+        bounced_permanent: "bounced_permanent";
+        bounced_transient: "bounced_transient";
+        bounced_undetermined: "bounced_undetermined";
+        click_rate: "click_rate";
+        clicked: "clicked";
+        complained: "complained";
+        complaint_rate: "complaint_rate";
+        delivered: "delivered";
+        delivery_delayed: "delivery_delayed";
+        delivery_rate: "delivery_rate";
+        failed: "failed";
+        open_rate: "open_rate";
+        opened: "opened";
+        received: "received";
+        sent: "sent";
+        suppressed: "suppressed";
+        unique_clicked: "unique_clicked";
+        unique_opened: "unique_opened";
+        unsubscribe_rate: "unsubscribe_rate";
+        unsubscribed: "unsubscribed";
+    }>>>;
+    dimensions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        broadcast: "broadcast";
+        domain: "domain";
+        email: "email";
+        period: "period";
+    }>>>;
+    domain_id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    email_id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    broadcast_id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export declare const getEmailMetricsOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    start_date: z.ZodOptional<z.ZodString>;
+    end_date: z.ZodOptional<z.ZodString>;
+    metrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dimensions: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<{
+        broadcast: "broadcast";
+        domain: "domain";
+        email: "email";
+        period: "period";
+    }>, z.ZodString]>>>;
+    granularity: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+        daily: "daily";
+        hourly: "hourly";
+        monthly: "monthly";
+        weekly: "weekly";
+    }>, z.ZodString]>>;
+    totals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        period: z.ZodOptional<z.ZodString>;
+        domain_id: z.ZodOptional<z.ZodString>;
+        domain_name: z.ZodOptional<z.ZodString>;
+        email_id: z.ZodOptional<z.ZodString>;
+        broadcast_id: z.ZodOptional<z.ZodString>;
+        broadcast_name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare function getEmailMetricsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    start_date?: string | undefined;
+    end_date?: string | undefined;
+    timezone?: string | undefined;
+    granularity?: "daily" | "hourly" | "monthly" | "weekly" | undefined;
+    metrics?: ("bounce_rate" | "bounced" | "bounced_permanent" | "bounced_transient" | "bounced_undetermined" | "click_rate" | "clicked" | "complained" | "complaint_rate" | "delivered" | "delivery_delayed" | "delivery_rate" | "failed" | "open_rate" | "opened" | "received" | "sent" | "suppressed" | "unique_clicked" | "unique_opened" | "unsubscribe_rate" | "unsubscribed")[] | undefined;
+    dimensions?: ("broadcast" | "domain" | "email" | "period")[] | undefined;
+    domain_id?: string[] | undefined;
+    email_id?: string[] | undefined;
+    broadcast_id?: string[] | undefined;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    start_date?: string | undefined;
+    end_date?: string | undefined;
+    metrics?: string[] | undefined;
+    dimensions?: string[] | undefined;
+    granularity?: string | undefined;
+    totals?: Record<string, number> | undefined;
+    data?: {
+        [x: string]: unknown;
+        period?: string | undefined;
+        domain_id?: string | undefined;
+        domain_name?: string | undefined;
+        email_id?: string | undefined;
+        broadcast_id?: string | undefined;
+        broadcast_name?: string | undefined;
+    }[] | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_email_metrics", unknown>;
+//# sourceMappingURL=get-email-metrics.d.ts.map

package/dist/providers/resend/tools/get-email-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-email-metrics.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-email-metrics.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCvB,CAAC;AA4BjB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAElE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wIAiCvD"}

package/dist/providers/resend/tools/get-email.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getEmailInputSchema: z.ZodObject<{
+    email_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getEmailOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    message_id: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    from: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    html: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    bcc: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    cc: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    reply_to: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    last_event: z.ZodOptional<z.ZodEnum<{
+        bounced: "bounced";
+        canceled: "canceled";
+        clicked: "clicked";
+        complained: "complained";
+        delivered: "delivered";
+        delivery_delayed: "delivery_delayed";
+        failed: "failed";
+        opened: "opened";
+        queued: "queued";
+        scheduled: "scheduled";
+        sent: "sent";
+        suppressed: "suppressed";
+    }>>;
+}, z.core.$loose>;
+export declare function getEmailTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    email_id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+    message_id?: string | undefined;
+    to?: string[] | undefined;
+    from?: string | undefined;
+    created_at?: string | undefined;
+    subject?: string | undefined;
+    html?: string | null | undefined;
+    text?: string | null | undefined;
+    bcc?: string[] | null | undefined;
+    cc?: string[] | null | undefined;
+    reply_to?: string[] | null | undefined;
+    last_event?: "bounced" | "canceled" | "clicked" | "complained" | "delivered" | "delivery_delayed" | "failed" | "opened" | "queued" | "scheduled" | "sent" | "suppressed" | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_email", unknown>;
+//# sourceMappingURL=get-email.d.ts.map

package/dist/providers/resend/tools/get-email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-email.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-email.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,mBAAmB;;iBAAqC,CAAC;AAmCtE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAE3D,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;gIAkBhD"}

package/dist/providers/resend/tools/get-received-email-attachment.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getReceivedEmailAttachmentInputSchema: z.ZodObject<{
+    email_id: z.ZodString;
+    attachment_id: z.ZodString;
+}, z.core.$loose>;
+export declare const getReceivedEmailAttachmentOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    content_type: z.ZodOptional<z.ZodString>;
+    content_id: z.ZodOptional<z.ZodString>;
+    content_disposition: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodEnum<{
+        attachment: "attachment";
+        inline: "inline";
+    }>, z.ZodString]>>>;
+    download_url: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export declare function getReceivedEmailAttachmentTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    email_id: string;
+    attachment_id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+    filename?: string | null | undefined;
+    content_type?: string | undefined;
+    content_id?: string | undefined;
+    content_disposition?: string | null | undefined;
+    download_url?: string | undefined;
+    expires_at?: string | undefined;
+    size?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_received_email_attachment", unknown>;
+//# sourceMappingURL=get-received-email-attachment.d.ts.map

package/dist/providers/resend/tools/get-received-email-attachment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-received-email-attachment.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-received-email-attachment.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,qCAAqC;;;iBAElC,CAAC;AAgBjB,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;iBAAyB,CAAC;AAE7E,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;oJAkBlE"}

package/dist/providers/resend/tools/get-received-email.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getReceivedEmailInputSchema: z.ZodObject<{
+    email_id: z.ZodString;
+}, z.core.$loose>;
+export declare const getReceivedEmailOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    from: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    message_id: z.ZodOptional<z.ZodString>;
+    bcc: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    cc: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    reply_to: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    received_for: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    html: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    headers: z.ZodOptional<z.ZodNullable<z.ZodObject<{}, z.core.$loose>>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        content_type: z.ZodOptional<z.ZodString>;
+        content_id: z.ZodOptional<z.ZodString>;
+        content_disposition: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodEnum<{
+            attachment: "attachment";
+            inline: "inline";
+        }>, z.ZodString]>>>;
+        size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare function getReceivedEmailTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    email_id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+    to?: string[] | undefined;
+    from?: string | undefined;
+    subject?: string | undefined;
+    message_id?: string | undefined;
+    bcc?: string[] | null | undefined;
+    cc?: string[] | null | undefined;
+    reply_to?: string[] | null | undefined;
+    received_for?: string[] | undefined;
+    html?: string | null | undefined;
+    text?: string | null | undefined;
+    headers?: {
+        [x: string]: unknown;
+    } | null | undefined;
+    created_at?: string | undefined;
+    attachments?: {
+        [x: string]: unknown;
+        id?: string | undefined;
+        filename?: string | null | undefined;
+        content_type?: string | undefined;
+        content_id?: string | undefined;
+        content_disposition?: string | null | undefined;
+        size?: number | undefined;
+    }[] | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_received_email", unknown>;
+//# sourceMappingURL=get-received-email.d.ts.map

package/dist/providers/resend/tools/get-received-email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-received-email.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-received-email.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,2BAA2B;;iBAAmD,CAAC;AAmC5F,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yIAkBxD"}

package/dist/providers/resend/tools/get-segment.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getSegmentInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getSegmentOutputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    object: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    audience_id: z.ZodOptional<z.ZodString>;
+    filter: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function getSegmentTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+}, {
+    [x: string]: unknown;
+    id?: string | undefined;
+    object?: string | undefined;
+    name?: string | undefined;
+    audience_id?: string | undefined;
+    filter?: {
+        [x: string]: unknown;
+    } | undefined;
+    created_at?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_get_segment", unknown>;
+//# sourceMappingURL=get-segment.d.ts.map

package/dist/providers/resend/tools/get-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-segment.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/get-segment.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,qBAAqB;;iBAA6C,CAAC;AAahF,eAAO,MAAM,sBAAsB;;;;;;;iBAAyB,CAAC;AAE7D,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;kIAkBlD"}