@mastra/connect 0.2.0-alpha.2 → 0.3.0-alpha.0

package/dist/providers/slack/tools/set-channel-purpose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-channel-purpose.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/set-channel-purpose.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;iBAIxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;yIAiCzD"}

package/dist/providers/slack/tools/set-channel-topic.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const setChannelTopicInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    topic: z.ZodString;
+}, z.core.$strip>;
+export declare const setChannelTopicOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    channel: z.ZodRecord<z.ZodString, z.ZodAny>;
+    warning: z.ZodOptional<z.ZodString>;
+    response_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+export declare function setChannelTopicTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    topic: string;
+}, {
+    ok: boolean;
+    channel: Record<string, any>;
+    warning?: string | undefined;
+    response_metadata?: Record<string, any> | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_set_channel_topic", unknown>;
+//# sourceMappingURL=set-channel-topic.d.ts.map

package/dist/providers/slack/tools/set-channel-topic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-channel-topic.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/set-channel-topic.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAkBxE,eAAO,MAAM,0BAA0B;;;iBAOrC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;iBAKtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;uIAyBvD"}

package/dist/providers/slack/tools/set-status.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const setStatusInputSchema: z.ZodObject<{
+    status_text: z.ZodString;
+    status_emoji: z.ZodString;
+    status_expiration: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const setStatusOutputSchema: z.ZodObject<{
+    profile: z.ZodObject<{
+        title: z.ZodString;
+        phone: z.ZodString;
+        skype: z.ZodString;
+        real_name: z.ZodString;
+        real_name_normalized: z.ZodString;
+        display_name: z.ZodString;
+        display_name_normalized: z.ZodString;
+        status_text: z.ZodString;
+        status_emoji: z.ZodString;
+        status_emoji_display_info: z.ZodArray<z.ZodAny>;
+        status_expiration: z.ZodNumber;
+        avatar_hash: z.ZodString;
+        email: z.ZodString;
+        pronouns: z.ZodString;
+        huddle_state: z.ZodString;
+        huddle_state_expiration_ts: z.ZodNumber;
+        first_name: z.ZodString;
+        last_name: z.ZodString;
+        image_24: z.ZodString;
+        image_32: z.ZodString;
+        image_48: z.ZodString;
+        image_72: z.ZodString;
+        image_192: z.ZodString;
+        image_512: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare function setStatusTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    status_text: string;
+    status_emoji: string;
+    status_expiration?: number | undefined;
+}, {
+    profile: {
+        title: string;
+        phone: string;
+        skype: string;
+        real_name: string;
+        real_name_normalized: string;
+        display_name: string;
+        display_name_normalized: string;
+        status_text: string;
+        status_emoji: string;
+        status_emoji_display_info: any[];
+        status_expiration: number;
+        avatar_hash: string;
+        email: string;
+        pronouns: string;
+        huddle_state: string;
+        huddle_state_expiration_ts: number;
+        first_name: string;
+        last_name: string;
+        image_24: string;
+        image_32: string;
+        image_48: string;
+        image_72: string;
+        image_192: string;
+        image_512: string;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_set_status", unknown>;
+//# sourceMappingURL=set-status.d.ts.map

package/dist/providers/slack/tools/set-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-status.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/set-status.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,oBAAoB;;;;iBAc/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BhC,CAAC;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gIAiCjD"}

package/dist/providers/slack/tools/set-user-presence.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const setUserPresenceInputSchema: z.ZodObject<{
+    presence: z.ZodEnum<{
+        away: "away";
+        online: "online";
+    }>;
+}, z.core.$strip>;
+export declare const setUserPresenceOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function setUserPresenceTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    presence: "away" | "online";
+}, {
+    ok: boolean;
+    error?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_set_user_presence", unknown>;
+//# sourceMappingURL=set-user-presence.d.ts.map

package/dist/providers/slack/tools/set-user-presence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-user-presence.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/set-user-presence.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;;;;iBAIrC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;uIAkCvD"}

package/dist/providers/slack/tools/unarchive-channel.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const unarchiveChannelInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+}, z.core.$strip>;
+export declare const unarchiveChannelOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function unarchiveChannelTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+}, {
+    ok: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_unarchive_channel", unknown>;
+//# sourceMappingURL=unarchive-channel.d.ts.map

package/dist/providers/slack/tools/unarchive-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unarchive-channel.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/unarchive-channel.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,2BAA2B;;iBAEtC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;uIAgCxD"}

package/dist/providers/slack/tools/unpin-message.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const unpinMessageInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const unpinMessageOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function unpinMessageTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    timestamp: string;
+}, {
+    ok: boolean;
+    error?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_unpin_message", unknown>;
+//# sourceMappingURL=unpin-message.d.ts.map

package/dist/providers/slack/tools/unpin-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unpin-message.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/unpin-message.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAC;AAEH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa;;;;;;mIAwBpD"}

package/dist/providers/slack/tools/update-message.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateMessageInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    message_ts: z.ZodString;
+    text: z.ZodString;
+    as_user: z.ZodOptional<z.ZodBoolean>;
+    link_names: z.ZodOptional<z.ZodBoolean>;
+    parse: z.ZodOptional<z.ZodEnum<{
+        client: "client";
+        full: "full";
+        none: "none";
+    }>>;
+    unfurl_links: z.ZodOptional<z.ZodBoolean>;
+    unfurl_media: z.ZodOptional<z.ZodBoolean>;
+    reply_broadcast: z.ZodOptional<z.ZodBoolean>;
+    blocks: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
+}, z.core.$strip>;
+export declare const updateMessageOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    channel: z.ZodString;
+    ts: z.ZodString;
+    text: z.ZodString;
+    message: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export declare function updateMessageTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    message_ts: string;
+    text: string;
+    as_user?: boolean | undefined;
+    link_names?: boolean | undefined;
+    parse?: "client" | "full" | "none" | undefined;
+    unfurl_links?: boolean | undefined;
+    unfurl_media?: boolean | undefined;
+    reply_broadcast?: boolean | undefined;
+    blocks?: {
+        [x: string]: unknown;
+    }[] | undefined;
+    attachments?: {
+        [x: string]: unknown;
+    }[] | undefined;
+}, {
+    ok: boolean;
+    channel: string;
+    ts: string;
+    text: string;
+    message?: any;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_update_message", unknown>;
+//# sourceMappingURL=update-message.d.ts.map

package/dist/providers/slack/tools/update-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-message.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/update-message.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;iBAsCnC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;iBAMpC,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;oIA6CrD"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/providers/slack/tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAsD7D,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,oBAAoB,2CAwD9D"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/stripe/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/stripe/tools/cancel-payment-intent.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const cancelPaymentIntentInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    cancellation_reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const cancelPaymentIntentOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    status: z.ZodString;
+    cancellation_reason: z.ZodOptional<z.ZodString>;
+    client_secret: z.ZodOptional<z.ZodString>;
+    created: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare function cancelPaymentIntentTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    id: string;
+    cancellation_reason?: string | undefined;
+}, {
+    id: string;
+    amount: number;
+    currency: string;
+    status: string;
+    cancellation_reason?: string | undefined;
+    client_secret?: string | undefined;
+    created: number;
+    description?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "stripe_cancel_payment_intent", unknown>;
+//# sourceMappingURL=cancel-payment-intent.d.ts.map

package/dist/providers/stripe/tools/cancel-payment-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancel-payment-intent.d.ts","sourceRoot":"","sources":["../../../../src/providers/stripe/tools/cancel-payment-intent.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,8BAA8B;;;iBAMzC,CAAC;AAgBH,eAAO,MAAM,+BAA+B;;;;;;;;;;iBAU1C,CAAC;AAEH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;4IAgC3D"}

package/dist/providers/stripe/tools/capture-payment-intent.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const capturePaymentIntentInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    amount_to_capture: z.ZodOptional<z.ZodNumber>;
+    application_fee_amount: z.ZodOptional<z.ZodNumber>;
+    final_capture: z.ZodOptional<z.ZodBoolean>;
+    statement_descriptor: z.ZodOptional<z.ZodString>;
+    statement_descriptor_suffix: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const capturePaymentIntentOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    amount: z.ZodNumber;
+    amount_capturable: z.ZodOptional<z.ZodNumber>;
+    amount_received: z.ZodOptional<z.ZodNumber>;
+    application_fee_amount: z.ZodOptional<z.ZodNumber>;
+    canceled_at: z.ZodOptional<z.ZodNumber>;
+    cancellation_reason: z.ZodOptional<z.ZodString>;
+    capture_method: z.ZodOptional<z.ZodString>;
+    client_secret: z.ZodOptional<z.ZodString>;
+    confirmation_method: z.ZodOptional<z.ZodString>;
+    created: z.ZodNumber;
+    currency: z.ZodString;
+    customer: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    latest_charge: z.ZodOptional<z.ZodString>;
+    livemode: z.ZodBoolean;
+    metadata: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    next_action: z.ZodOptional<z.ZodUnknown>;
+    payment_method: z.ZodOptional<z.ZodString>;
+    payment_method_options: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    payment_method_types: z.ZodArray<z.ZodString>;
+    receipt_email: z.ZodOptional<z.ZodString>;
+    setup_future_usage: z.ZodOptional<z.ZodString>;
+    shipping: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    statement_descriptor: z.ZodOptional<z.ZodString>;
+    statement_descriptor_suffix: z.ZodOptional<z.ZodString>;
+    status: z.ZodString;
+    transfer_data: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    transfer_group: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function capturePaymentIntentTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    id: string;
+    amount_to_capture?: number | undefined;
+    application_fee_amount?: number | undefined;
+    final_capture?: boolean | undefined;
+    statement_descriptor?: string | undefined;
+    statement_descriptor_suffix?: string | undefined;
+}, {
+    id: string;
+    amount: number;
+    amount_capturable?: number | undefined;
+    amount_received?: number | undefined;
+    application_fee_amount?: number | undefined;
+    canceled_at?: number | undefined;
+    cancellation_reason?: string | undefined;
+    capture_method?: string | undefined;
+    client_secret?: string | undefined;
+    confirmation_method?: string | undefined;
+    created: number;
+    currency: string;
+    customer?: string | undefined;
+    description?: string | undefined;
+    latest_charge?: string | undefined;
+    livemode: boolean;
+    metadata?: {
+        [x: string]: unknown;
+    } | undefined;
+    next_action?: unknown;
+    payment_method?: string | undefined;
+    payment_method_options?: {
+        [x: string]: unknown;
+    } | undefined;
+    payment_method_types: string[];
+    receipt_email?: string | undefined;
+    setup_future_usage?: string | undefined;
+    shipping?: {
+        [x: string]: unknown;
+    } | undefined;
+    statement_descriptor?: string | undefined;
+    statement_descriptor_suffix?: string | undefined;
+    status: string;
+    transfer_data?: {
+        [x: string]: unknown;
+    } | undefined;
+    transfer_group?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "stripe_capture_payment_intent", unknown>;
+//# sourceMappingURL=capture-payment-intent.d.ts.map

package/dist/providers/stripe/tools/capture-payment-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-payment-intent.d.ts","sourceRoot":"","sources":["../../../../src/providers/stripe/tools/capture-payment-intent.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,+BAA+B;;;;;;;iBAkB1C,CAAC;AAkCH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8B3C,CAAC;AAEH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6IAyF5D"}

package/dist/providers/stripe/tools/create-checkout-session.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createCheckoutSessionInputSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        payment: "payment";
+        setup: "setup";
+        subscription: "subscription";
+    }>;
+    success_url: z.ZodOptional<z.ZodString>;
+    cancel_url: z.ZodOptional<z.ZodString>;
+    customer: z.ZodOptional<z.ZodString>;
+    customer_email: z.ZodOptional<z.ZodString>;
+    currency: z.ZodOptional<z.ZodString>;
+    line_items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        price: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const createCheckoutSessionOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    mode: z.ZodString;
+    created: z.ZodNumber;
+    amount_subtotal: z.ZodOptional<z.ZodNumber>;
+    amount_total: z.ZodOptional<z.ZodNumber>;
+    currency: z.ZodOptional<z.ZodString>;
+    customer: z.ZodOptional<z.ZodString>;
+    customer_email: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    cancel_url: z.ZodOptional<z.ZodString>;
+    success_url: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodNumber>;
+    payment_intent: z.ZodOptional<z.ZodString>;
+    subscription: z.ZodOptional<z.ZodString>;
+    client_secret: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare function createCheckoutSessionTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    mode: "payment" | "setup" | "subscription";
+    success_url?: string | undefined;
+    cancel_url?: string | undefined;
+    customer?: string | undefined;
+    customer_email?: string | undefined;
+    currency?: string | undefined;
+    line_items?: {
+        price: string;
+        quantity: number;
+    }[] | undefined;
+    metadata?: Record<string, string> | undefined;
+}, {
+    id: string;
+    mode: string;
+    created: number;
+    amount_subtotal?: number | undefined;
+    amount_total?: number | undefined;
+    currency?: string | undefined;
+    customer?: string | undefined;
+    customer_email?: string | undefined;
+    status?: string | undefined;
+    url?: string | undefined;
+    cancel_url?: string | undefined;
+    success_url?: string | undefined;
+    expires_at?: number | undefined;
+    payment_intent?: string | undefined;
+    subscription?: string | undefined;
+    client_secret?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "stripe_create_checkout_session", unknown>;
+//# sourceMappingURL=create-checkout-session.d.ts.map

package/dist/providers/stripe/tools/create-checkout-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-checkout-session.d.ts","sourceRoot":"","sources":["../../../../src/providers/stripe/tools/create-checkout-session.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAOxE,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;iBAkB3C,CAAC;AAuBH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;iBAkB5C,CAAC;AAEH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8IA+E7D"}

package/dist/providers/stripe/tools/create-credit-note.d.ts

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createCreditNoteInputSchema: z.ZodObject<{
+    invoice: z.ZodString;
+    amount: z.ZodOptional<z.ZodNumber>;
+    lines: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            custom_line_item: "custom_line_item";
+            invoice_line_item: "invoice_line_item";
+        }>;
+        amount: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+        invoice_line_item: z.ZodOptional<z.ZodString>;
+        quantity: z.ZodOptional<z.ZodNumber>;
+        unit_amount: z.ZodOptional<z.ZodNumber>;
+        unit_amount_decimal: z.ZodOptional<z.ZodString>;
+        tax_rates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    reason: z.ZodOptional<z.ZodEnum<{
+        duplicate: "duplicate";
+        fraudulent: "fraudulent";
+        order_change: "order_change";
+        product_unsatisfactory: "product_unsatisfactory";
+    }>>;
+    memo: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    credit_amount: z.ZodOptional<z.ZodNumber>;
+    out_of_band_amount: z.ZodOptional<z.ZodNumber>;
+    refund_amount: z.ZodOptional<z.ZodNumber>;
+    effective_at: z.ZodOptional<z.ZodNumber>;
+    email_type: z.ZodOptional<z.ZodEnum<{
+        credit_note: "credit_note";
+        none: "none";
+    }>>;
+}, z.core.$strip>;
+export declare const createCreditNoteOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodString;
+    amount: z.ZodNumber;
+    amount_shipping: z.ZodOptional<z.ZodNumber>;
+    created: z.ZodOptional<z.ZodNumber>;
+    currency: z.ZodOptional<z.ZodString>;
+    customer: z.ZodOptional<z.ZodString>;
+    customer_balance_transaction: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    discount_amount: z.ZodOptional<z.ZodNumber>;
+    discount_amounts: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    invoice: z.ZodOptional<z.ZodString>;
+    lines: z.ZodOptional<z.ZodObject<{
+        object: z.ZodString;
+        data: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            object: z.ZodString;
+            amount: z.ZodNumber;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            discount_amount: z.ZodOptional<z.ZodNumber>;
+            discount_amounts: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+            invoice_line_item: z.ZodOptional<z.ZodString>;
+            livemode: z.ZodOptional<z.ZodBoolean>;
+            quantity: z.ZodOptional<z.ZodNumber>;
+            tax_rates: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+            taxes: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+            type: z.ZodString;
+            unit_amount: z.ZodOptional<z.ZodNumber>;
+            unit_amount_decimal: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        has_more: z.ZodBoolean;
+        url: z.ZodString;
+    }, z.core.$strip>>;
+    livemode: z.ZodOptional<z.ZodBoolean>;
+    memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    number: z.ZodOptional<z.ZodString>;
+    out_of_band_amount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    pdf: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pre_payment_amount: z.ZodOptional<z.ZodNumber>;
+    post_payment_amount: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    refunds: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    shipping_cost: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    status: z.ZodOptional<z.ZodString>;
+    subtotal: z.ZodOptional<z.ZodNumber>;
+    subtotal_excluding_tax: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodOptional<z.ZodNumber>;
+    total_excluding_tax: z.ZodOptional<z.ZodNumber>;
+    total_taxes: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    type: z.ZodOptional<z.ZodString>;
+    voided_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare function createCreditNoteTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    invoice: string;
+    amount?: number | undefined;
+    lines?: {
+        type: "custom_line_item" | "invoice_line_item";
+        amount?: number | undefined;
+        description?: string | undefined;
+        invoice_line_item?: string | undefined;
+        quantity?: number | undefined;
+        unit_amount?: number | undefined;
+        unit_amount_decimal?: string | undefined;
+        tax_rates?: string[] | undefined;
+    }[] | undefined;
+    reason?: "duplicate" | "fraudulent" | "order_change" | "product_unsatisfactory" | undefined;
+    memo?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    credit_amount?: number | undefined;
+    out_of_band_amount?: number | undefined;
+    refund_amount?: number | undefined;
+    effective_at?: number | undefined;
+    email_type?: "credit_note" | "none" | undefined;
+}, {
+    id: string;
+    object: string;
+    amount: number;
+    amount_shipping?: number | undefined;
+    created?: number | undefined;
+    currency?: string | undefined;
+    customer?: string | undefined;
+    customer_balance_transaction?: string | null | undefined;
+    discount_amount?: number | undefined;
+    discount_amounts?: unknown[] | undefined;
+    invoice?: string | undefined;
+    lines?: {
+        object: string;
+        data: {
+            id: string;
+            object: string;
+            amount: number;
+            description?: string | null | undefined;
+            discount_amount?: number | undefined;
+            discount_amounts?: unknown[] | undefined;
+            invoice_line_item?: string | undefined;
+            livemode?: boolean | undefined;
+            quantity?: number | undefined;
+            tax_rates?: unknown[] | undefined;
+            taxes?: unknown[] | undefined;
+            type: string;
+            unit_amount?: number | undefined;
+            unit_amount_decimal?: string | undefined;
+        }[];
+        has_more: boolean;
+        url: string;
+    } | undefined;
+    livemode?: boolean | undefined;
+    memo?: string | null | undefined;
+    metadata?: Record<string, string> | null | undefined;
+    number?: string | undefined;
+    out_of_band_amount?: number | null | undefined;
+    pdf?: string | null | undefined;
+    pre_payment_amount?: number | undefined;
+    post_payment_amount?: number | undefined;
+    reason?: string | null | undefined;
+    refunds?: unknown[] | undefined;
+    shipping_cost?: unknown;
+    status?: string | undefined;
+    subtotal?: number | undefined;
+    subtotal_excluding_tax?: number | undefined;
+    total?: number | undefined;
+    total_excluding_tax?: number | undefined;
+    total_taxes?: unknown[] | undefined;
+    type?: string | undefined;
+    voided_at?: number | null | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "stripe_create_credit_note", unknown>;
+//# sourceMappingURL=create-credit-note.d.ts.map

package/dist/providers/stripe/tools/create-credit-note.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-credit-note.d.ts","sourceRoot":"","sources":["../../../../src/providers/stripe/tools/create-credit-note.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BtC,CAAC;AA4DH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2B,CAAC;AA6BrE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yIAuFxD"}