@mastra/connect 0.1.0 → 0.2.0-alpha.2

package/dist/providers/incident-io/tools/get-schedule-override.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getScheduleOverrideInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getScheduleOverrideOutputSchema: z.ZodObject<{
+    override: z.ZodObject<{
+        created_at: z.ZodString;
+        end_at: z.ZodString;
+        id: z.ZodString;
+        layer_id: z.ZodString;
+        rotation_id: z.ZodString;
+        schedule_id: z.ZodString;
+        start_at: z.ZodString;
+        updated_at: z.ZodString;
+        user: z.ZodOptional<z.ZodObject<{
+            email: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            name: z.ZodString;
+            role: z.ZodUnion<[z.ZodEnum<{
+                administrator: "administrator";
+                owner: "owner";
+                responder: "responder";
+                unset: "unset";
+                viewer: "viewer";
+            }>, z.ZodString]>;
+            slack_user_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare function getScheduleOverrideTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+}, {
+    [x: string]: unknown;
+    override: {
+        [x: string]: unknown;
+        created_at: string;
+        end_at: string;
+        id: string;
+        layer_id: string;
+        rotation_id: string;
+        schedule_id: string;
+        start_at: string;
+        updated_at: string;
+        user?: {
+            [x: string]: unknown;
+            email?: string | undefined;
+            id: string;
+            name: string;
+            role: string;
+            slack_user_id?: string | undefined;
+        } | undefined;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_get_schedule_override", unknown>;
+//# sourceMappingURL=get-schedule-override.d.ts.map

package/dist/providers/incident-io/tools/get-schedule-override.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-schedule-override.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/get-schedule-override.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,8BAA8B;;iBAA6C,CAAC;AA6BzF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAEtE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;iJAkB3D"}

package/dist/providers/incident-io/tools/get-schedule-replica.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getScheduleReplicaInputSchema: z.ZodObject<{
+    schedule_id: z.ZodString;
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getScheduleReplicaOutputSchema: z.ZodObject<{
+    schedule_replica: z.ZodObject<{
+        created_at: z.ZodString;
+        id: z.ZodString;
+        last_sync_error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        last_synced_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        mirror_window_days: z.ZodOptional<z.ZodNumber>;
+        replica_fallback_user_id: z.ZodString;
+        replica_provider: z.ZodUnion<[z.ZodEnum<{
+            jsm: "jsm";
+            native: "native";
+            opsgenie: "opsgenie";
+            pagerduty: "pagerduty";
+        }>, z.ZodString]>;
+        replica_provider_id: z.ZodString;
+        schedule_id: z.ZodString;
+        sources: z.ZodArray<z.ZodObject<{
+            layer_id: z.ZodString;
+            rotation_id: z.ZodString;
+        }, z.core.$loose>>;
+        updated_at: z.ZodString;
+        user_statuses: z.ZodArray<z.ZodObject<{
+            external_user_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            user_id: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare function getScheduleReplicaTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    schedule_id: string;
+    id: string;
+}, {
+    [x: string]: unknown;
+    schedule_replica: {
+        [x: string]: unknown;
+        created_at: string;
+        id: string;
+        last_sync_error?: string | null | undefined;
+        last_synced_at?: string | null | undefined;
+        mirror_window_days?: number | undefined;
+        replica_fallback_user_id: string;
+        replica_provider: string;
+        replica_provider_id: string;
+        schedule_id: string;
+        sources: {
+            [x: string]: unknown;
+            layer_id: string;
+            rotation_id: string;
+        }[];
+        updated_at: string;
+        user_statuses: {
+            [x: string]: unknown;
+            external_user_id?: string | null | undefined;
+            user_id: string;
+        }[];
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_get_schedule_replica", unknown>;
+//# sourceMappingURL=get-schedule-replica.d.ts.map

package/dist/providers/incident-io/tools/get-schedule-replica.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-schedule-replica.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/get-schedule-replica.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,6BAA6B;;;iBAAsE,CAAC;AAyBjH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAErE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gJAkB1D"}

package/dist/providers/incident-io/tools/get-schedule-sync-rule.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getScheduleSyncRuleInputSchema: z.ZodObject<{
+    schedule_id: z.ZodString;
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getScheduleSyncRuleOutputSchema: z.ZodObject<{
+    schedule_sync_rule: z.ZodObject<{
+        created_at: z.ZodString;
+        id: z.ZodString;
+        permanent_member_user_ids: z.ZodArray<z.ZodString>;
+        rotation_id: z.ZodOptional<z.ZodString>;
+        schedule_id: z.ZodString;
+        schedule_sync_target: z.ZodObject<{
+            add_bot_to_group: z.ZodBoolean;
+            created_at: z.ZodString;
+            id: z.ZodString;
+            linked_schedules: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                team_ids: z.ZodArray<z.ZodString>;
+            }, z.core.$loose>>;
+            slack_team_id: z.ZodString;
+            slack_user_group_id: z.ZodString;
+            updated_at: z.ZodString;
+        }, z.core.$loose>;
+        schedule_sync_target_id: z.ZodString;
+        sync_type: z.ZodUnion<[z.ZodEnum<{
+            all_users: "all_users";
+            next_on_call: "next_on_call";
+            on_call: "on_call";
+        }>, z.ZodString]>;
+        updated_at: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare function getScheduleSyncRuleTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    schedule_id: string;
+    id: string;
+}, {
+    [x: string]: unknown;
+    schedule_sync_rule: {
+        [x: string]: unknown;
+        created_at: string;
+        id: string;
+        permanent_member_user_ids: string[];
+        rotation_id?: string | undefined;
+        schedule_id: string;
+        schedule_sync_target: {
+            [x: string]: unknown;
+            add_bot_to_group: boolean;
+            created_at: string;
+            id: string;
+            linked_schedules: {
+                [x: string]: unknown;
+                id: string;
+                name: string;
+                team_ids: string[];
+            }[];
+            slack_team_id: string;
+            slack_user_group_id: string;
+            updated_at: string;
+        };
+        schedule_sync_target_id: string;
+        sync_type: string;
+        updated_at: string;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_get_schedule_sync_rule", unknown>;
+//# sourceMappingURL=get-schedule-sync-rule.d.ts.map

package/dist/providers/incident-io/tools/get-schedule-sync-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-schedule-sync-rule.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/get-schedule-sync-rule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,8BAA8B;;;iBAAsE,CAAC;AAgClH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAEtE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kJAkB3D"}

package/dist/providers/incident-io/tools/get-schedule.d.ts

@@ -0,0 +1,222 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getScheduleInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getScheduleOutputSchema: z.ZodObject<{
+    schedule: z.ZodObject<{
+        annotations: z.ZodRecord<z.ZodString, z.ZodString>;
+        config: z.ZodOptional<z.ZodObject<{
+            rotations: z.ZodArray<z.ZodObject<{
+                effective_from: z.ZodOptional<z.ZodString>;
+                handover_start_at: z.ZodString;
+                handovers: z.ZodArray<z.ZodObject<{
+                    interval: z.ZodNumber;
+                    interval_type: z.ZodUnion<[z.ZodEnum<{
+                        daily: "daily";
+                        hourly: "hourly";
+                        weekly: "weekly";
+                    }>, z.ZodString]>;
+                }, z.core.$loose>>;
+                id: z.ZodString;
+                layers: z.ZodArray<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>;
+                name: z.ZodString;
+                scheduling_mode: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+                    fair: "fair";
+                    sequential: "sequential";
+                }>, z.ZodString]>>;
+                users: z.ZodArray<z.ZodObject<{
+                    email: z.ZodOptional<z.ZodString>;
+                    id: z.ZodString;
+                    name: z.ZodString;
+                    role: z.ZodUnion<[z.ZodEnum<{
+                        administrator: "administrator";
+                        owner: "owner";
+                        responder: "responder";
+                        unset: "unset";
+                        viewer: "viewer";
+                    }>, z.ZodString]>;
+                    slack_user_id: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>;
+                working_interval: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    end_time: z.ZodString;
+                    start_time: z.ZodString;
+                    weekday: z.ZodUnion<[z.ZodEnum<{
+                        friday: "friday";
+                        monday: "monday";
+                        saturday: "saturday";
+                        sunday: "sunday";
+                        thursday: "thursday";
+                        tuesday: "tuesday";
+                        wednesday: "wednesday";
+                    }>, z.ZodString]>;
+                }, z.core.$loose>>>;
+                working_intervals: z.ZodArray<z.ZodObject<{
+                    end_time: z.ZodString;
+                    start_time: z.ZodString;
+                    weekday: z.ZodUnion<[z.ZodEnum<{
+                        friday: "friday";
+                        monday: "monday";
+                        saturday: "saturday";
+                        sunday: "sunday";
+                        thursday: "thursday";
+                        tuesday: "tuesday";
+                        wednesday: "wednesday";
+                    }>, z.ZodString]>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+        created_at: z.ZodString;
+        current_shifts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            end_at: z.ZodString;
+            entry_id: z.ZodOptional<z.ZodString>;
+            fingerprint: z.ZodOptional<z.ZodString>;
+            layer_id: z.ZodOptional<z.ZodString>;
+            rotation_id: z.ZodOptional<z.ZodString>;
+            start_at: z.ZodString;
+            user: z.ZodOptional<z.ZodObject<{
+                email: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                name: z.ZodString;
+                role: z.ZodUnion<[z.ZodEnum<{
+                    administrator: "administrator";
+                    owner: "owner";
+                    responder: "responder";
+                    unset: "unset";
+                    viewer: "viewer";
+                }>, z.ZodString]>;
+                slack_user_id: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>>;
+        holidays_public_config: z.ZodOptional<z.ZodObject<{
+            country_codes: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        next_shifts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            end_at: z.ZodString;
+            entry_id: z.ZodOptional<z.ZodString>;
+            fingerprint: z.ZodOptional<z.ZodString>;
+            layer_id: z.ZodOptional<z.ZodString>;
+            rotation_id: z.ZodOptional<z.ZodString>;
+            start_at: z.ZodString;
+            user: z.ZodOptional<z.ZodObject<{
+                email: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                name: z.ZodString;
+                role: z.ZodUnion<[z.ZodEnum<{
+                    administrator: "administrator";
+                    owner: "owner";
+                    responder: "responder";
+                    unset: "unset";
+                    viewer: "viewer";
+                }>, z.ZodString]>;
+                slack_user_id: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>>;
+        permalink: z.ZodString;
+        team_ids: z.ZodArray<z.ZodString>;
+        timezone: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare function getScheduleTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+}, {
+    [x: string]: unknown;
+    schedule: {
+        [x: string]: unknown;
+        annotations: Record<string, string>;
+        config?: {
+            [x: string]: unknown;
+            rotations: {
+                [x: string]: unknown;
+                effective_from?: string | undefined;
+                handover_start_at: string;
+                handovers: {
+                    [x: string]: unknown;
+                    interval: number;
+                    interval_type: string;
+                }[];
+                id: string;
+                layers: {
+                    [x: string]: unknown;
+                    id?: string | undefined;
+                    name?: string | undefined;
+                }[];
+                name: string;
+                scheduling_mode?: string | undefined;
+                users: {
+                    [x: string]: unknown;
+                    email?: string | undefined;
+                    id: string;
+                    name: string;
+                    role: string;
+                    slack_user_id?: string | undefined;
+                }[];
+                working_interval?: {
+                    [x: string]: unknown;
+                    end_time: string;
+                    start_time: string;
+                    weekday: string;
+                }[] | undefined;
+                working_intervals: {
+                    [x: string]: unknown;
+                    end_time: string;
+                    start_time: string;
+                    weekday: string;
+                }[];
+            }[];
+        } | undefined;
+        created_at: string;
+        current_shifts?: {
+            [x: string]: unknown;
+            end_at: string;
+            entry_id?: string | undefined;
+            fingerprint?: string | undefined;
+            layer_id?: string | undefined;
+            rotation_id?: string | undefined;
+            start_at: string;
+            user?: {
+                [x: string]: unknown;
+                email?: string | undefined;
+                id: string;
+                name: string;
+                role: string;
+                slack_user_id?: string | undefined;
+            } | undefined;
+        }[] | undefined;
+        holidays_public_config?: {
+            [x: string]: unknown;
+            country_codes: string[];
+        } | undefined;
+        id: string;
+        name: string;
+        next_shifts?: {
+            [x: string]: unknown;
+            end_at: string;
+            entry_id?: string | undefined;
+            fingerprint?: string | undefined;
+            layer_id?: string | undefined;
+            rotation_id?: string | undefined;
+            start_at: string;
+            user?: {
+                [x: string]: unknown;
+                email?: string | undefined;
+                id: string;
+                name: string;
+                role: string;
+                slack_user_id?: string | undefined;
+            } | undefined;
+        }[] | undefined;
+        permalink: string;
+        team_ids: string[];
+        timezone: string;
+        updated_at: string;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_get_schedule", unknown>;
+//# sourceMappingURL=get-schedule.d.ts.map

package/dist/providers/incident-io/tools/get-schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-schedule.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/get-schedule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,sBAAsB;;iBAA6C,CAAC;AAmIjF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAE9D,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wIAkBnD"}

package/dist/providers/incident-io/tools/get-severity.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getSeverityInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getSeverityOutputSchema: z.ZodObject<{
+    severity: z.ZodObject<{
+        created_at: z.ZodString;
+        description: z.ZodString;
+        id: z.ZodString;
+        name: z.ZodString;
+        rank: z.ZodNumber;
+        updated_at: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare function getSeverityTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+}, {
+    [x: string]: unknown;
+    severity: {
+        [x: string]: unknown;
+        created_at: string;
+        description: string;
+        id: string;
+        name: string;
+        rank: number;
+        updated_at: string;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_get_severity", unknown>;
+//# sourceMappingURL=get-severity.d.ts.map

package/dist/providers/incident-io/tools/get-severity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-severity.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/get-severity.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,sBAAsB;;iBAA6C,CAAC;AAiBjF,eAAO,MAAM,uBAAuB;;;;;;;;;iBAAyB,CAAC;AAE9D,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;wIAkBnD"}

package/dist/providers/incident-io/tools/get-team.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getTeamInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getTeamOutputSchema: z.ZodObject<{
+    team: z.ZodObject<{
+        catalog_entry: z.ZodObject<{
+            external_id: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$loose>;
+        id: z.ZodString;
+        members: z.ZodArray<z.ZodObject<{
+            email: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            name: z.ZodString;
+            slack_user_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        name: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare function getTeamTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+}, {
+    [x: string]: unknown;
+    team: {
+        [x: string]: unknown;
+        catalog_entry: {
+            [x: string]: unknown;
+            external_id?: string | undefined;
+            id: string;
+            name: string;
+        };
+        id: string;
+        members: {
+            [x: string]: unknown;
+            email?: string | undefined;
+            id: string;
+            name: string;
+            slack_user_id?: string | undefined;
+        }[];
+        name: string;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_get_team", unknown>;
+//# sourceMappingURL=get-team.d.ts.map

package/dist/providers/incident-io/tools/get-team.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-team.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/get-team.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,kBAAkB;;iBAA6C,CAAC;AAwB7E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAE1D,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;oIAkB/C"}

package/dist/providers/incident-io/tools/get-user-paging-provider.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getUserPagingProviderInputSchema: z.ZodObject<{
+    user_id: z.ZodString;
+}, z.core.$loose>;
+export declare const getUserPagingProviderOutputSchema: z.ZodObject<{
+    preferred_escalation_provider: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+        native: "native";
+        opsgenie: "opsgenie";
+        pagerduty: "pagerduty";
+        splunk_on_call: "splunk_on_call";
+    }>, z.ZodString]>>;
+}, z.core.$loose>;
+export declare function getUserPagingProviderTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    user_id: string;
+}, {
+    [x: string]: unknown;
+    preferred_escalation_provider?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_get_user_paging_provider", unknown>;
+//# sourceMappingURL=get-user-paging-provider.d.ts.map

package/dist/providers/incident-io/tools/get-user-paging-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-user-paging-provider.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/get-user-paging-provider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,gCAAgC;;iBAAkD,CAAC;AAWhG,eAAO,MAAM,iCAAiC;;;;;;;iBAAyB,CAAC;AAExE,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa;;;;;;oJAkB7D"}

package/dist/providers/incident-io/tools/get-user.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getUserInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$loose>;
+export declare const getUserOutputSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        base_role: z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            name: z.ZodString;
+            slug: z.ZodString;
+        }, z.core.$loose>;
+        custom_roles: z.ZodArray<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            name: z.ZodString;
+            slug: z.ZodString;
+        }, z.core.$loose>>;
+        email: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        is_active: z.ZodBoolean;
+        name: z.ZodString;
+        role: z.ZodUnion<[z.ZodEnum<{
+            administrator: "administrator";
+            owner: "owner";
+            responder: "responder";
+            unset: "unset";
+            viewer: "viewer";
+        }>, z.ZodString]>;
+        seats: z.ZodObject<{
+            on_call: z.ZodUnion<[z.ZodEnum<{
+                full_access: "full_access";
+                none: "none";
+                viewer_only: "viewer_only";
+            }>, z.ZodString]>;
+            response: z.ZodUnion<[z.ZodEnum<{
+                full_access: "full_access";
+                none: "none";
+                viewer_only: "viewer_only";
+            }>, z.ZodString]>;
+        }, z.core.$loose>;
+        slack_user_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare function getUserTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    id: string;
+}, {
+    [x: string]: unknown;
+    user: {
+        [x: string]: unknown;
+        base_role: {
+            [x: string]: unknown;
+            description?: string | undefined;
+            id: string;
+            name: string;
+            slug: string;
+        };
+        custom_roles: {
+            [x: string]: unknown;
+            description?: string | undefined;
+            id: string;
+            name: string;
+            slug: string;
+        }[];
+        email?: string | undefined;
+        id: string;
+        is_active: boolean;
+        name: string;
+        role: string;
+        seats: {
+            [x: string]: unknown;
+            on_call: string;
+            response: string;
+        };
+        slack_user_id?: string | undefined;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_get_user", unknown>;
+//# sourceMappingURL=get-user.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-user.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/get-user.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,kBAAkB;;iBAA6C,CAAC;AA+B7E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAE1D,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oIAkB/C"}