@mastra/connect 0.1.0 → 0.2.0-alpha.2

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

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateAuthUserInputSchema: z.ZodObject<{
+    user_id: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    password: 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>>;
+    ban_duration: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateAuthUserOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    user_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    app_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+    last_sign_in_at: z.ZodOptional<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.ZodString;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+        last_sign_in_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare function updateAuthUserTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    user_id: string;
+    email?: string | undefined;
+    phone?: string | undefined;
+    password?: string | undefined;
+    email_confirm?: boolean | undefined;
+    phone_confirm?: boolean | undefined;
+    user_metadata?: Record<string, unknown> | undefined;
+    app_metadata?: Record<string, unknown> | undefined;
+    ban_duration?: string | undefined;
+}, {
+    id: string;
+    email?: string | undefined;
+    phone?: string | undefined;
+    role?: string | undefined;
+    user_metadata?: Record<string, unknown> | undefined;
+    app_metadata?: Record<string, unknown> | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+    last_sign_in_at?: string | undefined;
+    identities?: {
+        id: string;
+        user_id: string;
+        identity_data?: Record<string, unknown> | undefined;
+        provider: string;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+        last_sign_in_at?: string | undefined;
+    }[] | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_update_auth_user", unknown>;
+//# sourceMappingURL=update-auth-user.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-auth-user.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/update-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;;;;;;;;;;iBAUpC,CAAC;AAsCH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;iBAWrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yIAgEtD"}

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateStorageBucketInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    public: z.ZodOptional<z.ZodBoolean>;
+    fileSizeLimit: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+    allowedMimeTypes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export declare const updateStorageBucketOutputSchema: z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare function updateStorageBucketTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    id: string;
+    public?: boolean | undefined;
+    fileSizeLimit?: string | number | null | undefined;
+    allowedMimeTypes?: string[] | null | undefined;
+}, {
+    message: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_update_storage_bucket", unknown>;
+//# sourceMappingURL=update-storage-bucket.d.ts.map

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

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

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateStorageObjectInputSchema: z.ZodObject<{
+    bucket_id: z.ZodString;
+    path: z.ZodString;
+    new_path: z.ZodOptional<z.ZodString>;
+    new_bucket_id: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    content_type: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateStorageObjectOutputSchema: z.ZodObject<{
+    message: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    full_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function updateStorageObjectTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    bucket_id: string;
+    path: string;
+    new_path?: string | undefined;
+    new_bucket_id?: string | undefined;
+    content?: string | undefined;
+    content_type?: string | undefined;
+}, {
+    message?: string | undefined;
+    id?: string | undefined;
+    path?: string | undefined;
+    full_path?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_update_storage_object", unknown>;
+//# sourceMappingURL=update-storage-object.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-storage-object.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/update-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;;;;;;;iBA8BxC,CAAC;AAeJ,eAAO,MAAM,+BAA+B;;;;;iBAK1C,CAAC;AAMH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;8IAgE3D"}

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateTableRowsInputSchema: z.ZodObject<{
+    table: z.ZodString;
+    updates: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    filters: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export declare const updateTableRowsOutputSchema: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+export declare function updateTableRowsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    table: string;
+    updates: Record<string, unknown>;
+    filters: Record<string, string>;
+}, Record<string, unknown>[], unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_update_table_rows", unknown>;
+//# sourceMappingURL=update-table-rows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-table-rows.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/update-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;;;;iBAMrC,CAAC;AAUH,eAAO,MAAM,2BAA2B,oDAA6B,CAAC;AAEtE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;qKA4CvD"}

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const upsertTableRowInputSchema: z.ZodObject<{
+    table: z.ZodString;
+    row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    on_conflict: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const upsertTableRowOutputSchema: z.ZodObject<{
+    row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare function upsertTableRowTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    table: string;
+    row: Record<string, unknown>;
+    on_conflict?: string | undefined;
+}, {
+    row: Record<string, unknown>;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "supabase_upsert_table_row", unknown>;
+//# sourceMappingURL=upsert-table-row.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"upsert-table-row.d.ts","sourceRoot":"","sources":["../../../../src/providers/supabase/tools/upsert-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;;;;iBASpC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;iBAErC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;yIAoDtD"}

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

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

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

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

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

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

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

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

package/dist/providers/workos/tools/create-connection.d.ts

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createConnectionInputSchema: z.ZodObject<{
+    organization_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    external_id: z.ZodOptional<z.ZodString>;
+    connection_type: z.ZodOptional<z.ZodString>;
+    attribute_maps: z.ZodOptional<z.ZodObject<{
+        standard_attributes: z.ZodOptional<z.ZodObject<{
+            idp_id: z.ZodOptional<z.ZodString>;
+            email: z.ZodOptional<z.ZodString>;
+            first_name: z.ZodOptional<z.ZodString>;
+            last_name: z.ZodOptional<z.ZodString>;
+            groups: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        custom_attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    saml_options: z.ZodOptional<z.ZodObject<{
+        idp_metadata_url: z.ZodOptional<z.ZodString>;
+        acs_url: z.ZodOptional<z.ZodString>;
+        sp_entity_id: z.ZodOptional<z.ZodString>;
+        idp_entity_id: z.ZodOptional<z.ZodString>;
+        idp_sso_url: z.ZodOptional<z.ZodString>;
+        idp_signing_certs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sp_signing_key_pair: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            cert: z.ZodString;
+        }, z.core.$strip>>;
+        sp_encryption_key_pairs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            cert: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    oidc_options: z.ZodOptional<z.ZodObject<{
+        discovery_endpoint: z.ZodString;
+        client_id: z.ZodString;
+        client_secret: z.ZodOptional<z.ZodString>;
+        redirect_uri: z.ZodOptional<z.ZodString>;
+        pkce: z.ZodOptional<z.ZodBoolean>;
+        token_authentication_method: z.ZodOptional<z.ZodEnum<{
+            client_secret_basic: "client_secret_basic";
+            client_secret_post: "client_secret_post";
+            private_key_jwt: "private_key_jwt";
+        }>>;
+        jwt_signing_key_pair: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            cert: z.ZodString;
+        }, z.core.$strip>>;
+        id_token_signature_algorithm: z.ZodOptional<z.ZodEnum<{
+            ES256: "ES256";
+            ES384: "ES384";
+            ES512: "ES512";
+            EdDSA: "EdDSA";
+            HS256: "HS256";
+            HS384: "HS384";
+            HS512: "HS512";
+            PS256: "PS256";
+            PS384: "PS384";
+            PS512: "PS512";
+            RS256: "RS256";
+            RS384: "RS384";
+            RS512: "RS512";
+        }>>;
+        fetch_user_info: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const createConnectionOutputSchema: z.ZodObject<{
+    object: z.ZodLiteral<"connection">;
+    id: z.ZodString;
+    organization_id: z.ZodOptional<z.ZodString>;
+    connection_type: z.ZodString;
+    name: z.ZodString;
+    state: z.ZodEnum<{
+        active: "active";
+        deleting: "deleting";
+        draft: "draft";
+        inactive: "inactive";
+        requires_type: "requires_type";
+        validating: "validating";
+    }>;
+    status: z.ZodEnum<{
+        linked: "linked";
+        unlinked: "unlinked";
+    }>;
+    domains: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        object: z.ZodLiteral<"connection_domain">;
+        domain: z.ZodString;
+    }, z.core.$loose>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$loose>;
+export declare function createConnectionTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    organization_id: string;
+    name?: string | undefined;
+    external_id?: string | undefined;
+    connection_type?: string | undefined;
+    attribute_maps?: {
+        standard_attributes?: {
+            idp_id?: string | undefined;
+            email?: string | undefined;
+            first_name?: string | undefined;
+            last_name?: string | undefined;
+            groups?: string | null | undefined;
+            name?: string | null | undefined;
+        } | undefined;
+        custom_attributes?: Record<string, string> | undefined;
+    } | undefined;
+    saml_options?: {
+        idp_metadata_url?: string | undefined;
+        acs_url?: string | undefined;
+        sp_entity_id?: string | undefined;
+        idp_entity_id?: string | undefined;
+        idp_sso_url?: string | undefined;
+        idp_signing_certs?: string[] | undefined;
+        sp_signing_key_pair?: {
+            key: string;
+            cert: string;
+        } | undefined;
+        sp_encryption_key_pairs?: {
+            key: string;
+            cert: string;
+        }[] | undefined;
+    } | undefined;
+    oidc_options?: {
+        discovery_endpoint: string;
+        client_id: string;
+        client_secret?: string | undefined;
+        redirect_uri?: string | undefined;
+        pkce?: boolean | undefined;
+        token_authentication_method?: "client_secret_basic" | "client_secret_post" | "private_key_jwt" | undefined;
+        jwt_signing_key_pair?: {
+            key: string;
+            cert: string;
+        } | undefined;
+        id_token_signature_algorithm?: "ES256" | "ES384" | "ES512" | "EdDSA" | "HS256" | "HS384" | "HS512" | "PS256" | "PS384" | "PS512" | "RS256" | "RS384" | "RS512" | undefined;
+        fetch_user_info?: boolean | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    object: "connection";
+    id: string;
+    organization_id?: string | undefined;
+    connection_type: string;
+    name: string;
+    state: "active" | "deleting" | "draft" | "inactive" | "requires_type" | "validating";
+    status: "linked" | "unlinked";
+    domains: {
+        [x: string]: unknown;
+        id: string;
+        object: "connection_domain";
+        domain: string;
+    }[];
+    created_at: string;
+    updated_at: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_create_connection", unknown>;
+//# sourceMappingURL=create-connection.d.ts.map

package/dist/providers/workos/tools/create-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-connection.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/create-connection.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAyDxE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBpC,CAAC;AAmBL,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAE3D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wIAyBxD"}

package/dist/providers/workos/tools/create-invitation.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createInvitationInputSchema: z.ZodObject<{
+    email: z.ZodString;
+    organization_id: z.ZodOptional<z.ZodString>;
+    role_slug: z.ZodOptional<z.ZodString>;
+    expires_in_days: z.ZodOptional<z.ZodNumber>;
+    inviter_user_id: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const createInvitationOutputSchema: z.ZodObject<{
+    object: z.ZodLiteral<"invitation">;
+    id: z.ZodString;
+    email: z.ZodString;
+    state: z.ZodEnum<{
+        accepted: "accepted";
+        expired: "expired";
+        pending: "pending";
+        revoked: "revoked";
+    }>;
+    accepted_at: z.ZodNullable<z.ZodString>;
+    revoked_at: z.ZodNullable<z.ZodString>;
+    expires_at: z.ZodString;
+    organization_id: z.ZodNullable<z.ZodString>;
+    inviter_user_id: z.ZodNullable<z.ZodString>;
+    accepted_user_id: z.ZodNullable<z.ZodString>;
+    role_slug: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    token: z.ZodString;
+    accept_invitation_url: z.ZodString;
+}, z.core.$loose>;
+export declare function createInvitationTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    email: string;
+    organization_id?: string | undefined;
+    role_slug?: string | undefined;
+    expires_in_days?: number | undefined;
+    inviter_user_id?: string | undefined;
+    locale?: string | undefined;
+}, {
+    [x: string]: unknown;
+    object: "invitation";
+    id: string;
+    email: string;
+    state: "accepted" | "expired" | "pending" | "revoked";
+    accepted_at: string | null;
+    revoked_at: string | null;
+    expires_at: string;
+    organization_id: string | null;
+    inviter_user_id: string | null;
+    accepted_user_id: string | null;
+    role_slug: string | null;
+    created_at: string;
+    updated_at: string;
+    token: string;
+    accept_invitation_url: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_create_invitation", unknown>;
+//# sourceMappingURL=create-invitation.d.ts.map

package/dist/providers/workos/tools/create-invitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-invitation.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/create-invitation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,2BAA2B;;;;;;;iBAOtC,CAAC;AAsBH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAE3D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;wIAwBxD"}

package/dist/providers/workos/tools/create-organization-domain.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createOrganizationDomainInputSchema: z.ZodObject<{
+    organization_id: z.ZodString;
+    domain: z.ZodString;
+}, z.core.$strip>;
+export declare const createOrganizationDomainOutputSchema: z.ZodObject<{
+    object: z.ZodLiteral<"organization_domain">;
+    id: z.ZodString;
+    organization_id: z.ZodString;
+    domain: z.ZodString;
+    state: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        legacy_verified: "legacy_verified";
+        pending: "pending";
+        unverified: "unverified";
+        verified: "verified";
+    }>>;
+    verification_prefix: z.ZodOptional<z.ZodString>;
+    verification_token: z.ZodOptional<z.ZodString>;
+    verification_strategy: z.ZodOptional<z.ZodEnum<{
+        dns: "dns";
+        manual: "manual";
+    }>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$loose>;
+export declare function createOrganizationDomainTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    organization_id: string;
+    domain: string;
+}, {
+    [x: string]: unknown;
+    object: "organization_domain";
+    id: string;
+    organization_id: string;
+    domain: string;
+    state?: "failed" | "legacy_verified" | "pending" | "unverified" | "verified" | undefined;
+    verification_prefix?: string | undefined;
+    verification_token?: string | undefined;
+    verification_strategy?: "dns" | "manual" | undefined;
+    created_at: string;
+    updated_at: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_create_organization_domain", unknown>;
+//# sourceMappingURL=create-organization-domain.d.ts.map

package/dist/providers/workos/tools/create-organization-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-organization-domain.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/create-organization-domain.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,mCAAmC;;;iBAAgE,CAAC;AAiBjH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAEnE,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;iJAiBhE"}

package/dist/providers/workos/tools/create-organization-membership.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createOrganizationMembershipInputSchema: z.ZodObject<{
+    user_id: z.ZodString;
+    organization_id: z.ZodString;
+    role_slug: z.ZodOptional<z.ZodString>;
+    role_slugs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const createOrganizationMembershipOutputSchema: z.ZodObject<{
+    object: z.ZodLiteral<"organization_membership">;
+    id: z.ZodString;
+    user_id: z.ZodString;
+    organization_id: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        pending: "pending";
+    }>;
+    directory_managed: z.ZodBoolean;
+    organization_name: z.ZodOptional<z.ZodString>;
+    custom_attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    role: z.ZodOptional<z.ZodObject<{
+        slug: z.ZodString;
+    }, z.core.$loose>>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+    }, z.core.$loose>>>;
+    user: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$loose>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$loose>;
+export declare function createOrganizationMembershipTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    user_id: string;
+    organization_id: string;
+    role_slug?: string | undefined;
+    role_slugs?: string[] | undefined;
+}, {
+    [x: string]: unknown;
+    object: "organization_membership";
+    id: string;
+    user_id: string;
+    organization_id: string;
+    status: "active" | "inactive" | "pending";
+    directory_managed: boolean;
+    organization_name?: string | undefined;
+    custom_attributes?: Record<string, unknown> | undefined;
+    role?: {
+        [x: string]: unknown;
+        slug: string;
+    } | undefined;
+    roles?: {
+        [x: string]: unknown;
+        slug: string;
+    }[] | undefined;
+    user?: {
+        [x: string]: unknown;
+        id: string;
+    } | undefined;
+    created_at: string;
+    updated_at: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_create_organization_membership", unknown>;
+//# sourceMappingURL=create-organization-membership.d.ts.map

package/dist/providers/workos/tools/create-organization-membership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-organization-membership.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/create-organization-membership.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,uCAAuC;;;;;iBAShD,CAAC;AAoBL,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAEvE,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qJAsBpE"}

package/dist/providers/workos/tools/create-organization.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createOrganizationInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    domain_data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        domain: z.ZodString;
+        state: z.ZodEnum<{
+            pending: "pending";
+            verified: "verified";
+        }>;
+    }, z.core.$strip>>>;
+    external_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const createOrganizationOutputSchema: z.ZodObject<{
+    object: z.ZodLiteral<"organization">;
+    id: z.ZodString;
+    name: z.ZodString;
+    allow_profiles_outside_organization: z.ZodBoolean;
+    domains: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    stripe_customer_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    external_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$loose>;
+export declare function createOrganizationTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    name: string;
+    domain_data?: {
+        domain: string;
+        state: "pending" | "verified";
+    }[] | undefined;
+    external_id?: string | null | undefined;
+    metadata?: Record<string, string> | undefined;
+}, {
+    [x: string]: unknown;
+    object: "organization";
+    id: string;
+    name: string;
+    allow_profiles_outside_organization: boolean;
+    domains: Record<string, unknown>[];
+    stripe_customer_id?: string | null | undefined;
+    created_at: string;
+    updated_at: string;
+    external_id?: string | null | undefined;
+    metadata?: Record<string, string> | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_create_organization", unknown>;
+//# sourceMappingURL=create-organization.d.ts.map

package/dist/providers/workos/tools/create-organization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-organization.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/create-organization.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAIxE,eAAO,MAAM,6BAA6B;;;;;;;;;;;iBAKxC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;iBAa3B,CAAC;AAEjB,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;0IAsB1D"}