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

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listStreamsInputSchema: z.ZodObject<{
+    database: z.ZodString;
+}, z.core.$strip>;
+export declare const listStreamsOutputSchema: z.ZodObject<{
+    streams: 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>;
+        owner: z.ZodOptional<z.ZodString>;
+        comment: z.ZodOptional<z.ZodString>;
+        table_name: z.ZodOptional<z.ZodString>;
+        source_type: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        stale: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listStreamsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    database: string;
+}, {
+    streams: {
+        created_on?: string | undefined;
+        name?: string | undefined;
+        database_name?: string | undefined;
+        schema_name?: string | undefined;
+        owner?: string | undefined;
+        comment?: string | undefined;
+        table_name?: string | undefined;
+        source_type?: string | undefined;
+        type?: string | undefined;
+        stale?: string | undefined;
+        mode?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_streams", unknown>;
+//# sourceMappingURL=list-streams.d.ts.map

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

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

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listTablesInputSchema: z.ZodObject<{
+    database: z.ZodString;
+    schema: z.ZodString;
+}, z.core.$strip>;
+export declare const listTablesOutputSchema: z.ZodObject<{
+    tables: z.ZodArray<z.ZodObject<{
+        created_on: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        database_name: z.ZodOptional<z.ZodString>;
+        schema_name: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        rows: z.ZodOptional<z.ZodNumber>;
+        bytes: z.ZodOptional<z.ZodNumber>;
+        owner: z.ZodOptional<z.ZodString>;
+        retention_time: z.ZodOptional<z.ZodNumber>;
+        is_external: z.ZodOptional<z.ZodString>;
+        is_iceberg: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listTablesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    database: string;
+    schema: string;
+}, {
+    tables: {
+        created_on?: string | undefined;
+        name: string;
+        database_name?: string | undefined;
+        schema_name?: string | undefined;
+        kind?: string | undefined;
+        rows?: number | undefined;
+        bytes?: number | undefined;
+        owner?: string | undefined;
+        retention_time?: number | undefined;
+        is_external?: string | undefined;
+        is_iceberg?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_tables", unknown>;
+//# sourceMappingURL=list-tables.d.ts.map

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

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

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listTasksInputSchema: z.ZodObject<{
+    database: z.ZodString;
+}, z.core.$strip>;
+export declare const listTasksOutputSchema: z.ZodObject<{
+    tasks: 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>;
+        owner: z.ZodOptional<z.ZodString>;
+        warehouse: z.ZodOptional<z.ZodString>;
+        schedule: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        definition: z.ZodOptional<z.ZodString>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listTasksTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    database: string;
+}, {
+    tasks: {
+        created_on?: string | undefined;
+        name?: string | undefined;
+        database_name?: string | undefined;
+        schema_name?: string | undefined;
+        owner?: string | undefined;
+        warehouse?: string | undefined;
+        schedule?: string | undefined;
+        state?: string | undefined;
+        definition?: string | undefined;
+        condition?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_tasks", unknown>;
+//# sourceMappingURL=list-tasks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-tasks.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/list-tasks.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,oBAAoB;;iBAE/B,CAAC;AAeH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;iBAEhC,CAAC;AAmCH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;oIAqFjD"}

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listUsersInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const listUsersOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        created_on: z.ZodOptional<z.ZodString>;
+        login_name: z.ZodOptional<z.ZodString>;
+        display_name: z.ZodOptional<z.ZodString>;
+        first_name: z.ZodOptional<z.ZodString>;
+        last_name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+        must_change_password: z.ZodOptional<z.ZodBoolean>;
+        default_warehouse: z.ZodOptional<z.ZodString>;
+        default_role: z.ZodOptional<z.ZodString>;
+        has_password: z.ZodOptional<z.ZodBoolean>;
+        has_rsa_public_key: z.ZodOptional<z.ZodBoolean>;
+        last_success_login: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listUsersTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<Record<string, never>, {
+    items: {
+        name: string;
+        created_on?: string | undefined;
+        login_name?: string | undefined;
+        display_name?: string | undefined;
+        first_name?: string | undefined;
+        last_name?: string | undefined;
+        email?: string | undefined;
+        disabled?: boolean | undefined;
+        must_change_password?: boolean | undefined;
+        default_warehouse?: string | undefined;
+        default_role?: string | undefined;
+        has_password?: boolean | undefined;
+        has_rsa_public_key?: boolean | undefined;
+        last_success_login?: string | undefined;
+        type?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_users", unknown>;
+//# sourceMappingURL=list-users.d.ts.map

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

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

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listViewsInputSchema: z.ZodObject<{
+    database_name: z.ZodString;
+    schema_name: z.ZodString;
+}, z.core.$strip>;
+export declare const listViewsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        created_on: z.ZodString;
+        name: z.ZodString;
+        database_name: z.ZodString;
+        schema_name: z.ZodString;
+        owner: z.ZodOptional<z.ZodString>;
+        comment: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        is_secure: z.ZodBoolean;
+        is_materialized: z.ZodBoolean;
+        change_tracking: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listViewsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    database_name: string;
+    schema_name: string;
+}, {
+    items: {
+        created_on: string;
+        name: string;
+        database_name: string;
+        schema_name: string;
+        owner?: string | undefined;
+        comment?: string | undefined;
+        text?: string | undefined;
+        is_secure: boolean;
+        is_materialized: boolean;
+        change_tracking?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_views", unknown>;
+//# sourceMappingURL=list-views.d.ts.map

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

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

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

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listWarehousesInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const listWarehousesOutputSchema: z.ZodObject<{
+    warehouses: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        state: z.ZodString;
+        type: z.ZodString;
+        size: z.ZodString;
+        min_cluster_count: z.ZodNumber;
+        max_cluster_count: z.ZodNumber;
+        started_clusters: z.ZodNumber;
+        running: z.ZodNumber;
+        queued: z.ZodNumber;
+        is_default: z.ZodBoolean;
+        is_current: z.ZodBoolean;
+        auto_suspend: z.ZodNumber;
+        auto_resume: z.ZodBoolean;
+        owner: z.ZodString;
+        enable_query_acceleration: z.ZodBoolean;
+        resource_monitor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listWarehousesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<Record<string, never>, {
+    warehouses: {
+        name: string;
+        state: string;
+        type: string;
+        size: string;
+        min_cluster_count: number;
+        max_cluster_count: number;
+        started_clusters: number;
+        running: number;
+        queued: number;
+        is_default: boolean;
+        is_current: boolean;
+        auto_suspend: number;
+        auto_resume: boolean;
+        owner: string;
+        enable_query_acceleration: boolean;
+        resource_monitor?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "snowflake_list_warehouses", unknown>;
+//# sourceMappingURL=list-warehouses.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-warehouses.d.ts","sourceRoot":"","sources":["../../../../src/providers/snowflake/tools/list-warehouses.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB,gCAAe,CAAC;AAoCtD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;iBAErC,CAAC;AAuBH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;yIAuEtD"}

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

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

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

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

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

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

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

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

package/dist/providers/supabase/tools/copy-storage-object.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const copyStorageObjectInputSchema: z.ZodObject<{
+    bucketId: z.ZodString;
+    sourceKey: z.ZodString;
+    destinationBucket: z.ZodString;
+    destinationKey: z.ZodString;
+}, z.core.$strip>;
+export declare const copyStorageObjectOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    bucket_id: z.ZodString;
+    owner: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        cacheControl: z.ZodOptional<z.ZodString>;
+        contentLength: z.ZodOptional<z.ZodNumber>;
+        httpStatusCode: z.ZodOptional<z.ZodNumber>;
+        eTag: z.ZodOptional<z.ZodString>;
+        lastModified: z.ZodOptional<z.ZodString>;
+        mimetype: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+    last_accessed_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function copyStorageObjectTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    bucketId: string;
+    sourceKey: string;
+    destinationBucket: string;
+    destinationKey: string;
+}, {
+    id: string;
+    name: string;
+    bucket_id: string;
+    owner?: string | undefined;
+    size?: number | undefined;
+    metadata?: {
+        cacheControl?: string | undefined;
+        contentLength?: number | undefined;
+        httpStatusCode?: number | undefined;
+        eTag?: string | undefined;
+        lastModified?: string | undefined;
+        mimetype?: string | undefined;
+        size?: number | undefined;
+    } | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+    last_accessed_at?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_copy_storage_object", unknown>;
+//# sourceMappingURL=copy-storage-object.d.ts.map

package/dist/providers/supabase/tools/copy-storage-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy-storage-object.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/copy-storage-object.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;;;;iBAOvC,CAAC;AAuBH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;iBAUxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;4IAoDzD"}

package/dist/providers/supabase/tools/create-auth-user.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createAuthUserInputSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    email_confirm: z.ZodOptional<z.ZodBoolean>;
+    phone_confirm: z.ZodOptional<z.ZodBoolean>;
+    user_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    app_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const createAuthUserOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    email_confirmed_at: z.ZodOptional<z.ZodString>;
+    phone_confirmed_at: z.ZodOptional<z.ZodString>;
+    last_sign_in_at: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    identities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        user_id: z.ZodString;
+        identity_data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        provider: z.ZodOptional<z.ZodString>;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    user_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    app_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare function createAuthUserTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    email?: string | undefined;
+    password?: string | undefined;
+    phone?: string | undefined;
+    email_confirm?: boolean | undefined;
+    phone_confirm?: boolean | undefined;
+    user_metadata?: Record<string, unknown> | undefined;
+    app_metadata?: Record<string, unknown> | undefined;
+}, {
+    id: string;
+    email?: string | undefined;
+    phone?: string | undefined;
+    email_confirmed_at?: string | undefined;
+    phone_confirmed_at?: string | undefined;
+    last_sign_in_at?: string | undefined;
+    created_at: string;
+    updated_at: string;
+    identities?: {
+        id: string;
+        user_id: string;
+        identity_data?: Record<string, unknown> | undefined;
+        provider?: string | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+    }[] | undefined;
+    user_metadata?: Record<string, unknown> | undefined;
+    app_metadata?: Record<string, unknown> | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_create_auth_user", unknown>;
+//# sourceMappingURL=create-auth-user.d.ts.map

package/dist/providers/supabase/tools/create-auth-user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-auth-user.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/create-auth-user.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;iBAYlC,CAAC;AA8BL,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;iBAuBrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;yIAkDtD"}

package/dist/providers/supabase/tools/create-signed-upload-url.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createSignedUploadUrlInputSchema: z.ZodObject<{
+    bucket_id: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+export declare const createSignedUploadUrlOutputSchema: z.ZodObject<{
+    signed_url: z.ZodString;
+    token: z.ZodString;
+}, z.core.$strip>;
+export declare function createSignedUploadUrlTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    bucket_id: string;
+    path: string;
+}, {
+    signed_url: string;
+    token: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_create_signed_upload_url", unknown>;
+//# sourceMappingURL=create-signed-upload-url.d.ts.map

package/dist/providers/supabase/tools/create-signed-upload-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-signed-upload-url.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/create-signed-upload-url.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,gCAAgC;;;iBAG3C,CAAC;AAOH,eAAO,MAAM,iCAAiC;;;iBAG5C,CAAC;AAEH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa;;;;;;iJA6C7D"}

package/dist/providers/supabase/tools/create-signed-url.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createSignedUrlInputSchema: z.ZodObject<{
+    bucket_id: z.ZodString;
+    path: z.ZodString;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const createSignedUrlOutputSchema: z.ZodObject<{
+    signed_url: z.ZodString;
+}, z.core.$strip>;
+export declare function createSignedUrlTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    bucket_id: string;
+    path: string;
+    expires_in?: number | undefined;
+}, {
+    signed_url: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_create_signed_url", unknown>;
+//# sourceMappingURL=create-signed-url.d.ts.map

package/dist/providers/supabase/tools/create-signed-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-signed-url.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/create-signed-url.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;;iBAEtC,CAAC;AAkBH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;0IAgEvD"}

package/dist/providers/supabase/tools/create-storage-bucket.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createStorageBucketInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    public: z.ZodOptional<z.ZodBoolean>;
+    file_size_limit: z.ZodOptional<z.ZodNumber>;
+    allowed_mime_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        ANALYTICS: "ANALYTICS";
+        STANDARD: "STANDARD";
+    }>>;
+}, z.core.$strip>;
+export declare const createStorageBucketOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    public: z.ZodBoolean;
+    owner: z.ZodOptional<z.ZodString>;
+    owner_id: z.ZodOptional<z.ZodString>;
+    file_size_limit: z.ZodOptional<z.ZodNumber>;
+    allowed_mime_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        ANALYTICS: "ANALYTICS";
+        STANDARD: "STANDARD";
+    }>>;
+}, z.core.$strip>;
+export declare function createStorageBucketTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    id: string;
+    name?: string | undefined;
+    public?: boolean | undefined;
+    file_size_limit?: number | undefined;
+    allowed_mime_types?: string[] | undefined;
+    type?: "ANALYTICS" | "STANDARD" | undefined;
+}, {
+    id: string;
+    name: string;
+    public: boolean;
+    owner?: string | undefined;
+    owner_id?: string | undefined;
+    file_size_limit?: number | undefined;
+    allowed_mime_types?: string[] | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+    type?: "ANALYTICS" | "STANDARD" | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_create_storage_bucket", unknown>;
+//# sourceMappingURL=create-storage-bucket.d.ts.map

package/dist/providers/supabase/tools/create-storage-bucket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-storage-bucket.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/create-storage-bucket.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,8BAA8B;;;;;;;;;;iBAUzC,CAAC;AAeH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;iBAW1C,CAAC;AAMH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;8IAgD3D"}

package/dist/providers/supabase/tools/create-storage-object.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createStorageObjectInputSchema: z.ZodObject<{
+    bucket_id: z.ZodString;
+    path: z.ZodString;
+    content: z.ZodString;
+    content_type: z.ZodString;
+    upsert: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const createStorageObjectOutputSchema: z.ZodObject<{
+    key: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare function createStorageObjectTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    bucket_id: string;
+    path: string;
+    content: string;
+    content_type: string;
+    upsert?: boolean | undefined;
+}, {
+    key: string;
+    id: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_create_storage_object", unknown>;
+//# sourceMappingURL=create-storage-object.d.ts.map

package/dist/providers/supabase/tools/create-storage-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-storage-object.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/create-storage-object.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,8BAA8B;;;;;;iBAQzC,CAAC;AAOH,eAAO,MAAM,+BAA+B;;;iBAG1C,CAAC;AAEH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;8IA2C3D"}

package/dist/providers/supabase/tools/delete-auth-factor.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteAuthFactorInputSchema: z.ZodObject<{
+    user_id: z.ZodString;
+    factor_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteAuthFactorOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    user_id: z.ZodString;
+    factor_id: z.ZodString;
+    factor_type: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    friendly_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function deleteAuthFactorTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    user_id: string;
+    factor_id: string;
+}, {
+    success: boolean;
+    user_id: string;
+    factor_id: string;
+    factor_type?: string | undefined;
+    status?: string | undefined;
+    friendly_name?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_delete_auth_factor", unknown>;
+//# sourceMappingURL=delete-auth-factor.d.ts.map

package/dist/providers/supabase/tools/delete-auth-factor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-auth-factor.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/delete-auth-factor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC;AAWH,eAAO,MAAM,4BAA4B;;;;;;;iBAOvC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;2IA6DxD"}

package/dist/providers/supabase/tools/delete-auth-user.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteAuthUserInputSchema: z.ZodObject<{
+    user_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteAuthUserOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    user_id: z.ZodString;
+}, z.core.$strip>;
+export declare function deleteAuthUserTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    user_id: string;
+}, {
+    success: boolean;
+    user_id: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_delete_auth_user", unknown>;
+//# sourceMappingURL=delete-auth-user.d.ts.map

package/dist/providers/supabase/tools/delete-auth-user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-auth-user.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/delete-auth-user.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,yBAAyB;;iBAKpC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;yIA0CtD"}

package/dist/providers/supabase/tools/delete-storage-bucket.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteStorageBucketInputSchema: z.ZodObject<{
+    bucket_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteStorageBucketOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    bucket_id: z.ZodString;
+}, z.core.$strip>;
+export declare function deleteStorageBucketTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    bucket_id: string;
+}, {
+    success: boolean;
+    bucket_id: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_delete_storage_bucket", unknown>;
+//# sourceMappingURL=delete-storage-bucket.d.ts.map

package/dist/providers/supabase/tools/delete-storage-bucket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-storage-bucket.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/delete-storage-bucket.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,8BAA8B;;iBAEzC,CAAC;AAOH,eAAO,MAAM,+BAA+B;;;iBAG1C,CAAC;AAMH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;8IA+F3D"}