@mastra/connect 0.1.0-alpha.0 → 0.2.0-alpha.1

package/dist/providers/openai/tools/search-vector-store.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const searchVectorStoreInputSchema: z.ZodObject<{
+    vector_store_id: z.ZodString;
+    query: z.ZodString;
+    max_num_results: z.ZodOptional<z.ZodNumber>;
+    filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    ranking_options: z.ZodOptional<z.ZodObject<{
+        ranker: z.ZodOptional<z.ZodString>;
+        score_threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    rewrite_query: z.ZodOptional<z.ZodBoolean>;
+    next_page: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const searchVectorStoreOutputSchema: z.ZodObject<{
+    object: z.ZodString;
+    search_query: z.ZodArray<z.ZodString>;
+    data: z.ZodArray<z.ZodObject<{
+        file_id: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        score: z.ZodNumber;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    has_more: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare function searchVectorStoreTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    vector_store_id: string;
+    query: string;
+    max_num_results?: number | undefined;
+    filters?: Record<string, unknown> | undefined;
+    ranking_options?: {
+        ranker?: string | undefined;
+        score_threshold?: number | undefined;
+    } | undefined;
+    rewrite_query?: boolean | undefined;
+    next_page?: string | undefined;
+}, {
+    object: string;
+    search_query: string[];
+    data: {
+        file_id: string;
+        filename?: string | undefined;
+        score: number;
+        attributes?: Record<string, unknown> | undefined;
+        content?: {
+            type?: string | undefined;
+            text?: string | undefined;
+        }[] | undefined;
+    }[];
+    has_more: boolean;
+    next_page?: string | null | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_search_vector_store", unknown>;
+//# sourceMappingURL=search-vector-store.d.ts.map

package/dist/providers/openai/tools/search-vector-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-vector-store.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/search-vector-store.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;;;;;;;;;;iBAavC,CAAC;AAeH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;iBAMxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;0IA8CzD"}

package/dist/providers/openai/tools/update-vector-store.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateVectorStoreInputSchema: z.ZodObject<{
+    vector_store_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    expires_after: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        anchor: z.ZodLiteral<"last_active_at">;
+        days: z.ZodNumber;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const updateVectorStoreOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodString;
+    created_at: z.ZodNumber;
+    name: z.ZodString;
+    bytes: z.ZodOptional<z.ZodNumber>;
+    file_counts: z.ZodObject<{
+        total: z.ZodNumber;
+        in_progress: z.ZodNumber;
+        completed: z.ZodNumber;
+        failed: z.ZodNumber;
+        cancelled: z.ZodNumber;
+    }, z.core.$strip>;
+    expires_after: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        anchor: z.ZodLiteral<"last_active_at">;
+        days: z.ZodNumber;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare function updateVectorStoreTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    vector_store_id: string;
+    name?: string | undefined;
+    expires_after?: {
+        anchor: "last_active_at";
+        days: number;
+    } | null | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    id: string;
+    object: string;
+    created_at: number;
+    name: string;
+    bytes?: number | undefined;
+    file_counts: {
+        total: number;
+        in_progress: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+    };
+    expires_after?: {
+        anchor: "last_active_at";
+        days: number;
+    } | null | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_update_vector_store", unknown>;
+//# sourceMappingURL=update-vector-store.d.ts.map

package/dist/providers/openai/tools/update-vector-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-vector-store.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/update-vector-store.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAOxE,eAAO,MAAM,4BAA4B;;;;;;;;iBAKvC,CAAC;AAqBH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;iBASxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;0IAuDzD"}

package/dist/providers/openai/tools.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderToolsOptions } from '../../toolset.js';
+export declare function createOpenaiTools(options?: ProviderToolsOptions): import("@mastra/core/agent").ToolsInput;
+//# sourceMappingURL=tools.d.ts.map

package/dist/providers/openai/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/providers/openai/tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AA6B7D,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,oBAAoB,2CA+B/D"}

package/dist/providers/resend/index.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderRegistration } from '../../registry.js';
+import { createResendTools } from './tools.js';
+export declare const resendProvider: ProviderRegistration;
+export { createResendTools };
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/resend/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/resend/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,eAAO,MAAM,cAAc,EAAE,oBAI5B,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/providers/resend/tools/add-contact-to-segment.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const addContactToSegmentInputSchema: z.ZodObject<{
+    contact_id: z.ZodString;
+    segment_id: z.ZodString;
+}, z.core.$loose>;
+export declare const addContactToSegmentOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    contact_id: z.ZodOptional<z.ZodString>;
+    segment_id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function addContactToSegmentTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    contact_id: string;
+    segment_id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    contact_id?: string | undefined;
+    segment_id?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_add_contact_to_segment", unknown>;
+//# sourceMappingURL=add-contact-to-segment.d.ts.map

package/dist/providers/resend/tools/add-contact-to-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-contact-to-segment.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/add-contact-to-segment.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,8BAA8B;;;iBAE3B,CAAC;AAMjB,eAAO,MAAM,+BAA+B;;;;iBAAyB,CAAC;AAEtE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;6IAkB3D"}

package/dist/providers/resend/tools/cancel-broadcast.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const cancelBroadcastInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const cancelBroadcastOutputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    object: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function cancelBroadcastTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+}, {
+    [x: string]: unknown;
+    id?: string | undefined;
+    object?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_cancel_broadcast", unknown>;
+//# sourceMappingURL=cancel-broadcast.d.ts.map

package/dist/providers/resend/tools/cancel-broadcast.d.ts.map

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

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const cancelEmailInputSchema: z.ZodObject<{
+    email_id: z.ZodString;
+}, z.core.$strip>;
+export declare const cancelEmailOutputSchema: 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 cancelEmailTool(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_cancel_email", unknown>;
+//# sourceMappingURL=cancel-email.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cancel-email.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/cancel-email.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,sBAAsB;;iBAAqC,CAAC;AAmCzE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAE9D,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;mIAkBnD"}

package/dist/providers/resend/tools/create-audience.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createAudienceInputSchema: z.ZodObject<{
+    body: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const createAudienceOutputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    object: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function createAudienceTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    body: {
+        [x: string]: unknown;
+        name: string;
+    };
+}, {
+    [x: string]: unknown;
+    id?: string | undefined;
+    object?: string | undefined;
+    name?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_create_audience", unknown>;
+//# sourceMappingURL=create-audience.d.ts.map

package/dist/providers/resend/tools/create-audience.d.ts.map

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

package/dist/providers/resend/tools/create-broadcast.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createBroadcastInputSchema: z.ZodObject<{
+    body: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        segment_id: z.ZodString;
+        audience_id: z.ZodOptional<z.ZodString>;
+        from: z.ZodString;
+        subject: z.ZodString;
+        reply_to: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        preview_text: z.ZodOptional<z.ZodString>;
+        html: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        topic_id: z.ZodOptional<z.ZodString>;
+        send: z.ZodOptional<z.ZodBoolean>;
+        scheduled_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const createBroadcastOutputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    object: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function createBroadcastTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    body: {
+        [x: string]: unknown;
+        name?: string | undefined;
+        segment_id: string;
+        audience_id?: string | undefined;
+        from: string;
+        subject: string;
+        reply_to?: string[] | undefined;
+        preview_text?: string | undefined;
+        html?: string | undefined;
+        text?: string | undefined;
+        topic_id?: string | undefined;
+        send?: boolean | undefined;
+        scheduled_at?: string | undefined;
+    };
+}, {
+    [x: string]: unknown;
+    id?: string | undefined;
+    object?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_create_broadcast", unknown>;
+//# sourceMappingURL=create-broadcast.d.ts.map

package/dist/providers/resend/tools/create-broadcast.d.ts.map

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

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

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createContactImportInputSchema: z.ZodObject<{
+    body: z.ZodObject<{
+        file: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        column_map: z.ZodOptional<z.ZodObject<{
+            email: z.ZodOptional<z.ZodString>;
+            first_name: z.ZodOptional<z.ZodString>;
+            last_name: z.ZodOptional<z.ZodString>;
+            unsubscribed: z.ZodOptional<z.ZodString>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                column: z.ZodString;
+                type: z.ZodEnum<{
+                    boolean: "boolean";
+                    number: "number";
+                    string: "string";
+                }>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>;
+        on_conflict: z.ZodOptional<z.ZodEnum<{
+            skip: "skip";
+            upsert: "upsert";
+        }>>;
+        segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$loose>>>;
+        topics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            subscription: z.ZodEnum<{
+                opt_in: "opt_in";
+                opt_out: "opt_out";
+            }>;
+        }, z.core.$loose>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const createContactImportOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function createContactImportTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    body: {
+        file: string;
+        filename?: string | undefined;
+        column_map?: {
+            [x: string]: unknown;
+            email?: string | undefined;
+            first_name?: string | undefined;
+            last_name?: string | undefined;
+            unsubscribed?: string | undefined;
+            properties?: Record<string, {
+                [x: string]: unknown;
+                column: string;
+                type: "boolean" | "number" | "string";
+            }> | undefined;
+        } | undefined;
+        on_conflict?: "skip" | "upsert" | undefined;
+        segments?: {
+            [x: string]: unknown;
+            id: string;
+        }[] | undefined;
+        topics?: {
+            [x: string]: unknown;
+            id: string;
+            subscription: "opt_in" | "opt_out";
+        }[] | undefined;
+    };
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_create_contact_import", unknown>;
+//# sourceMappingURL=create-contact-import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-contact-import.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/create-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,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CzC,CAAC;AAIH,eAAO,MAAM,+BAA+B;;;iBAAyB,CAAC;AAMtE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4IAoC3D"}

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createContactPropertyInputSchema: z.ZodObject<{
+    body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        key: z.ZodString;
+        type: z.ZodLiteral<"string">;
+        fallback_value: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        key: z.ZodString;
+        type: z.ZodLiteral<"number">;
+        fallback_value: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>], "type">;
+}, z.core.$loose>;
+export declare const createContactPropertyOutputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    object: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function createContactPropertyTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    body: {
+        [x: string]: unknown;
+        key: string;
+        type: "string";
+        fallback_value?: string | undefined;
+    } | {
+        [x: string]: unknown;
+        key: string;
+        type: "number";
+        fallback_value?: number | undefined;
+    };
+}, {
+    [x: string]: unknown;
+    id?: string | undefined;
+    object?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_create_contact_property", unknown>;
+//# sourceMappingURL=create-contact-property.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-contact-property.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/create-contact-property.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAQ9F,eAAO,MAAM,gCAAgC;;;;;;;;;;iBAO7B,CAAC;AAIjB,eAAO,MAAM,iCAAiC;;;iBAAyB,CAAC;AAExE,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;8IAmB7D"}

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

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createContactInputSchema: z.ZodObject<{
+    body: z.ZodObject<{
+        email: z.ZodString;
+        first_name: z.ZodOptional<z.ZodString>;
+        last_name: z.ZodOptional<z.ZodString>;
+        unsubscribed: z.ZodOptional<z.ZodBoolean>;
+        properties: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        topics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            subscription: z.ZodOptional<z.ZodEnum<{
+                opt_in: "opt_in";
+                opt_out: "opt_out";
+            }>>;
+        }, z.core.$loose>>>;
+        audience_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const createContactOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function createContactTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    body: {
+        [x: string]: unknown;
+        email: string;
+        first_name?: string | undefined;
+        last_name?: string | undefined;
+        unsubscribed?: boolean | undefined;
+        properties?: {
+            [x: string]: unknown;
+        } | undefined;
+        segments?: {
+            [x: string]: unknown;
+            id?: string | undefined;
+        }[] | undefined;
+        topics?: {
+            [x: string]: unknown;
+            id?: string | undefined;
+            subscription?: "opt_in" | "opt_out" | undefined;
+        }[] | undefined;
+        audience_id?: string | undefined;
+    };
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_create_contact", unknown>;
+//# sourceMappingURL=create-contact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-contact.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/create-contact.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;iBAqBrB,CAAC;AAIjB,eAAO,MAAM,yBAAyB;;;iBAAyB,CAAC;AAEhE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;qIAmBrD"}

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

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createDomainClaimInputSchema: z.ZodObject<{
+    body: z.ZodObject<{
+        name: z.ZodString;
+        region: z.ZodOptional<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";
+        }>>;
+        custom_return_path: z.ZodOptional<z.ZodString>;
+        open_tracking: z.ZodOptional<z.ZodBoolean>;
+        click_tracking: z.ZodOptional<z.ZodBoolean>;
+        tracking_subdomain: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const createDomainClaimOutputSchema: 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 createDomainClaimTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    body: {
+        [x: string]: unknown;
+        name: string;
+        region?: "ap-northeast-1" | "eu-west-1" | "sa-east-1" | "us-east-1" | undefined;
+        custom_return_path?: string | undefined;
+        open_tracking?: boolean | undefined;
+        click_tracking?: boolean | undefined;
+        tracking_subdomain?: string | undefined;
+    };
+}, {
+    [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_create_domain_claim", unknown>;
+//# sourceMappingURL=create-domain-claim.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-domain-claim.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/create-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,4BAA4B;;;;;;;;;;;;;;iBAazB,CAAC;AAiCjB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAEpE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0IAmBzD"}