@mastra/connect 0.1.0 → 0.2.0-alpha.2

package/dist/providers/resend/tools/update-topic.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateTopicInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    body: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const updateTopicOutputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    object: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function updateTopicTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+    body: {
+        [x: string]: unknown;
+        name?: string | undefined;
+        description?: string | undefined;
+        visibility?: "private" | "public" | undefined;
+    };
+}, {
+    [x: string]: unknown;
+    id?: string | undefined;
+    object?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_update_topic", unknown>;
+//# sourceMappingURL=update-topic.d.ts.map

package/dist/providers/resend/tools/update-topic.d.ts.map

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

package/dist/providers/resend/tools/update-webhook.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateWebhookInputSchema: z.ZodObject<{
+    webhook_id: z.ZodString;
+    body: z.ZodObject<{
+        endpoint: z.ZodOptional<z.ZodString>;
+        events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        status: z.ZodOptional<z.ZodEnum<{
+            disabled: "disabled";
+            enabled: "enabled";
+        }>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const updateWebhookOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function updateWebhookTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    webhook_id: string;
+    body: {
+        [x: string]: unknown;
+        endpoint?: string | undefined;
+        events?: string[] | undefined;
+        status?: "disabled" | "enabled" | undefined;
+    };
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_update_webhook", unknown>;
+//# sourceMappingURL=update-webhook.d.ts.map

package/dist/providers/resend/tools/update-webhook.d.ts.map

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

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const verifyDomainClaimInputSchema: z.ZodObject<{
+    domain_id: z.ZodString;
+}, z.core.$loose>;
+export declare const verifyDomainClaimOutputSchema: 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 verifyDomainClaimTool(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_verify_domain_claim", unknown>;
+//# sourceMappingURL=verify-domain-claim.d.ts.map

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

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

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const verifyDomainInputSchema: z.ZodObject<{
+    domain_id: z.ZodString;
+}, z.core.$strip>;
+export declare const verifyDomainOutputSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function verifyDomainTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    domain_id: string;
+}, {
+    [x: string]: unknown;
+    object?: string | undefined;
+    id?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "resend_verify_domain", unknown>;
+//# sourceMappingURL=verify-domain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verify-domain.d.ts","sourceRoot":"","sources":["../../../../src/providers/resend/tools/verify-domain.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,uBAAuB;;iBAAsC,CAAC;AAI3E,eAAO,MAAM,wBAAwB;;;iBAAyB,CAAC;AAE/D,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa;;;;;;oIAkBpD"}

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

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

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

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

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

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

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

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

package/dist/providers/snowflake/tools/cancel-statement.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const cancelStatementInputSchema: z.ZodObject<{
+    statement_handle: z.ZodString;
+}, z.core.$strip>;
+export declare const cancelStatementOutputSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare function cancelStatementTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    statement_handle: string;
+}, {
+    code: string;
+    message: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_cancel_statement", unknown>;
+//# sourceMappingURL=cancel-statement.d.ts.map

package/dist/providers/snowflake/tools/cancel-statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancel-statement.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/cancel-statement.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,0BAA0B;;iBAMrC,CAAC;AAOH,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;0IA4BvD"}

package/dist/providers/snowflake/tools/execute-statement.d.ts

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const executeStatementInputSchema: z.ZodObject<{
+    statement: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    warehouse: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    bindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const executeStatementOutputSchema: z.ZodObject<{
+    code: z.ZodString;
+    sqlState: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    statementHandle: z.ZodString;
+    statementHandles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    statementStatusUrl: z.ZodString;
+    createdOn: z.ZodOptional<z.ZodNumber>;
+    resultSetMetaData: z.ZodOptional<z.ZodObject<{
+        numRows: z.ZodOptional<z.ZodNumber>;
+        format: z.ZodOptional<z.ZodString>;
+        rowType: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            database: z.ZodOptional<z.ZodString>;
+            schema: z.ZodOptional<z.ZodString>;
+            table: z.ZodOptional<z.ZodString>;
+            type: z.ZodString;
+            scale: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            precision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            length: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            nullable: z.ZodBoolean;
+            byteLength: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            collation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        partitionInfo: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            rowCount: z.ZodNumber;
+            uncompressedSize: z.ZodNumber;
+            compressedSize: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    data: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodUnknown>>>;
+    stats: z.ZodOptional<z.ZodObject<{
+        numRowsInserted: z.ZodOptional<z.ZodNumber>;
+        numRowsUpdated: z.ZodOptional<z.ZodNumber>;
+        numRowsDeleted: z.ZodOptional<z.ZodNumber>;
+        numDuplicateRowsUpdated: z.ZodOptional<z.ZodNumber>;
+        numRowsUnloaded: z.ZodOptional<z.ZodNumber>;
+        numBytesUnloaded: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function executeStatementTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    statement: string;
+    timeout?: number | undefined;
+    warehouse?: string | undefined;
+    database?: string | undefined;
+    schema?: string | undefined;
+    role?: string | undefined;
+    bindings?: Record<string, {
+        type: string;
+        value: string;
+    }> | undefined;
+}, {
+    code: string;
+    sqlState?: string | undefined;
+    message: string;
+    statementHandle: string;
+    statementHandles?: string[] | undefined;
+    statementStatusUrl: string;
+    createdOn?: number | undefined;
+    resultSetMetaData?: {
+        numRows?: number | undefined;
+        format?: string | undefined;
+        rowType?: {
+            name: string;
+            database?: string | undefined;
+            schema?: string | undefined;
+            table?: string | undefined;
+            type: string;
+            scale?: number | null | undefined;
+            precision?: number | null | undefined;
+            length?: number | null | undefined;
+            nullable: boolean;
+            byteLength?: number | null | undefined;
+            collation?: string | null | undefined;
+        }[] | undefined;
+        partitionInfo?: {
+            rowCount: number;
+            uncompressedSize: number;
+            compressedSize?: number | undefined;
+        }[] | undefined;
+    } | undefined;
+    data?: unknown[][] | undefined;
+    stats?: {
+        numRowsInserted?: number | undefined;
+        numRowsUpdated?: number | undefined;
+        numRowsDeleted?: number | undefined;
+        numDuplicateRowsUpdated?: number | undefined;
+        numRowsUnloaded?: number | undefined;
+        numBytesUnloaded?: number | undefined;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_execute_statement", unknown>;
+//# sourceMappingURL=execute-statement.d.ts.map

package/dist/providers/snowflake/tools/execute-statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-statement.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/execute-statement.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAOxE,eAAO,MAAM,2BAA2B;;;;;;;;;;;iBAQtC,CAAC;AAsCH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWvC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2IAmCxD"}

package/dist/providers/snowflake/tools/get-statement-result.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getStatementResultInputSchema: z.ZodObject<{
+    statement_handle: z.ZodString;
+    partition: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const getStatementResultOutputSchema: z.ZodObject<{
+    statement_handle: z.ZodString;
+    statement_state: z.ZodOptional<z.ZodString>;
+    num_rows: z.ZodOptional<z.ZodNumber>;
+    columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        precision: z.ZodOptional<z.ZodNumber>;
+        scale: z.ZodOptional<z.ZodNumber>;
+        byte_length: z.ZodOptional<z.ZodNumber>;
+        length: z.ZodOptional<z.ZodNumber>;
+        nullable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    rows: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodUnknown>>>;
+    next_partition_num: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function getStatementResultTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    statement_handle: string;
+    partition?: number | undefined;
+}, {
+    statement_handle: string;
+    statement_state?: string | undefined;
+    num_rows?: number | undefined;
+    columns?: {
+        name: string;
+        type: string;
+        precision?: number | undefined;
+        scale?: number | undefined;
+        byte_length?: number | undefined;
+        length?: number | undefined;
+        nullable?: boolean | undefined;
+    }[] | undefined;
+    rows?: unknown[][] | undefined;
+    next_partition_num?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_get_statement_result", unknown>;
+//# sourceMappingURL=get-statement-result.d.ts.map

package/dist/providers/snowflake/tools/get-statement-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-statement-result.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/get-statement-result.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,6BAA6B;;;iBAOxC,CAAC;AAuCH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;iBAOzC,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;8IAuD1D"}

package/dist/providers/snowflake/tools/get-statement-status.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getStatementStatusInputSchema: z.ZodObject<{
+    statementHandle: z.ZodString;
+}, z.core.$strip>;
+export declare const getStatementStatusOutputSchema: z.ZodObject<{
+    statementHandle: z.ZodString;
+    sqlState: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
+    createdOn: z.ZodOptional<z.ZodNumber>;
+    statementStatusUrl: z.ZodOptional<z.ZodString>;
+    resultSetMetaData: z.ZodOptional<z.ZodObject<{
+        numRows: z.ZodOptional<z.ZodNumber>;
+        format: z.ZodOptional<z.ZodString>;
+        rowType: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            database: z.ZodOptional<z.ZodString>;
+            schema: z.ZodOptional<z.ZodString>;
+            table: z.ZodOptional<z.ZodString>;
+            scale: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            precision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            length: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            byteLength: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            nullable: z.ZodOptional<z.ZodBoolean>;
+            collation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        partitionInfo: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            rowCount: z.ZodNumber;
+            uncompressedSize: z.ZodNumber;
+            compressedSize: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    data: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare function getStatementStatusTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    statementHandle: string;
+}, {
+    statementHandle: string;
+    sqlState?: string | undefined;
+    message?: string | undefined;
+    code?: string | undefined;
+    createdOn?: number | undefined;
+    statementStatusUrl?: string | undefined;
+    resultSetMetaData?: {
+        numRows?: number | undefined;
+        format?: string | undefined;
+        rowType?: {
+            name: string;
+            type: string;
+            database?: string | undefined;
+            schema?: string | undefined;
+            table?: string | undefined;
+            scale?: number | null | undefined;
+            precision?: number | null | undefined;
+            length?: number | null | undefined;
+            byteLength?: number | null | undefined;
+            nullable?: boolean | undefined;
+            collation?: string | null | undefined;
+        }[] | undefined;
+        partitionInfo?: {
+            rowCount: number;
+            uncompressedSize: number;
+            compressedSize?: number | undefined;
+        }[] | undefined;
+    } | undefined;
+    data?: unknown[][] | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_get_statement_status", unknown>;
+//# sourceMappingURL=get-statement-status.d.ts.map

package/dist/providers/snowflake/tools/get-statement-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-statement-status.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/get-statement-status.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,6BAA6B;;iBAIxC,CAAC;AA6BH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASzC,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8IAkB1D"}

package/dist/providers/snowflake/tools/list-columns.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listColumnsInputSchema: z.ZodObject<{
+    database: z.ZodString;
+    schema: z.ZodString;
+    table: z.ZodString;
+}, z.core.$strip>;
+export declare const listColumnsOutputSchema: z.ZodObject<{
+    columns: z.ZodArray<z.ZodObject<{
+        table_name: z.ZodString;
+        schema_name: z.ZodString;
+        column_name: z.ZodString;
+        data_type: z.ZodString;
+        nullable: z.ZodBoolean;
+        default: z.ZodOptional<z.ZodString>;
+        kind: z.ZodString;
+        autoincrement: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listColumnsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    database: string;
+    schema: string;
+    table: string;
+}, {
+    columns: {
+        table_name: string;
+        schema_name: string;
+        column_name: string;
+        data_type: string;
+        nullable: boolean;
+        default?: string | undefined;
+        kind: string;
+        autoincrement?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_columns", unknown>;
+//# sourceMappingURL=list-columns.d.ts.map

package/dist/providers/snowflake/tools/list-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-columns.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/list-columns.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAaH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAElC,CAAC;AA8BH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;sIA8DnD"}

package/dist/providers/snowflake/tools/list-databases.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listDatabasesInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const listDatabasesOutputSchema: z.ZodObject<{
+    databases: z.ZodArray<z.ZodObject<{
+        created_on: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodString;
+        is_default: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        is_current: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        origin: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        owner: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        comment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        retention_time: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        kind: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listDatabasesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<Record<string, never>, {
+    databases: {
+        created_on?: string | null | undefined;
+        name: string;
+        is_default?: string | null | undefined;
+        is_current?: string | null | undefined;
+        origin?: string | null | undefined;
+        owner?: string | null | undefined;
+        comment?: string | null | undefined;
+        retention_time?: string | null | undefined;
+        kind?: string | null | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_databases", unknown>;
+//# sourceMappingURL=list-databases.d.ts.map

package/dist/providers/snowflake/tools/list-databases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-databases.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/list-databases.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,wBAAwB,gCAAe,CAAC;AAcrD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAEpC,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;wIA+CrD"}

package/dist/providers/snowflake/tools/list-roles.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listRolesInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const listRolesOutputSchema: z.ZodObject<{
+    roles: z.ZodArray<z.ZodObject<{
+        created_on: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        is_default: z.ZodBoolean;
+        is_current: z.ZodBoolean;
+        is_inherited: z.ZodBoolean;
+        assigned_to_users: z.ZodOptional<z.ZodNumber>;
+        granted_to_roles: z.ZodOptional<z.ZodNumber>;
+        granted_roles: z.ZodOptional<z.ZodNumber>;
+        owner: z.ZodOptional<z.ZodString>;
+        comment: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listRolesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<Record<string, never>, {
+    roles: {
+        created_on?: string | undefined;
+        name: string;
+        is_default: boolean;
+        is_current: boolean;
+        is_inherited: boolean;
+        assigned_to_users?: number | undefined;
+        granted_to_roles?: number | undefined;
+        granted_roles?: number | undefined;
+        owner?: string | undefined;
+        comment?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_roles", unknown>;
+//# sourceMappingURL=list-roles.d.ts.map

package/dist/providers/snowflake/tools/list-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-roles.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/list-roles.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,oBAAoB,gCAAe,CAAC;AAejD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;iBAEhC,CAAC;AAqHH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;oIAiEjD"}

package/dist/providers/snowflake/tools/list-schemas.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listSchemasInputSchema: z.ZodObject<{
+    database: z.ZodString;
+}, z.core.$strip>;
+export declare const listSchemasOutputSchema: z.ZodObject<{
+    schemas: z.ZodArray<z.ZodObject<{
+        created_on: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        is_default: z.ZodBoolean;
+        is_current: z.ZodBoolean;
+        database_name: z.ZodString;
+        owner: z.ZodString;
+        comment: z.ZodOptional<z.ZodString>;
+        retention_time: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listSchemasTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    database: string;
+}, {
+    schemas: {
+        created_on?: string | undefined;
+        name: string;
+        is_default: boolean;
+        is_current: boolean;
+        database_name: string;
+        owner: string;
+        comment?: string | undefined;
+        retention_time?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_schemas", unknown>;
+//# sourceMappingURL=list-schemas.d.ts.map

package/dist/providers/snowflake/tools/list-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-schemas.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/list-schemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;iBAEjC,CAAC;AAaH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAElC,CAAC;AA4DH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;sIA0FnD"}

package/dist/providers/snowflake/tools/list-stages.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listStagesInputSchema: z.ZodObject<{
+    database: z.ZodString;
+}, z.core.$strip>;
+export declare const listStagesOutputSchema: z.ZodObject<{
+    stages: z.ZodArray<z.ZodObject<{
+        created_on: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        database_name: z.ZodOptional<z.ZodString>;
+        schema_name: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        has_credentials: z.ZodOptional<z.ZodString>;
+        has_encryption_key: z.ZodOptional<z.ZodString>;
+        owner: z.ZodOptional<z.ZodString>;
+        comment: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        cloud: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listStagesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    database: string;
+}, {
+    stages: {
+        created_on?: string | undefined;
+        name?: string | undefined;
+        database_name?: string | undefined;
+        schema_name?: string | undefined;
+        url?: string | undefined;
+        has_credentials?: string | undefined;
+        has_encryption_key?: string | undefined;
+        owner?: string | undefined;
+        comment?: string | undefined;
+        region?: string | undefined;
+        type?: string | undefined;
+        cloud?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_stages", unknown>;
+//# sourceMappingURL=list-stages.d.ts.map

package/dist/providers/snowflake/tools/list-stages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-stages.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/list-stages.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;iBAEhC,CAAC;AAiBH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;iBAEjC,CAAC;AAiCH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;qIAmGlD"}