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

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

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createUserInputSchema: z.ZodObject<{
+    email: z.ZodString;
+    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";
+    }>>;
+    name: z.ZodOptional<z.ZodString>;
+    first_name: z.ZodOptional<z.ZodString>;
+    last_name: z.ZodOptional<z.ZodString>;
+    email_verified: z.ZodOptional<z.ZodBoolean>;
+    external_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    ip_address: z.ZodOptional<z.ZodString>;
+    user_agent: z.ZodOptional<z.ZodString>;
+    signals_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const createUserOutputSchema: 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>>;
+    radar_auth_attempt_id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function createUserTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    email: string;
+    password?: string | undefined;
+    password_hash?: string | undefined;
+    password_hash_type?: "argon2" | "bcrypt" | "firebase-scrypt" | "scrypt" | "ssha" | undefined;
+    name?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    email_verified?: boolean | undefined;
+    external_id?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    ip_address?: string | undefined;
+    user_agent?: string | undefined;
+    signals_id?: string | 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;
+    radar_auth_attempt_id?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_create_user", unknown>;
+//# sourceMappingURL=create-user.d.ts.map

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

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

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

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deactivateOrganizationMembershipInputSchema: z.ZodObject<{
+    membership_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deactivateOrganizationMembershipOutputSchema: 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 deactivateOrganizationMembershipTool(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_deactivate_organization_membership", unknown>;
+//# sourceMappingURL=deactivate-organization-membership.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deactivate-organization-membership.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/deactivate-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/delete-connection.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteConnectionInputSchema: z.ZodObject<{
+    connection_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteConnectionOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function deleteConnectionTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    connection_id: string;
+}, {
+    id: string;
+    success: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_delete_connection", unknown>;
+//# sourceMappingURL=delete-connection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-connection.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/delete-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;;iBAA0C,CAAC;AAEnF,eAAO,MAAM,4BAA4B;;;iBAAqD,CAAC;AAE/F,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;wIAgBxD"}

package/dist/providers/workos/tools/delete-directory.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteDirectoryInputSchema: z.ZodObject<{
+    directory_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteDirectoryOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function deleteDirectoryTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    directory_id: string;
+}, {
+    id: string;
+    success: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_delete_directory", unknown>;
+//# sourceMappingURL=delete-directory.d.ts.map

package/dist/providers/workos/tools/delete-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-directory.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/delete-directory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;iBAAyC,CAAC;AAEjF,eAAO,MAAM,2BAA2B;;;iBAAqD,CAAC;AAE9F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;uIAgBvD"}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteOrganizationDomainInputSchema: z.ZodObject<{
+    organization_domain_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteOrganizationDomainOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function deleteOrganizationDomainTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    organization_domain_id: string;
+}, {
+    id: string;
+    success: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_delete_organization_domain", unknown>;
+//# sourceMappingURL=delete-organization-domain.d.ts.map

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

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

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteOrganizationMembershipInputSchema: z.ZodObject<{
+    membership_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteOrganizationMembershipOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function deleteOrganizationMembershipTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    membership_id: string;
+}, {
+    id: string;
+    success: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_delete_organization_membership", unknown>;
+//# sourceMappingURL=delete-organization-membership.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-organization-membership.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/delete-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;;iBAA0C,CAAC;AAE/F,eAAO,MAAM,wCAAwC;;;iBAAqD,CAAC;AAE3G,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,aAAa;;;;;qJAgBpE"}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteOrganizationInputSchema: z.ZodObject<{
+    organization_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteOrganizationOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function deleteOrganizationTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    organization_id: string;
+}, {
+    id: string;
+    success: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_delete_organization", unknown>;
+//# sourceMappingURL=delete-organization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-organization.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/delete-organization.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,6BAA6B;;iBAExC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;iBAAqD,CAAC;AAEjG,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;0IAgB1D"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-user.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/delete-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;;iBAEhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;iBAAqD,CAAC;AAEzF,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;kIAgBlD"}

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getConnectionInputSchema: z.ZodObject<{
+    connection_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getConnectionOutputSchema: 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 getConnectionTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    connection_id: string;
+}, {
+    [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_get_connection", unknown>;
+//# sourceMappingURL=get-connection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-connection.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/get-connection.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,wBAAwB;;iBAA0C,CAAC;AAmBhF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAExD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;qIAiBrD"}

package/dist/providers/workos/tools/get-directory-group.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getDirectoryGroupInputSchema: z.ZodObject<{
+    group_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getDirectoryGroupOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    idp_id: z.ZodString;
+    directory_id: z.ZodString;
+    organization_id: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    raw_attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$loose>;
+export declare function getDirectoryGroupTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    group_id: string;
+}, {
+    [x: string]: unknown;
+    id: string;
+    idp_id: string;
+    directory_id: string;
+    organization_id: string | null;
+    name: string;
+    created_at: string;
+    updated_at: string;
+    raw_attributes: Record<string, unknown>;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_get_directory_group", unknown>;
+//# sourceMappingURL=get-directory-group.d.ts.map

package/dist/providers/workos/tools/get-directory-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-directory-group.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/get-directory-group.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;iBAAqC,CAAC;AAe/E,eAAO,MAAM,6BAA6B;;;;;;;;;iBAAiB,CAAC;AAE5D,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;0IAiBzD"}

package/dist/providers/workos/tools/get-directory-user.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getDirectoryUserInputSchema: z.ZodObject<{
+    directory_user_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getDirectoryUserOutputSchema: z.ZodObject<{
+    object: z.ZodLiteral<"directory_user">;
+    id: z.ZodString;
+    directory_id: z.ZodString;
+    organization_id: z.ZodNullable<z.ZodString>;
+    idp_id: z.ZodString;
+    first_name: z.ZodNullable<z.ZodString>;
+    last_name: z.ZodNullable<z.ZodString>;
+    email: z.ZodNullable<z.ZodString>;
+    state: z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+    }>;
+    role: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    raw_attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    custom_attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    groups: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        idp_id: z.ZodString;
+        directory_id: z.ZodString;
+        organization_id: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        raw_attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$loose>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$loose>;
+export declare function getDirectoryUserTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    directory_user_id: string;
+}, {
+    [x: string]: unknown;
+    object: "directory_user";
+    id: string;
+    directory_id: string;
+    organization_id: string | null;
+    idp_id: string;
+    first_name: string | null;
+    last_name: string | null;
+    email: string | null;
+    state: "active" | "inactive";
+    role?: Record<string, unknown> | undefined;
+    roles?: Record<string, unknown>[] | undefined;
+    raw_attributes: Record<string, unknown>;
+    custom_attributes?: Record<string, unknown> | undefined;
+    groups: {
+        [x: string]: unknown;
+        id: string;
+        idp_id: string;
+        directory_id: string;
+        organization_id: string | null;
+        name: string;
+        created_at: string;
+        updated_at: string;
+        raw_attributes: Record<string, unknown>;
+    }[];
+    created_at: string;
+    updated_at: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_get_directory_user", unknown>;
+//# sourceMappingURL=get-directory-user.d.ts.map

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

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

package/dist/providers/workos/tools/get-directory.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getDirectoryInputSchema: z.ZodObject<{
+    directory_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getDirectoryOutputSchema: z.ZodObject<{
+    object: z.ZodLiteral<"directory">;
+    id: z.ZodString;
+    domain: z.ZodString;
+    external_key: z.ZodString;
+    name: z.ZodString;
+    organization_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    state: z.ZodString;
+    type: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$loose>;
+export declare function getDirectoryTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    directory_id: string;
+}, {
+    [x: string]: unknown;
+    object: "directory";
+    id: string;
+    domain: string;
+    external_key: string;
+    name: string;
+    organization_id?: string | null | undefined;
+    state: string;
+    type: string;
+    created_at: string;
+    updated_at: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_get_directory", unknown>;
+//# sourceMappingURL=get-directory.d.ts.map

package/dist/providers/workos/tools/get-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-directory.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/get-directory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,uBAAuB;;iBAAyC,CAAC;AAiB9E,eAAO,MAAM,wBAAwB;;;;;;;;;;;iBAAiB,CAAC;AAEvD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;oIAiBpD"}

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

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getInvitationInputSchema: z.ZodObject<{
+    invitation_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getInvitationOutputSchema: 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 getInvitationTool(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_get_invitation", unknown>;
+//# sourceMappingURL=get-invitation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-invitation.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/get-invitation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,wBAAwB;;iBAA0C,CAAC;AAsBhF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAExD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;qIAiBrD"}

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getOrganizationDomainInputSchema: z.ZodObject<{
+    organization_domain_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getOrganizationDomainOutputSchema: 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 getOrganizationDomainTool(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_get_organization_domain", unknown>;
+//# sourceMappingURL=get-organization-domain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-organization-domain.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/get-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,gCAAgC;;iBAAmD,CAAC;AAiBjG,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAEhE,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;8IAiB7D"}

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

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getOrganizationMembershipInputSchema: z.ZodObject<{
+    membership_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getOrganizationMembershipOutputSchema: 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 getOrganizationMembershipTool(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_get_organization_membership", unknown>;
+//# sourceMappingURL=get-organization-membership.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-organization-membership.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/get-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,oCAAoC;;iBAA0C,CAAC;AAoB5F,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;iBAAiB,CAAC;AAEpE,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;kJAiBjE"}