@mastra/connect 0.1.0 → 0.2.0-alpha.1

package/dist/providers/incident-io/tools/list-catalog-types.d.ts

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listCatalogTypesInputSchema: z.ZodObject<{}, z.core.$loose>;
+export declare const listCatalogTypesOutputSchema: z.ZodObject<{
+    catalog_types: z.ZodArray<z.ZodObject<{
+        annotations: z.ZodRecord<z.ZodString, z.ZodString>;
+        categories: z.ZodArray<z.ZodUnion<[z.ZodEnum<{
+            customer: "customer";
+            "issue-tracker": "issue-tracker";
+            "on-call": "on-call";
+            "product-feature": "product-feature";
+            service: "service";
+            team: "team";
+            user: "user";
+        }>, z.ZodString]>>;
+        color: z.ZodUnion<[z.ZodEnum<{
+            blue: "blue";
+            cyan: "cyan";
+            green: "green";
+            orange: "orange";
+            pink: "pink";
+            violet: "violet";
+            yellow: "yellow";
+        }>, z.ZodString]>;
+        created_at: z.ZodString;
+        description: z.ZodString;
+        dynamic_resource_parameter: z.ZodOptional<z.ZodString>;
+        engine_resource_type: z.ZodString;
+        estimated_count: z.ZodOptional<z.ZodNumber>;
+        icon: z.ZodUnion<[z.ZodEnum<{
+            alert: "alert";
+            bolt: "bolt";
+            box: "box";
+            briefcase: "briefcase";
+            browser: "browser";
+            bulb: "bulb";
+            calendar: "calendar";
+            clock: "clock";
+            cog: "cog";
+            components: "components";
+            database: "database";
+            doc: "doc";
+            email: "email";
+            "escalation-path": "escalation-path";
+            files: "files";
+            flag: "flag";
+            folder: "folder";
+            globe: "globe";
+            "incident-template": "incident-template";
+            money: "money";
+            server: "server";
+            severity: "severity";
+            star: "star";
+            "status-page": "status-page";
+            store: "store";
+            tag: "tag";
+            user: "user";
+            users: "users";
+        }>, z.ZodString]>;
+        id: z.ZodString;
+        is_editable: z.ZodBoolean;
+        is_team_type: z.ZodOptional<z.ZodBoolean>;
+        last_synced_at: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        owning_team_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        ranked: z.ZodBoolean;
+        registry_type: z.ZodOptional<z.ZodString>;
+        required_integrations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        schema: z.ZodObject<{
+            attributes: z.ZodArray<z.ZodObject<{
+                array: z.ZodBoolean;
+                backlink_attribute: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                mode: z.ZodUnion<[z.ZodEnum<{
+                    "": "";
+                    api: "api";
+                    backlink: "backlink";
+                    dashboard: "dashboard";
+                    dynamic: "dynamic";
+                    external: "external";
+                    internal: "internal";
+                    path: "path";
+                }>, z.ZodString]>;
+                name: z.ZodString;
+                path: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    attribute_id: z.ZodString;
+                    attribute_name: z.ZodString;
+                }, z.core.$loose>>>;
+                type: z.ZodString;
+            }, z.core.$loose>>;
+            version: z.ZodNumber;
+        }, z.core.$loose>;
+        source_repo_url: z.ZodOptional<z.ZodString>;
+        type_name: z.ZodString;
+        updated_at: z.ZodString;
+        use_name_as_identifier: z.ZodBoolean;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare function listCatalogTypesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+}, {
+    [x: string]: unknown;
+    catalog_types: {
+        [x: string]: unknown;
+        annotations: Record<string, string>;
+        categories: string[];
+        color: string;
+        created_at: string;
+        description: string;
+        dynamic_resource_parameter?: string | undefined;
+        engine_resource_type: string;
+        estimated_count?: number | undefined;
+        icon: string;
+        id: string;
+        is_editable: boolean;
+        is_team_type?: boolean | undefined;
+        last_synced_at?: string | undefined;
+        name: string;
+        owning_team_ids?: string[] | undefined;
+        ranked: boolean;
+        registry_type?: string | undefined;
+        required_integrations?: string[] | undefined;
+        schema: {
+            [x: string]: unknown;
+            attributes: {
+                [x: string]: unknown;
+                array: boolean;
+                backlink_attribute?: string | undefined;
+                id: string;
+                mode: string;
+                name: string;
+                path?: {
+                    [x: string]: unknown;
+                    attribute_id: string;
+                    attribute_name: string;
+                }[] | undefined;
+                type: string;
+            }[];
+            version: number;
+        };
+        source_repo_url?: string | undefined;
+        type_name: string;
+        updated_at: string;
+        use_name_as_identifier: boolean;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_list_catalog_types", unknown>;
+//# sourceMappingURL=list-catalog-types.d.ts.map

package/dist/providers/incident-io/tools/list-catalog-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-catalog-types.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/list-catalog-types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,2BAA2B,gCAA6B,CAAC;AA4FtE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8IAkBxD"}

package/dist/providers/incident-io/tools/list-follow-ups.d.ts

@@ -0,0 +1,200 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listFollowUpsInputSchema: z.ZodObject<{
+    page_size: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    incident_id: z.ZodOptional<z.ZodString>;
+    incident_mode: z.ZodOptional<z.ZodEnum<{
+        retrospective: "retrospective";
+        standard: "standard";
+        stream: "stream";
+        test: "test";
+        tutorial: "tutorial";
+    }>>;
+    assignee_team_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listFollowUpsOutputSchema: z.ZodObject<{
+    follow_ups: z.ZodArray<z.ZodObject<{
+        assignee: z.ZodOptional<z.ZodNullable<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>>>;
+        assignee_team: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$loose>>>;
+        category: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            name: z.ZodString;
+            rank: z.ZodNumber;
+        }, z.core.$loose>>>;
+        completed_at: z.ZodOptional<z.ZodString>;
+        created_at: z.ZodString;
+        creator: z.ZodObject<{
+            alert: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+            }, z.core.$loose>>;
+            api_key: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$loose>>;
+            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>>;
+            workflow: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+        description: z.ZodOptional<z.ZodString>;
+        external_issue_reference: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            issue_name: z.ZodString;
+            issue_permalink: z.ZodString;
+            provider: z.ZodUnion<[z.ZodEnum<{
+                asana: "asana";
+                azure_devops: "azure_devops";
+                click_up: "click_up";
+                freshservice: "freshservice";
+                github: "github";
+                gitlab: "gitlab";
+                jira: "jira";
+                jira_server: "jira_server";
+                linear: "linear";
+                notion: "notion";
+                salesforce: "salesforce";
+                service_now: "service_now";
+                shortcut: "shortcut";
+            }>, z.ZodString]>;
+        }, z.core.$loose>>>;
+        id: z.ZodString;
+        incident_id: z.ZodString;
+        labels: z.ZodArray<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            name: z.ZodString;
+            rank: z.ZodNumber;
+        }, z.core.$loose>>>;
+        status: z.ZodUnion<[z.ZodEnum<{
+            completed: "completed";
+            deleted: "deleted";
+            not_doing: "not_doing";
+            outstanding: "outstanding";
+        }>, z.ZodString]>;
+        title: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$loose>>;
+    pagination_meta: z.ZodObject<{
+        after: z.ZodOptional<z.ZodString>;
+        page_size: z.ZodNumber;
+    }, z.core.$loose>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function listFollowUpsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    page_size?: number | undefined;
+    after?: string | undefined;
+    incident_id?: string | undefined;
+    incident_mode?: "retrospective" | "standard" | "stream" | "test" | "tutorial" | undefined;
+    assignee_team_id?: string | undefined;
+}, {
+    [x: string]: unknown;
+    follow_ups: {
+        [x: string]: unknown;
+        assignee?: {
+            [x: string]: unknown;
+            email?: string | undefined;
+            id: string;
+            name: string;
+            role: string;
+            slack_user_id?: string | undefined;
+        } | null | undefined;
+        assignee_team?: {
+            [x: string]: unknown;
+            id: string;
+            name: string;
+        } | null | undefined;
+        category?: {
+            [x: string]: unknown;
+            description?: string | undefined;
+            id: string;
+            name: string;
+            rank: number;
+        } | null | undefined;
+        completed_at?: string | undefined;
+        created_at: string;
+        creator: {
+            [x: string]: unknown;
+            alert?: {
+                [x: string]: unknown;
+                id: string;
+                title: string;
+            } | undefined;
+            api_key?: {
+                [x: string]: unknown;
+                id: string;
+                name: string;
+            } | undefined;
+            user?: {
+                [x: string]: unknown;
+                email?: string | undefined;
+                id: string;
+                name: string;
+                role: string;
+                slack_user_id?: string | undefined;
+            } | undefined;
+            workflow?: {
+                [x: string]: unknown;
+                id: string;
+                name: string;
+            } | undefined;
+        };
+        description?: string | undefined;
+        external_issue_reference?: {
+            [x: string]: unknown;
+            issue_name: string;
+            issue_permalink: string;
+            provider: string;
+        } | null | undefined;
+        id: string;
+        incident_id: string;
+        labels: string[];
+        priority?: {
+            [x: string]: unknown;
+            description?: string | undefined;
+            id: string;
+            name: string;
+            rank: number;
+        } | null | undefined;
+        status: string;
+        title: string;
+        updated_at: string;
+    }[];
+    pagination_meta: {
+        [x: string]: unknown;
+        after?: string | undefined;
+        page_size: number;
+    };
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_list_follow_ups", unknown>;
+//# sourceMappingURL=list-follow-ups.d.ts.map

package/dist/providers/incident-io/tools/list-follow-ups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-follow-ups.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/list-follow-ups.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAMnC,CAAC;AAuFH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAwE,CAAC;AAE/G,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2IAyBrD"}

package/dist/providers/incident-io/tools/list-incident-alerts.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listIncidentAlertsInputSchema: z.ZodObject<{
+    page_size: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    alert_id: z.ZodOptional<z.ZodString>;
+    incident_id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const listIncidentAlertsOutputSchema: z.ZodObject<{
+    incident_alerts: z.ZodArray<z.ZodObject<{
+        alert: z.ZodObject<{
+            alert_group_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            alert_source_id: z.ZodString;
+            created_at: z.ZodString;
+            deduplication_key: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            resolved_at: z.ZodOptional<z.ZodString>;
+            source_url: z.ZodOptional<z.ZodString>;
+            status: z.ZodUnion<[z.ZodEnum<{
+                firing: "firing";
+                resolved: "resolved";
+            }>, z.ZodString]>;
+            title: z.ZodString;
+            updated_at: z.ZodString;
+        }, z.core.$loose>;
+        alert_route_id: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        incident: z.ZodObject<{
+            external_id: z.ZodNumber;
+            id: z.ZodString;
+            name: z.ZodString;
+            reference: z.ZodString;
+            status_category: z.ZodUnion<[z.ZodEnum<{
+                active: "active";
+                canceled: "canceled";
+                closed: "closed";
+                declined: "declined";
+                merged: "merged";
+                paused: "paused";
+                "post-incident": "post-incident";
+                triage: "triage";
+            }>, z.ZodString]>;
+            summary: z.ZodOptional<z.ZodString>;
+            visibility: z.ZodUnion<[z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>, z.ZodString]>;
+        }, z.core.$loose>;
+    }, z.core.$loose>>;
+    pagination_meta: z.ZodObject<{
+        after: z.ZodOptional<z.ZodString>;
+        page_size: z.ZodNumber;
+    }, z.core.$loose>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare function listIncidentAlertsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    page_size?: number | undefined;
+    after?: string | undefined;
+    alert_id?: string | undefined;
+    incident_id?: string | undefined;
+}, {
+    [x: string]: unknown;
+    incident_alerts: {
+        [x: string]: unknown;
+        alert: {
+            [x: string]: unknown;
+            alert_group_ids?: string[] | undefined;
+            alert_source_id: string;
+            created_at: string;
+            deduplication_key: string;
+            description?: string | undefined;
+            id: string;
+            resolved_at?: string | undefined;
+            source_url?: string | undefined;
+            status: string;
+            title: string;
+            updated_at: string;
+        };
+        alert_route_id?: string | undefined;
+        id: string;
+        incident: {
+            [x: string]: unknown;
+            external_id: number;
+            id: string;
+            name: string;
+            reference: string;
+            status_category: string;
+            summary?: string | undefined;
+            visibility: string;
+        };
+    }[];
+    pagination_meta: {
+        [x: string]: unknown;
+        after?: string | undefined;
+        page_size: number;
+    };
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_list_incident_alerts", unknown>;
+//# sourceMappingURL=list-incident-alerts.d.ts.map

package/dist/providers/incident-io/tools/list-incident-alerts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-incident-alerts.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/list-incident-alerts.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,6BAA6B;;;;;iBAO1B,CAAC;AA4CjB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAwE,CAAC;AAEpH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gJAwB1D"}

package/dist/providers/incident-io/tools/list-incident-participant-workloads.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listIncidentParticipantWorkloadsInputSchema: z.ZodObject<{
+    incident_id: z.ZodString;
+}, z.core.$loose>;
+export declare const listIncidentParticipantWorkloadsOutputSchema: z.ZodObject<{
+    incident_participant_workloads: z.ZodArray<z.ZodObject<{
+        archived_at: z.ZodOptional<z.ZodString>;
+        participant_type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+            collaborator: "collaborator";
+            observer: "observer";
+            responder: "responder";
+        }>, z.ZodString]>>;
+        user: 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>;
+        workload: z.ZodObject<{
+            minutes_spent_on_incident: z.ZodNumber;
+            minutes_spent_on_incident_in_late_hours: z.ZodNumber;
+            minutes_spent_on_incident_in_sleeping_hours: z.ZodNumber;
+            minutes_spent_on_incident_in_working_hours: z.ZodNumber;
+        }, z.core.$loose>;
+    }, z.core.$loose>>;
+    metadata: z.ZodObject<{
+        data_synced_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare function listIncidentParticipantWorkloadsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    incident_id: string;
+}, {
+    [x: string]: unknown;
+    incident_participant_workloads: {
+        [x: string]: unknown;
+        archived_at?: string | undefined;
+        participant_type?: string | undefined;
+        user: {
+            [x: string]: unknown;
+            email?: string | undefined;
+            id: string;
+            name: string;
+            role: string;
+            slack_user_id?: string | undefined;
+        };
+        workload: {
+            [x: string]: unknown;
+            minutes_spent_on_incident: number;
+            minutes_spent_on_incident_in_late_hours: number;
+            minutes_spent_on_incident_in_sleeping_hours: number;
+            minutes_spent_on_incident_in_working_hours: number;
+        };
+    }[];
+    metadata: {
+        [x: string]: unknown;
+        data_synced_at?: string | null | undefined;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_list_incident_participant_workloads", unknown>;
+//# sourceMappingURL=list-incident-participant-workloads.d.ts.map

package/dist/providers/incident-io/tools/list-incident-participant-workloads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-incident-participant-workloads.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/list-incident-participant-workloads.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,2CAA2C;;iBAAsD,CAAC;AAiC/G,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAEnF,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+JAwBxE"}

package/dist/providers/incident-io/tools/list-incident-participants.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listIncidentParticipantsInputSchema: z.ZodObject<{
+    incident_id: z.ZodString;
+}, z.core.$loose>;
+export declare const listIncidentParticipantsOutputSchema: z.ZodObject<{
+    incident_participants: z.ZodObject<{
+        active: z.ZodArray<z.ZodObject<{
+            participant_type: z.ZodUnion<[z.ZodEnum<{
+                collaborator: "collaborator";
+                observer: "observer";
+                responder: "responder";
+            }>, z.ZodString]>;
+            user: 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>>;
+        passive: z.ZodArray<z.ZodObject<{
+            participant_type: z.ZodUnion<[z.ZodEnum<{
+                collaborator: "collaborator";
+                observer: "observer";
+                responder: "responder";
+            }>, z.ZodString]>;
+            user: 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>;
+}, z.core.$loose>;
+export declare function listIncidentParticipantsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+    incident_id: string;
+}, {
+    [x: string]: unknown;
+    incident_participants: {
+        [x: string]: unknown;
+        active: {
+            [x: string]: unknown;
+            participant_type: string;
+            user: {
+                [x: string]: unknown;
+                email?: string | undefined;
+                id: string;
+                name: string;
+                role: string;
+                slack_user_id?: string | undefined;
+            };
+        }[];
+        passive: {
+            [x: string]: unknown;
+            participant_type: string;
+            user: {
+                [x: string]: unknown;
+                email?: string | undefined;
+                id: string;
+                name: string;
+                role: string;
+                slack_user_id?: string | undefined;
+            };
+        }[];
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_list_incident_participants", unknown>;
+//# sourceMappingURL=list-incident-participants.d.ts.map

package/dist/providers/incident-io/tools/list-incident-participants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-incident-participants.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/list-incident-participants.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,mCAAmC;;iBAAsD,CAAC;AA2CvG,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAE3E,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sJAqBhE"}

package/dist/providers/incident-io/tools/list-incident-roles.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listIncidentRolesInputSchema: z.ZodObject<{}, z.core.$loose>;
+export declare const listIncidentRolesOutputSchema: z.ZodObject<{
+    incident_roles: z.ZodArray<z.ZodObject<{
+        created_at: z.ZodString;
+        description: z.ZodString;
+        id: z.ZodString;
+        instructions: z.ZodString;
+        name: z.ZodString;
+        role_type: z.ZodUnion<[z.ZodEnum<{
+            custom: "custom";
+            lead: "lead";
+            reporter: "reporter";
+        }>, z.ZodString]>;
+        shortform: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare function listIncidentRolesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    [x: string]: unknown;
+}, {
+    [x: string]: unknown;
+    incident_roles: {
+        [x: string]: unknown;
+        created_at: string;
+        description: string;
+        id: string;
+        instructions: string;
+        name: string;
+        role_type: string;
+        shortform: string;
+        updated_at: string;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "incident_io_list_incident_roles", unknown>;
+//# sourceMappingURL=list-incident-roles.d.ts.map

package/dist/providers/incident-io/tools/list-incident-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-incident-roles.d.ts","sourceRoot":"","sources":["../../../../src/providers/incident-io/tools/list-incident-roles.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,4BAA4B,gCAA6B,CAAC;AAqBvE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;iBAAyB,CAAC;AAEpE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;+IAkBzD"}