@mastra/connect 0.1.0 → 0.2.0-alpha.1

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

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getOrganizationInputSchema: z.ZodObject<{
+    organization_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getOrganizationOutputSchema: z.ZodObject<{
+    object: z.ZodLiteral<"organization">;
+    id: z.ZodString;
+    name: z.ZodString;
+    allow_profiles_outside_organization: z.ZodBoolean;
+    domains: z.ZodArray<z.ZodObject<{
+        object: z.ZodLiteral<"organization_domain">;
+        id: z.ZodString;
+        domain: z.ZodString;
+        organization_id: z.ZodString;
+        state: z.ZodString;
+        verification_token: z.ZodOptional<z.ZodString>;
+        verification_strategy: z.ZodString;
+        verification_prefix: z.ZodOptional<z.ZodString>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$strip>>;
+    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 getOrganizationTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    organization_id: string;
+}, {
+    [x: string]: unknown;
+    object: "organization";
+    id: string;
+    name: string;
+    allow_profiles_outside_organization: boolean;
+    domains: {
+        object: "organization_domain";
+        id: string;
+        domain: string;
+        organization_id: string;
+        state: string;
+        verification_token?: string | undefined;
+        verification_strategy: string;
+        verification_prefix?: string | undefined;
+        created_at: string;
+        updated_at: string;
+    }[];
+    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_get_organization", unknown>;
+//# sourceMappingURL=get-organization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-organization.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/get-organization.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;iBAErC,CAAC;AAeH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;iBAaxB,CAAC;AAEjB,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;uIAgBvD"}

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getUserInputSchema: z.ZodObject<{
+    user_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getUserOutputSchema: 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 getUserTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    user_id: string;
+}, {
+    [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_get_user", unknown>;
+//# sourceMappingURL=get-user.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-user.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/get-user.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,kBAAkB;;iBAE7B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;iBAiBhB,CAAC;AAEjB,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;+HAgB/C"}

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

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listConnectionsInputSchema: 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";
+    }>>;
+    connection_type: z.ZodOptional<z.ZodString>;
+    domain: z.ZodOptional<z.ZodString>;
+    organization_id: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listConnectionsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<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>>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listConnectionsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+    cursor_direction?: "after" | "before" | undefined;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    connection_type?: string | undefined;
+    domain?: string | undefined;
+    organization_id?: string | undefined;
+    search?: string | undefined;
+}, {
+    items: {
+        [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;
+    }[];
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_list_connections", unknown>;
+//# sourceMappingURL=list-connections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-connections.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/list-connections.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;AAyBH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uIA4BvD"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-directories.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/list-directories.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;iBAQrC,CAAC;AAuBH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;iBAGtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;uIA2BvD"}

package/dist/providers/workos/tools/list-directory-groups.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listDirectoryGroupsInputSchema: 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";
+    }>>;
+    directory: z.ZodOptional<z.ZodString>;
+    user: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listDirectoryGroupsOutputSchema: z.ZodObject<{
+    items: 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>>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listDirectoryGroupsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+    cursor_direction?: "after" | "before" | undefined;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    directory?: string | undefined;
+    user?: string | undefined;
+}, {
+    items: {
+        [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>;
+    }[];
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_list_directory_groups", unknown>;
+//# sourceMappingURL=list-directory-groups.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-directory-groups.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/list-directory-groups.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAOzC,CAAC;AAqBH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;iBAG1C,CAAC;AAEH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;4IA0B3D"}

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

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listDirectoryUsersInputSchema: 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";
+    }>>;
+    directory: z.ZodOptional<z.ZodString>;
+    group: z.ZodOptional<z.ZodString>;
+    idp_id: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listDirectoryUsersOutputSchema: z.ZodObject<{
+    items: z.ZodArray<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>>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listDirectoryUsersTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+    cursor_direction?: "after" | "before" | undefined;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    directory?: string | undefined;
+    group?: string | undefined;
+    idp_id?: string | undefined;
+    email?: string | undefined;
+}, {
+    items: {
+        [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;
+    }[];
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_list_directory_users", unknown>;
+//# sourceMappingURL=list-directory-users.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-directory-users.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/list-directory-users.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;AA0CH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGzC,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2IA4B1D"}

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listEventsInputSchema: 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";
+    }>>;
+    events: z.ZodArray<z.ZodString>;
+    range_start: z.ZodOptional<z.ZodString>;
+    range_end: z.ZodOptional<z.ZodString>;
+    organization_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listEventsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        event: z.ZodString;
+        created_at: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listEventsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+    cursor_direction?: "after" | "before" | undefined;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    events: string[];
+    range_start?: string | undefined;
+    range_end?: string | undefined;
+    organization_id?: string | undefined;
+}, {
+    items: {
+        [x: string]: unknown;
+        id: string;
+        event: string;
+        created_at: string;
+        data: Record<string, unknown>;
+        context?: Record<string, unknown> | undefined;
+    }[];
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_list_events", unknown>;
+//# sourceMappingURL=list-events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-events.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/list-events.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;iBAShC,CAAC;AAkBH,eAAO,MAAM,sBAAsB;;;;;;;;;iBAAmF,CAAC;AAEvH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;kIA4BlD"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-invitations.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/list-invitations.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;AA4BH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;iBAGtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;uIA0BvD"}

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

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listOrganizationMembershipGroupsInputSchema: 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";
+    }>>;
+    membership_id: z.ZodString;
+}, z.core.$strip>;
+export declare const listOrganizationMembershipGroupsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        organization_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listOrganizationMembershipGroupsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+    cursor_direction?: "after" | "before" | undefined;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    membership_id: string;
+}, {
+    items: {
+        [x: string]: unknown;
+        id: string;
+        name: string;
+        organization_id?: string | undefined;
+    }[];
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_list_organization_membership_groups", unknown>;
+//# sourceMappingURL=list-organization-membership-groups.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-organization-membership-groups.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/list-organization-membership-groups.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,2CAA2C;;;;;;;;;;;;iBAMtD,CAAC;AAYH,eAAO,MAAM,4CAA4C;;;;;;;iBAGvD,CAAC;AAEH,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;0JA2BxE"}

package/dist/providers/workos/tools/list-organization-memberships.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listOrganizationMembershipsInputSchema: 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";
+    }>>;
+    organization_id: z.ZodOptional<z.ZodString>;
+    user_id: z.ZodOptional<z.ZodString>;
+    statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        pending: "pending";
+    }>>>;
+}, z.core.$strip>;
+export declare const listOrganizationMembershipsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<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>>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listOrganizationMembershipsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+    cursor_direction?: "after" | "before" | undefined;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    organization_id?: string | undefined;
+    user_id?: string | undefined;
+    statuses?: ("active" | "inactive" | "pending")[] | undefined;
+}, {
+    items: {
+        [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;
+    }[];
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "workos_list_organization_memberships", unknown>;
+//# sourceMappingURL=list-organization-memberships.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-organization-memberships.d.ts","sourceRoot":"","sources":["../../../../src/providers/workos/tools/list-organization-memberships.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;iBAQjD,CAAC;AA0BH,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGlD,CAAC;AAEH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oJA2BnE"}