@mastra/connect 0.1.0 → 0.2.0-alpha.1

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

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteStorageObjectInputSchema: z.ZodObject<{
+    bucketId: z.ZodString;
+    prefixes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const deleteStorageObjectOutputSchema: z.ZodObject<{
+    deleted: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        bucket_id: z.ZodOptional<z.ZodString>;
+        owner: z.ZodOptional<z.ZodString>;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+        last_accessed_at: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        path_tokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export declare function deleteStorageObjectTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    bucketId: string;
+    prefixes: string[];
+}, {
+    deleted: {
+        [x: string]: unknown;
+        name: string;
+        id?: string | undefined;
+        bucket_id?: string | undefined;
+        owner?: string | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+        last_accessed_at?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        path_tokens?: string[] | undefined;
+        version?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_delete_storage_object", unknown>;
+//# sourceMappingURL=delete-storage-object.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-storage-object.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/delete-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;;;iBAGzC,CAAC;AAiBH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;iBAE1C,CAAC;AAEH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;8IAsC3D"}

package/dist/providers/supabase/tools/delete-table-rows.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteTableRowsInputSchema: z.ZodObject<{
+    table: z.ZodString;
+    filters: z.ZodRecord<z.ZodString, z.ZodString>;
+    returnRepresentation: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const deleteTableRowsOutputSchema: z.ZodObject<{
+    deletedCount: z.ZodOptional<z.ZodNumber>;
+    deletedRows: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare function deleteTableRowsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    table: string;
+    filters: Record<string, string>;
+    returnRepresentation?: boolean | undefined;
+}, {
+    deletedCount?: number | undefined;
+    deletedRows?: Record<string, unknown>[] | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_delete_table_rows", unknown>;
+//# sourceMappingURL=delete-table-rows.d.ts.map

package/dist/providers/supabase/tools/delete-table-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-table-rows.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/delete-table-rows.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;;;iBASrC,CAAC;AAIH,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;0IAwDvD"}

package/dist/providers/supabase/tools/generate-auth-link.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const generateAuthLinkInputSchema: z.ZodObject<{
+    type: z.ZodUnion<readonly [z.ZodLiteral<"magiclink">, z.ZodLiteral<"recovery">, z.ZodLiteral<"invite">, z.ZodLiteral<"signup">, z.ZodLiteral<"email_change_current">, z.ZodLiteral<"email_change_new">]>;
+    email: z.ZodString;
+    new_email: z.ZodOptional<z.ZodString>;
+    redirect_to: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const generateAuthLinkOutputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    action_link: z.ZodOptional<z.ZodString>;
+    email_otp: z.ZodOptional<z.ZodString>;
+    hashed_token: z.ZodOptional<z.ZodString>;
+    verification_type: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function generateAuthLinkTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    type: "email_change_current" | "email_change_new" | "invite" | "magiclink" | "recovery" | "signup";
+    email: string;
+    new_email?: string | undefined;
+    redirect_to?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+}, {
+    id?: string | undefined;
+    email?: string | undefined;
+    action_link?: string | undefined;
+    email_otp?: string | undefined;
+    hashed_token?: string | undefined;
+    verification_type?: string | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_generate_auth_link", unknown>;
+//# sourceMappingURL=generate-auth-link.d.ts.map

package/dist/providers/supabase/tools/generate-auth-link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-auth-link.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/generate-auth-link.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,2BAA2B;;;;;;iBAkBtC,CAAC;AAuBH,eAAO,MAAM,4BAA4B;;;;;;;;;iBASvC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;2IAwExD"}

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

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getAuthUserInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+export declare const getAuthUserOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    aud: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    email_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    phone_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    last_sign_in_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    app_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    user_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    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.ZodString;
+        created_at: z.ZodOptional<z.ZodString>;
+        last_sign_in_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    factors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+        friendly_name: z.ZodOptional<z.ZodString>;
+        factor_type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+    is_anonymous: z.ZodOptional<z.ZodBoolean>;
+    banned_until: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export declare function getAuthUserTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    userId: string;
+}, {
+    [x: string]: unknown;
+    id: string;
+    aud?: string | undefined;
+    role?: string | undefined;
+    email?: string | undefined;
+    phone?: string | null | undefined;
+    email_confirmed_at?: string | null | undefined;
+    phone_confirmed_at?: string | null | undefined;
+    confirmed_at?: string | null | undefined;
+    last_sign_in_at?: string | null | undefined;
+    app_metadata?: Record<string, unknown> | undefined;
+    user_metadata?: Record<string, unknown> | undefined;
+    identities?: {
+        id: string;
+        user_id: string;
+        identity_data?: Record<string, unknown> | undefined;
+        provider: string;
+        created_at?: string | undefined;
+        last_sign_in_at?: string | undefined;
+        updated_at?: string | undefined;
+    }[] | undefined;
+    factors?: {
+        id: string;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+        status?: string | undefined;
+        friendly_name?: string | undefined;
+        factor_type?: string | undefined;
+    }[] | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+    is_anonymous?: boolean | undefined;
+    banned_until?: string | null | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_get_auth_user", unknown>;
+//# sourceMappingURL=get-auth-user.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-auth-user.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/get-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,sBAAsB;;iBAKjC,CAAC;AA2CH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAqB,CAAC;AAE1D,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sIAqCnD"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-storage-bucket.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/get-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,2BAA2B;;iBAEtC,CAAC;AAeH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;iBAWvC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;2IAkDxD"}

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getStorageObjectInputSchema: z.ZodObject<{
+    bucketId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+export declare const getStorageObjectOutputSchema: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodString;
+    size: z.ZodNumber;
+    contentType: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export declare function getStorageObjectTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    bucketId: string;
+    path: string;
+}, {
+    name: string;
+    id: string;
+    size: number;
+    contentType: string;
+    created_at: string;
+    updated_at: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_get_storage_object", unknown>;
+//# sourceMappingURL=get-storage-object.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-storage-object.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/get-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,2BAA2B;;;iBAGtC,CAAC;AAiBH,eAAO,MAAM,4BAA4B;;;;;;;iBAOvC,CAAC;AAMH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;2IAkGxD"}

package/dist/providers/supabase/tools/insert-table-row.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const insertTableRowInputSchema: z.ZodObject<{
+    table: z.ZodString;
+    row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const insertTableRowOutputSchema: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+export declare function insertTableRowTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    table: string;
+    row: Record<string, unknown>;
+}, Record<string, unknown>[], unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_insert_table_row", unknown>;
+//# sourceMappingURL=insert-table-row.d.ts.map

package/dist/providers/supabase/tools/insert-table-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-table-row.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/insert-table-row.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;iBAKpC,CAAC;AAEH,eAAO,MAAM,0BAA0B,oDAA6C,CAAC;AAMrF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;oKAkCtD"}

package/dist/providers/supabase/tools/invoke-rpc.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const invokeRpcInputSchema: z.ZodObject<{
+    function_name: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    read_only: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const invokeRpcOutputSchema: z.ZodUnknown;
+export declare function invokeRpcTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    function_name: string;
+    args?: Record<string, unknown> | undefined;
+    read_only?: boolean | undefined;
+}, unknown, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_invoke_rpc", unknown>;
+//# sourceMappingURL=invoke-rpc.d.ts.map

package/dist/providers/supabase/tools/invoke-rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoke-rpc.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/invoke-rpc.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,oBAAoB;;;;iBAU/B,CAAC;AAaH,eAAO,MAAM,qBAAqB,cAAc,CAAC;AAEjD,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa;;;;4IA4DjD"}

package/dist/providers/supabase/tools/list-auth-factors.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listAuthFactorsInputSchema: z.ZodObject<{
+    user_id: z.ZodString;
+}, z.core.$strip>;
+export declare const listAuthFactorsOutputSchema: z.ZodObject<{
+    factors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        user_id: z.ZodString;
+        friendly_name: z.ZodOptional<z.ZodString>;
+        factor_type: z.ZodOptional<z.ZodEnum<{
+            phone: "phone";
+            totp: "totp";
+        }>>;
+        status: z.ZodOptional<z.ZodEnum<{
+            unverified: "unverified";
+            verified: "verified";
+        }>>;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function listAuthFactorsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    user_id: string;
+}, {
+    factors: {
+        id: string;
+        user_id: string;
+        friendly_name?: string | undefined;
+        factor_type?: "phone" | "totp" | undefined;
+        status?: "unverified" | "verified" | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_list_auth_factors", unknown>;
+//# sourceMappingURL=list-auth-factors.d.ts.map

package/dist/providers/supabase/tools/list-auth-factors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-auth-factors.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/list-auth-factors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;iBAOrC,CAAC;AAsBH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;iBAEtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;0IAqDvD"}

package/dist/providers/supabase/tools/list-auth-users.d.ts

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listAuthUsersInputSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const listAuthUsersOutputSchema: z.ZodObject<{
+    users: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        aud: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        email_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        phone_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        email_change: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        email_change_sent_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        email_change_confirm_status: z.ZodOptional<z.ZodNumber>;
+        phone_change: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        phone_change_sent_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        phone_change_token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        recovery_sent_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        recovery_token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        new_email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        new_phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        invited_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        confirmation_sent_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        confirmation_token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reauthentication_sent_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reauthentication_token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        is_super_admin: z.ZodOptional<z.ZodBoolean>;
+        created_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        last_sign_in_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        app_metadata: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        user_metadata: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        factors: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
+        identities: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{}, z.core.$loose>>, z.ZodNull]>>;
+    }, z.core.$loose>>;
+    total: z.ZodOptional<z.ZodNumber>;
+    next_page: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function listAuthUsersTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    page?: number | undefined;
+    per_page?: number | undefined;
+}, {
+    users: {
+        [x: string]: unknown;
+        id: string;
+        aud?: string | undefined;
+        role?: string | null | undefined;
+        email?: string | null | undefined;
+        email_confirmed_at?: string | null | undefined;
+        phone?: string | null | undefined;
+        phone_confirmed_at?: string | null | undefined;
+        confirmed_at?: string | null | undefined;
+        email_change?: string | null | undefined;
+        email_change_sent_at?: string | null | undefined;
+        email_change_confirm_status?: number | undefined;
+        phone_change?: string | null | undefined;
+        phone_change_sent_at?: string | null | undefined;
+        phone_change_token?: string | null | undefined;
+        recovery_sent_at?: string | null | undefined;
+        recovery_token?: string | null | undefined;
+        new_email?: string | null | undefined;
+        new_phone?: string | null | undefined;
+        invited_at?: string | null | undefined;
+        confirmation_sent_at?: string | null | undefined;
+        confirmation_token?: string | null | undefined;
+        reauthentication_sent_at?: string | null | undefined;
+        reauthentication_token?: string | null | undefined;
+        is_super_admin?: boolean | undefined;
+        created_at?: string | null | undefined;
+        updated_at?: string | null | undefined;
+        last_sign_in_at?: string | null | undefined;
+        app_metadata?: {
+            [x: string]: unknown;
+        } | undefined;
+        user_metadata?: {
+            [x: string]: unknown;
+        } | undefined;
+        factors?: {
+            [x: string]: unknown;
+        }[] | undefined;
+        identities?: {
+            [x: string]: unknown;
+        }[] | null | undefined;
+    }[];
+    total?: number | undefined;
+    next_page?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_list_auth_users", unknown>;
+//# sourceMappingURL=list-auth-users.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-auth-users.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/list-auth-users.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAC;AAsCH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIpC,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wIAoDrD"}

package/dist/providers/supabase/tools/list-storage-buckets.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listStorageBucketsInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    sort_column: z.ZodOptional<z.ZodEnum<{
+        created_at: "created_at";
+        id: "id";
+        name: "name";
+        updated_at: "updated_at";
+    }>>;
+    sort_order: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    search: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listStorageBucketsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        public: z.ZodBoolean;
+        owner: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        created_at: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        updated_at: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        file_size_limit: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        allowed_mime_types: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    next_offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function listStorageBucketsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    limit?: number | undefined;
+    offset?: number | undefined;
+    sort_column?: "created_at" | "id" | "name" | "updated_at" | undefined;
+    sort_order?: "asc" | "desc" | undefined;
+    search?: string | undefined;
+}, {
+    items: {
+        id: string;
+        name: string;
+        public: boolean;
+        owner?: string | null | undefined;
+        created_at?: string | null | undefined;
+        updated_at?: string | null | undefined;
+        file_size_limit?: number | null | undefined;
+        allowed_mime_types?: string[] | null | undefined;
+        type?: string | null | undefined;
+    }[];
+    next_offset?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_list_storage_buckets", unknown>;
+//# sourceMappingURL=list-storage-buckets.d.ts.map

package/dist/providers/supabase/tools/list-storage-buckets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-storage-buckets.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/list-storage-buckets.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;iBASxC,CAAC;AAcH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAGzC,CAAC;AAMH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;6IA2D1D"}

package/dist/providers/supabase/tools/list-storage-objects.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listStorageObjectsInputSchema: z.ZodObject<{
+    bucket_id: z.ZodString;
+    prefix: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const listStorageObjectsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        bucket_id: z.ZodOptional<z.ZodString>;
+        owner: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+        created_at: z.ZodOptional<z.ZodString>;
+        last_accessed_at: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            eTag: z.ZodOptional<z.ZodString>;
+            size: z.ZodOptional<z.ZodNumber>;
+            mimetype: z.ZodOptional<z.ZodString>;
+            cacheControl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    next_offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function listStorageObjectsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    bucket_id: string;
+    prefix?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    items: {
+        name: string;
+        id?: string | undefined;
+        bucket_id?: string | undefined;
+        owner?: string | undefined;
+        updated_at?: string | undefined;
+        created_at?: string | undefined;
+        last_accessed_at?: string | undefined;
+        metadata?: {
+            eTag?: string | undefined;
+            size?: number | undefined;
+            mimetype?: string | undefined;
+            cacheControl?: string | undefined;
+        } | undefined;
+    }[];
+    next_offset?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_list_storage_objects", unknown>;
+//# sourceMappingURL=list-storage-objects.d.ts.map

package/dist/providers/supabase/tools/list-storage-objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-storage-objects.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/list-storage-objects.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,6BAA6B;;;;;iBAKxC,CAAC;AAwBH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;iBAqBzC,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;6IAsE1D"}

package/dist/providers/supabase/tools/query-table-rows.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const queryTableRowsInputSchema: z.ZodObject<{
+    table: z.ZodString;
+    select: z.ZodOptional<z.ZodString>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        operator: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strip>>>;
+    order: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    count: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const queryTableRowsOutputSchema: z.ZodObject<{
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    count: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function queryTableRowsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    table: string;
+    select?: string | undefined;
+    filters?: {
+        column: string;
+        operator: string;
+        value: string | number | boolean;
+    }[] | undefined;
+    order?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    count?: boolean | undefined;
+}, {
+    rows: Record<string, unknown>[];
+    count?: number | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_query_table_rows", unknown>;
+//# sourceMappingURL=query-table-rows.d.ts.map

package/dist/providers/supabase/tools/query-table-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-table-rows.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/query-table-rows.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAQxE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAQpC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AAMH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;yIAiFtD"}