@mastra/connect 0.2.0 → 0.3.0-alpha.0

package/dist/providers/hubspot/tools/update-ticket.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateTicketInputSchema: z.ZodObject<{
+    ticketId: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    pipeline: z.ZodOptional<z.ZodString>;
+    pipelineStage: z.ZodOptional<z.ZodString>;
+    ownerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateTicketOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    pipeline: z.ZodOptional<z.ZodString>;
+    pipelineStage: z.ZodOptional<z.ZodString>;
+    ownerId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function updateTicketTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    ticketId: string;
+    subject?: string | undefined;
+    content?: string | undefined;
+    status?: string | undefined;
+    priority?: string | undefined;
+    category?: string | undefined;
+    pipeline?: string | undefined;
+    pipelineStage?: string | undefined;
+    ownerId?: string | undefined;
+}, {
+    id: string;
+    subject?: string | undefined;
+    content?: string | undefined;
+    status?: string | undefined;
+    priority?: string | undefined;
+    category?: string | undefined;
+    pipeline?: string | undefined;
+    pipelineStage?: string | undefined;
+    ownerId?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "hubspot_update_ticket", unknown>;
+//# sourceMappingURL=update-ticket.d.ts.map

package/dist/providers/hubspot/tools/update-ticket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-ticket.d.ts","sourceRoot":"","sources":["../../../../src/providers/hubspot/tools/update-ticket.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,uBAAuB;;;;;;;;;;iBAUlC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAYnC,CAAC;AAEH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;qIA2CpD"}

package/dist/providers/hubspot/tools/whoami.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const whoamiInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const whoamiOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    hubId: z.ZodNumber;
+    hubDomain: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function whoamiTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<Record<string, never>, {
+    id: string;
+    email: string;
+    hubId: number;
+    hubDomain?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "hubspot_whoami", unknown>;
+//# sourceMappingURL=whoami.d.ts.map

package/dist/providers/hubspot/tools/whoami.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whoami.d.ts","sourceRoot":"","sources":["../../../../src/providers/hubspot/tools/whoami.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,iBAAiB,gCAAe,CAAC;AAE9C,eAAO,MAAM,kBAAkB;;;;;iBAK7B,CAAC;AAEH,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa;;;;;8HA4C9C"}

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/providers/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAc3D,eAAO,MAAM,SAAS,EAAE,SAAS,oBAAoB,EAYpD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/providers/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAwB3D,eAAO,MAAM,SAAS,EAAE,SAAS,oBAAoB,EAsBpD,CAAC"}

package/dist/providers/jira/tools/get-field.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getFieldInputSchema: z.ZodObject<{
+    fieldId: z.ZodString;
+}, z.core.$strip>;
+export declare const getFieldOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    custom: z.ZodBoolean;
+    clauseNames: z.ZodArray<z.ZodString>;
+    navigable: z.ZodBoolean;
+    orderable: z.ZodBoolean;
+    searchable: z.ZodBoolean;
+    key: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        system: z.ZodOptional<z.ZodString>;
+        custom: z.ZodOptional<z.ZodString>;
+        customId: z.ZodOptional<z.ZodNumber>;
+        items: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function getFieldTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    fieldId: string;
+}, {
+    id: string;
+    name: string;
+    custom: boolean;
+    clauseNames: string[];
+    navigable: boolean;
+    orderable: boolean;
+    searchable: boolean;
+    key?: string | undefined;
+    schema?: {
+        type?: string | undefined;
+        system?: string | undefined;
+        custom?: string | undefined;
+        customId?: number | undefined;
+        items?: string | undefined;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "jira_get_field", unknown>;
+//# sourceMappingURL=get-field.d.ts.map

package/dist/providers/jira/tools/get-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-field.d.ts","sourceRoot":"","sources":["../../../../src/providers/jira/tools/get-field.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,mBAAmB;;iBAI9B,CAAC;AAUH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;iBAU/B,CAAC;AAYH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;8HA0EhD"}

package/dist/providers/jira/tools/update-comment.d.ts

@@ -34,10 +34,10 @@ export declare const updateCommentOutputSchema: z.ZodObject<{
         self: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     visibility: z.ZodOptional<z.ZodObject<{
-        type: z.ZodEnum<{
+        type: z.ZodUnion<[z.ZodEnum<{
             group: "group";
             role: "role";
-        }>;
+        }>, z.ZodString]>;
         value: z.ZodOptional<z.ZodString>;
         identifier: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
@@ -76,7 +76,7 @@ export declare function updateCommentTool(proxy: PlatformProxy): import("@mastra
         self?: string | undefined;
     } | undefined;
     visibility?: {
-        type: "group" | "role";
+        type: string;
         value?: string | undefined;
         identifier?: string | undefined;
     } | undefined;

package/dist/providers/jira/tools/update-comment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-comment.d.ts","sourceRoot":"","sources":["../../../../src/providers/jira/tools/update-comment.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAYxE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;iBAOnC,CAAC;AAoBH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;iBASpC,CAAC;AAOH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mIAoGrD"}
+{"version":3,"file":"update-comment.d.ts","sourceRoot":"","sources":["../../../../src/providers/jira/tools/update-comment.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAoBxE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;iBAOnC,CAAC;AAoBH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;iBASpC,CAAC;AAOH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mIAoGrD"}

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

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/providers/jira/tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAwC7D,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,oBAAoB,2CA0C7D"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/providers/jira/tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAyC7D,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,oBAAoB,2CA2C7D"}

package/dist/providers/notion/tools/get-bot-user.d.ts

@@ -8,10 +8,10 @@ export declare const getBotUserOutputSchema: z.ZodObject<{
     type: z.ZodLiteral<"bot">;
     bot: z.ZodObject<{
         owner: z.ZodObject<{
-            type: z.ZodEnum<{
+            type: z.ZodUnion<[z.ZodEnum<{
                 user: "user";
                 workspace: "workspace";
-            }>;
+            }>, z.ZodString]>;
             user_id: z.ZodOptional<z.ZodString>;
             user_name: z.ZodOptional<z.ZodString>;
             user_email: z.ZodOptional<z.ZodString>;
@@ -28,7 +28,7 @@ export declare function getBotUserTool(proxy: PlatformProxy): import("@mastra/co
     type: "bot";
     bot: {
         owner: {
-            type: "user" | "workspace";
+            type: string;
             user_id?: string | undefined;
             user_name?: string | undefined;
             user_email?: string | undefined;

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

@@ -7,10 +7,10 @@ export declare const getUserOutputSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
     avatarUrl: z.ZodOptional<z.ZodString>;
-    type: z.ZodEnum<{
+    type: z.ZodUnion<[z.ZodEnum<{
         bot: "bot";
         person: "person";
-    }>;
+    }>, z.ZodString]>;
     email: z.ZodOptional<z.ZodString>;
     botOwner: z.ZodOptional<z.ZodObject<{
         type: z.ZodString;
@@ -25,7 +25,7 @@ export declare function getUserTool(proxy: PlatformProxy): import("@mastra/core/
     id: string;
     name?: string | undefined;
     avatarUrl?: string | undefined;
-    type: "bot" | "person";
+    type: string;
     email?: string | undefined;
     botOwner?: {
         type: string;

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

@@ -7,10 +7,10 @@ export declare const listUsersInputSchema: z.ZodObject<{
 export declare const listUsersOutputSchema: z.ZodObject<{
     users: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        type: z.ZodEnum<{
+        type: z.ZodUnion<[z.ZodEnum<{
             bot: "bot";
             person: "person";
-        }>;
+        }>, z.ZodString]>;
         name: z.ZodOptional<z.ZodString>;
         avatar_url: z.ZodOptional<z.ZodString>;
         email: z.ZodOptional<z.ZodString>;
@@ -24,7 +24,7 @@ export declare function listUsersTool(proxy: PlatformProxy): import("@mastra/cor
 }, {
     users: {
         id: string;
-        type: "bot" | "person";
+        type: string;
         name?: string | undefined;
         avatar_url?: string | undefined;
         email?: string | undefined;

package/dist/providers/openai/tools/get-batch.d.ts

@@ -5,7 +5,7 @@ export declare const getBatchInputSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const getBatchOutputSchema: z.ZodObject<{
     id: z.ZodString;
-    status: z.ZodEnum<{
+    status: z.ZodUnion<[z.ZodEnum<{
         cancelled: "cancelled";
         cancelling: "cancelling";
         completed: "completed";
@@ -14,7 +14,7 @@ export declare const getBatchOutputSchema: z.ZodObject<{
         finalizing: "finalizing";
         in_progress: "in_progress";
         validating: "validating";
-    }>;
+    }>, z.ZodString]>;
     input_file_id: z.ZodString;
     output_file_id: z.ZodOptional<z.ZodString>;
     error_file_id: z.ZodOptional<z.ZodString>;
@@ -32,7 +32,7 @@ export declare function getBatchTool(proxy: PlatformProxy): import("@mastra/core
     batch_id: string;
 }, {
     id: string;
-    status: "cancelled" | "cancelling" | "completed" | "expired" | "failed" | "finalizing" | "in_progress" | "validating";
+    status: string;
     input_file_id: string;
     output_file_id?: string | undefined;
     error_file_id?: string | undefined;

package/dist/providers/openai/tools/get-batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-batch.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/get-batch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,mBAAmB;;iBAE9B,CAAC;AAgCH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;iBAwB/B,CAAC;AAEH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;gIA8ChD"}
+{"version":3,"file":"get-batch.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/get-batch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,mBAAmB;;iBAE9B,CAAC;AAyBH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;iBAiB/B,CAAC;AAEH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;gIA8ChD"}

package/dist/providers/openai/tools/list-batches.d.ts

@@ -19,7 +19,7 @@ export declare const listBatchesOutputSchema: z.ZodObject<{
         }, z.core.$loose>>;
         input_file_id: z.ZodString;
         completion_window: z.ZodString;
-        status: z.ZodEnum<{
+        status: z.ZodUnion<[z.ZodEnum<{
             cancelled: "cancelled";
             cancelling: "cancelling";
             completed: "completed";
@@ -28,7 +28,7 @@ export declare const listBatchesOutputSchema: z.ZodObject<{
             finalizing: "finalizing";
             in_progress: "in_progress";
             validating: "validating";
-        }>;
+        }>, z.ZodString]>;
         output_file_id: z.ZodNullable<z.ZodString>;
         error_file_id: z.ZodNullable<z.ZodString>;
         created_at: z.ZodNumber;
@@ -69,7 +69,7 @@ export declare function listBatchesTool(proxy: PlatformProxy): import("@mastra/c
         } | null;
         input_file_id: string;
         completion_window: string;
-        status: "cancelled" | "cancelling" | "completed" | "expired" | "failed" | "finalizing" | "in_progress" | "validating";
+        status: string;
         output_file_id: string | null;
         error_file_id: string | null;
         created_at: number;

package/dist/providers/openai/tools/list-batches.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-batches.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/list-batches.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;iBAKjC,CAAC;AA8DH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mIA0BnD"}
+{"version":3,"file":"list-batches.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/list-batches.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;iBAKjC,CAAC;AAuDH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mIA0BnD"}

package/dist/providers/openai/tools/list-fine-tuning-jobs.d.ts

@@ -14,14 +14,14 @@ export declare const listFineTuningJobsOutputSchema: z.ZodObject<{
         fine_tuned_model: z.ZodOptional<z.ZodString>;
         organization_id: z.ZodString;
         result_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        status: z.ZodEnum<{
+        status: z.ZodUnion<[z.ZodEnum<{
             cancelled: "cancelled";
             failed: "failed";
             queued: "queued";
             running: "running";
             succeeded: "succeeded";
             validating_files: "validating_files";
-        }>;
+        }>, z.ZodString]>;
         validation_file: z.ZodOptional<z.ZodString>;
         training_file: z.ZodString;
         hyperparameters: z.ZodOptional<z.ZodObject<{
@@ -56,7 +56,7 @@ export declare function listFineTuningJobsTool(proxy: PlatformProxy): import("@m
         fine_tuned_model?: string | undefined;
         organization_id: string;
         result_files?: string[] | undefined;
-        status: "cancelled" | "failed" | "queued" | "running" | "succeeded" | "validating_files";
+        status: string;
         validation_file?: string | undefined;
         training_file: string;
         hyperparameters?: {

package/dist/providers/openai/tools/list-vector-store-files.d.ts

@@ -20,12 +20,12 @@ export declare const listVectorStoreFilesOutputSchema: z.ZodObject<{
         id: z.ZodString;
         object: z.ZodString;
         vector_store_id: z.ZodString;
-        status: z.ZodEnum<{
+        status: z.ZodUnion<[z.ZodEnum<{
             cancelled: "cancelled";
             completed: "completed";
             failed: "failed";
             in_progress: "in_progress";
-        }>;
+        }>, z.ZodString]>;
         created_at: z.ZodNumber;
         usage_bytes: z.ZodNumber;
     }, z.core.$strip>>;
@@ -44,7 +44,7 @@ export declare function listVectorStoreFilesTool(proxy: PlatformProxy): import("
         id: string;
         object: string;
         vector_store_id: string;
-        status: "cancelled" | "completed" | "failed" | "in_progress";
+        status: string;
         created_at: number;
         usage_bytes: number;
     }[];

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/posthog/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD,eAAO,MAAM,eAAe,EAAE,oBAI7B,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/providers/posthog/tools/capture-event.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const captureEventInputSchema: z.ZodObject<{
+    api_key: z.ZodString;
+    event: z.ZodString;
+    distinct_id: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const captureEventOutputSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+export declare function captureEventTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    api_key: string;
+    event: string;
+    distinct_id: string;
+    properties?: Record<string, unknown> | undefined;
+    timestamp?: string | undefined;
+}, {
+    status?: string | number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "posthog_capture_event", unknown>;
+//# sourceMappingURL=capture-event.d.ts.map

package/dist/providers/posthog/tools/capture-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-event.d.ts","sourceRoot":"","sources":["../../../../src/providers/posthog/tools/capture-event.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,uBAAuB;;;;;;iBAMlC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;iBAEnC,CAAC;AAEH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa;;;;;;;;qIAiCpD"}

package/dist/providers/posthog/tools/create-action.d.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createActionInputSchema: z.ZodObject<{
+    project_id: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodString>>>;
+    post_to_slack: z.ZodOptional<z.ZodBoolean>;
+    slack_message_format: z.ZodOptional<z.ZodString>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodOptional<z.ZodString>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            type: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+            operator: z.ZodString;
+        }, z.core.$strip>>>;
+        selector: z.ZodOptional<z.ZodString>;
+        selector_regex: z.ZodOptional<z.ZodString>;
+        tag_name: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        text_matching: z.ZodOptional<z.ZodString>;
+        href: z.ZodOptional<z.ZodString>;
+        href_matching: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        url_matching: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const createActionOutputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodString>>>;
+    post_to_slack: z.ZodOptional<z.ZodBoolean>;
+    slack_message_format: z.ZodOptional<z.ZodString>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodOptional<z.ZodString>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            type: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+            operator: z.ZodString;
+        }, z.core.$strip>>>;
+        selector: z.ZodOptional<z.ZodString>;
+        selector_regex: z.ZodOptional<z.ZodString>;
+        tag_name: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        text_matching: z.ZodOptional<z.ZodString>;
+        href: z.ZodOptional<z.ZodString>;
+        href_matching: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        url_matching: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    deleted: z.ZodOptional<z.ZodBoolean>;
+    is_calculating: z.ZodOptional<z.ZodBoolean>;
+    last_calculated_at: z.ZodOptional<z.ZodString>;
+    team_id: z.ZodOptional<z.ZodNumber>;
+    is_action: z.ZodOptional<z.ZodBoolean>;
+    bytecode_error: z.ZodOptional<z.ZodString>;
+    pinned_at: z.ZodOptional<z.ZodString>;
+    creation_context: z.ZodOptional<z.ZodString>;
+    user_access_level: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createActionTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    project_id: number;
+    name: string;
+    description?: string | undefined;
+    tags?: (string | null)[] | undefined;
+    post_to_slack?: boolean | undefined;
+    slack_message_format?: string | undefined;
+    steps?: {
+        event?: string | undefined;
+        properties?: {
+            key: string;
+            type: string;
+            value: string | number | boolean | (string | number | boolean)[];
+            operator: string;
+        }[] | undefined;
+        selector?: string | undefined;
+        selector_regex?: string | undefined;
+        tag_name?: string | undefined;
+        text?: string | undefined;
+        text_matching?: string | undefined;
+        href?: string | undefined;
+        href_matching?: string | undefined;
+        url?: string | undefined;
+        url_matching?: string | undefined;
+    }[] | undefined;
+}, {
+    id: number;
+    name: string;
+    description?: string | undefined;
+    tags?: (string | null)[] | undefined;
+    post_to_slack?: boolean | undefined;
+    slack_message_format?: string | undefined;
+    steps?: {
+        event?: string | undefined;
+        properties?: {
+            key: string;
+            type: string;
+            value: string | number | boolean | (string | number | boolean)[];
+            operator: string;
+        }[] | undefined;
+        selector?: string | undefined;
+        selector_regex?: string | undefined;
+        tag_name?: string | undefined;
+        text?: string | undefined;
+        text_matching?: string | undefined;
+        href?: string | undefined;
+        href_matching?: string | undefined;
+        url?: string | undefined;
+        url_matching?: string | undefined;
+    }[] | undefined;
+    created_at?: string | undefined;
+    deleted?: boolean | undefined;
+    is_calculating?: boolean | undefined;
+    last_calculated_at?: string | undefined;
+    team_id?: number | undefined;
+    is_action?: boolean | undefined;
+    bytecode_error?: string | undefined;
+    pinned_at?: string | undefined;
+    creation_context?: string | undefined;
+    user_access_level?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "posthog_create_action", unknown>;
+//# sourceMappingURL=create-action.d.ts.map

package/dist/providers/posthog/tools/create-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-action.d.ts","sourceRoot":"","sources":["../../../../src/providers/posthog/tools/create-action.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAuBxE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;iBAQlC,CAAC;AAoCH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBnC,CAAC;AAEH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qIA+CpD"}

package/dist/providers/posthog/tools/create-alert.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createAlertInputSchema: z.ZodObject<{
+    project_id: z.ZodString;
+    insight: z.ZodNumber;
+    name: z.ZodString;
+    condition_type: z.ZodEnum<{
+        absolute_value: "absolute_value";
+        relative_decrease: "relative_decrease";
+        relative_increase: "relative_increase";
+    }>;
+    threshold_type: z.ZodEnum<{
+        absolute: "absolute";
+        percentage: "percentage";
+    }>;
+    threshold_lower: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    threshold_upper: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    calculation_interval: z.ZodOptional<z.ZodEnum<{
+        daily: "daily";
+        every_15_minutes: "every_15_minutes";
+        hourly: "hourly";
+        monthly: "monthly";
+        weekly: "weekly";
+    }>>;
+    subscribed_users: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    config_series_index: z.ZodOptional<z.ZodNumber>;
+    config_check_ongoing_interval: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    skip_weekend: z.ZodOptional<z.ZodBoolean>;
+    snoozed_until: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    detector_config: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    schedule_restriction: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    investigation_agent_enabled: z.ZodOptional<z.ZodBoolean>;
+    investigation_gates_notifications: z.ZodOptional<z.ZodBoolean>;
+    investigation_inconclusive_action: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const createAlertOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    insight_id: z.ZodNumber;
+    state: z.ZodString;
+    enabled: z.ZodBoolean;
+    calculation_interval: z.ZodString;
+    condition_type: z.ZodOptional<z.ZodString>;
+    threshold_type: z.ZodOptional<z.ZodString>;
+    threshold_lower: z.ZodOptional<z.ZodNumber>;
+    threshold_upper: z.ZodOptional<z.ZodNumber>;
+    config_series_index: z.ZodOptional<z.ZodNumber>;
+    config_check_ongoing_interval: z.ZodOptional<z.ZodBoolean>;
+    subscribed_users: z.ZodArray<z.ZodNumber>;
+    created_at: z.ZodString;
+    snoozed_until: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    skip_weekend: z.ZodOptional<z.ZodBoolean>;
+    detector_config: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    schedule_restriction: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    investigation_agent_enabled: z.ZodOptional<z.ZodBoolean>;
+    investigation_gates_notifications: z.ZodOptional<z.ZodBoolean>;
+    investigation_inconclusive_action: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createAlertTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    project_id: string;
+    insight: number;
+    name: string;
+    condition_type: "absolute_value" | "relative_decrease" | "relative_increase";
+    threshold_type: "absolute" | "percentage";
+    threshold_lower?: number | null | undefined;
+    threshold_upper?: number | null | undefined;
+    calculation_interval?: "daily" | "every_15_minutes" | "hourly" | "monthly" | "weekly" | undefined;
+    subscribed_users?: number[] | undefined;
+    config_series_index?: number | undefined;
+    config_check_ongoing_interval?: boolean | undefined;
+    enabled?: boolean | undefined;
+    skip_weekend?: boolean | undefined;
+    snoozed_until?: string | null | undefined;
+    detector_config?: Record<string, unknown> | null | undefined;
+    schedule_restriction?: Record<string, unknown> | null | undefined;
+    investigation_agent_enabled?: boolean | undefined;
+    investigation_gates_notifications?: boolean | undefined;
+    investigation_inconclusive_action?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    insight_id: number;
+    state: string;
+    enabled: boolean;
+    calculation_interval: string;
+    condition_type?: string | undefined;
+    threshold_type?: string | undefined;
+    threshold_lower?: number | undefined;
+    threshold_upper?: number | undefined;
+    config_series_index?: number | undefined;
+    config_check_ongoing_interval?: boolean | undefined;
+    subscribed_users: number[];
+    created_at: string;
+    snoozed_until?: string | null | undefined;
+    skip_weekend?: boolean | undefined;
+    detector_config?: Record<string, unknown> | null | undefined;
+    schedule_restriction?: Record<string, unknown> | null | undefined;
+    investigation_agent_enabled?: boolean | undefined;
+    investigation_gates_notifications?: boolean | undefined;
+    investigation_inconclusive_action?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "posthog_create_alert", unknown>;
+//# sourceMappingURL=create-alert.d.ts.map

package/dist/providers/posthog/tools/create-alert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-alert.d.ts","sourceRoot":"","sources":["../../../../src/providers/posthog/tools/create-alert.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoBjC,CAAC;AAwDH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;iBAsBlC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oIA0GnD"}