@mastra/connect 0.1.0 → 0.2.0-alpha.2

package/dist/providers/workos/tools/list-organizations.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listOrganizationsInputSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    cursor_direction: z.ZodOptional<z.ZodEnum<{
+        after: "after";
+        before: "before";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    order: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const listOrganizationsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<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>>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listOrganizationsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+    cursor_direction?: "after" | "before" | undefined;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    domains?: string[] | undefined;
+}, {
+    items: {
+        [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;
+    }[];
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_list_organizations", unknown>;
+//# sourceMappingURL=list-organizations.d.ts.map

package/dist/providers/workos/tools/list-organizations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-organizations.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/list-organizations.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;iBAMvC,CAAC;AAuBH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;iBAGxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;yIAyBzD"}

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

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listUsersInputSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    cursor_direction: z.ZodOptional<z.ZodEnum<{
+        after: "after";
+        before: "before";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    order: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    email: z.ZodOptional<z.ZodString>;
+    organization_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listUsersOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        object: z.ZodLiteral<"user">;
+        id: z.ZodString;
+        email: z.ZodString;
+        email_verified: z.ZodBoolean;
+        profile_picture_url: z.ZodNullable<z.ZodString>;
+        name: z.ZodNullable<z.ZodString>;
+        first_name: z.ZodNullable<z.ZodString>;
+        last_name: z.ZodNullable<z.ZodString>;
+        last_sign_in_at: z.ZodNullable<z.ZodString>;
+        locale: 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>>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listUsersTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+    cursor_direction?: "after" | "before" | undefined;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    email?: string | undefined;
+    organization_id?: string | undefined;
+}, {
+    items: {
+        [x: string]: unknown;
+        object: "user";
+        id: string;
+        email: string;
+        email_verified: boolean;
+        profile_picture_url: string | null;
+        name: string | null;
+        first_name: string | null;
+        last_name: string | null;
+        last_sign_in_at: string | null;
+        locale: string | null;
+        created_at: string;
+        updated_at: string;
+        external_id?: string | null | undefined;
+        metadata?: Record<string, string> | undefined;
+    }[];
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_list_users", unknown>;
+//# sourceMappingURL=list-users.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-users.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/list-users.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAO/B,CAAC;AA2BH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;iBAA+E,CAAC;AAElH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;iIA0BjD"}

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

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const reactivateOrganizationMembershipInputSchema: z.ZodObject<{
+    membership_id: z.ZodString;
+}, z.core.$strip>;
+export declare const reactivateOrganizationMembershipOutputSchema: 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 reactivateOrganizationMembershipTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    membership_id: string;
+}, {
+    [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_reactivate_organization_membership", unknown>;
+//# sourceMappingURL=reactivate-organization-membership.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reactivate-organization-membership.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/reactivate-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,2CAA2C;;iBAA0C,CAAC;AAoBnG,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAE3E,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;yJAoBxE"}

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

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const resendInvitationInputSchema: z.ZodObject<{
+    invitation_id: z.ZodString;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const resendInvitationOutputSchema: 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 resendInvitationTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    invitation_id: string;
+    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_resend_invitation", unknown>;
+//# sourceMappingURL=resend-invitation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resend-invitation.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/resend-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;;;iBAAyE,CAAC;AAsBlH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAE3D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;wIAiBxD"}

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

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const revokeInvitationInputSchema: z.ZodObject<{
+    invitation_id: z.ZodString;
+}, z.core.$strip>;
+export declare const revokeInvitationOutputSchema: 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 revokeInvitationTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    invitation_id: string;
+}, {
+    [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_revoke_invitation", unknown>;
+//# sourceMappingURL=revoke-invitation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"revoke-invitation.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/revoke-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;;iBAA0C,CAAC;AAsBnF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAE3D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;wIAiBxD"}

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

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateConnectionInputSchema: z.ZodObject<{
+    connection_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    external_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    connection_type: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateConnectionOutputSchema: 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 updateConnectionTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    connection_id: string;
+    name?: string | undefined;
+    external_id?: string | null | undefined;
+    connection_type?: string | 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_update_connection", unknown>;
+//# sourceMappingURL=update-connection.d.ts.map

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

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

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateOrganizationMembershipInputSchema: z.ZodObject<{
+    membership_id: z.ZodString;
+    role_slug: z.ZodOptional<z.ZodString>;
+    role_slugs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const updateOrganizationMembershipOutputSchema: 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 updateOrganizationMembershipTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    membership_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_update_organization_membership", unknown>;
+//# sourceMappingURL=update-organization-membership.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-organization-membership.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/update-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;;;;iBAQhD,CAAC;AAoBL,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAEvE,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;qJAoBpE"}

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateOrganizationInputSchema: z.ZodObject<{
+    organization_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    domain_data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        domain: z.ZodString;
+        state: z.ZodEnum<{
+            pending: "pending";
+            verified: "verified";
+        }>;
+    }, z.core.$strip>>>;
+    stripe_customer_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    external_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const updateOrganizationOutputSchema: 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 updateOrganizationTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    organization_id: string;
+    name?: string | undefined;
+    domain_data?: {
+        domain: string;
+        state: "pending" | "verified";
+    }[] | undefined;
+    stripe_customer_id?: string | null | 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_update_organization", unknown>;
+//# sourceMappingURL=update-organization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-organization.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/update-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;;;;;;;;;;;;;iBAOxC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;iBAa3B,CAAC;AAEjB,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;0IAuB1D"}

package/dist/providers/workos/tools/update-user.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateUserInputSchema: z.ZodObject<{
+    user_id: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    first_name: z.ZodOptional<z.ZodString>;
+    last_name: z.ZodOptional<z.ZodString>;
+    email_verified: z.ZodOptional<z.ZodBoolean>;
+    password: z.ZodOptional<z.ZodString>;
+    password_hash: z.ZodOptional<z.ZodString>;
+    password_hash_type: z.ZodOptional<z.ZodEnum<{
+        argon2: "argon2";
+        bcrypt: "bcrypt";
+        "firebase-scrypt": "firebase-scrypt";
+        scrypt: "scrypt";
+        ssha: "ssha";
+    }>>;
+    external_id: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+}, z.core.$strip>;
+export declare const updateUserOutputSchema: z.ZodObject<{
+    object: z.ZodLiteral<"user">;
+    id: z.ZodString;
+    email: z.ZodString;
+    email_verified: z.ZodBoolean;
+    profile_picture_url: z.ZodNullable<z.ZodString>;
+    name: z.ZodNullable<z.ZodString>;
+    first_name: z.ZodNullable<z.ZodString>;
+    last_name: z.ZodNullable<z.ZodString>;
+    last_sign_in_at: z.ZodNullable<z.ZodString>;
+    locale: 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 updateUserTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    user_id: string;
+    email?: string | undefined;
+    name?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    email_verified?: boolean | undefined;
+    password?: string | undefined;
+    password_hash?: string | undefined;
+    password_hash_type?: "argon2" | "bcrypt" | "firebase-scrypt" | "scrypt" | "ssha" | undefined;
+    external_id?: string | undefined;
+    locale?: string | undefined;
+    metadata?: Record<string, string | null> | undefined;
+}, {
+    [x: string]: unknown;
+    object: "user";
+    id: string;
+    email: string;
+    email_verified: boolean;
+    profile_picture_url: string | null;
+    name: string | null;
+    first_name: string | null;
+    last_name: string | null;
+    last_sign_in_at: string | null;
+    locale: string | null;
+    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_update_user", unknown>;
+//# sourceMappingURL=update-user.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-user.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/update-user.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;iBAahC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;iBAiBnB,CAAC;AAEjB,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kIA6BlD"}

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const verifyOrganizationDomainInputSchema: z.ZodObject<{
+    organization_domain_id: z.ZodString;
+}, z.core.$strip>;
+export declare const verifyOrganizationDomainOutputSchema: 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 verifyOrganizationDomainTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    organization_domain_id: 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_verify_organization_domain", unknown>;
+//# sourceMappingURL=verify-organization-domain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verify-organization-domain.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/verify-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;;iBAAmD,CAAC;AAiBpG,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAEnE,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;iJAiBhE"}

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

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

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

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