@mastra/connect 0.2.0-alpha.2 → 0.3.0-alpha.0

package/dist/providers/github/tools/update-release.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateReleaseInputSchema: z.ZodObject<{
+    owner: z.ZodString;
+    repo: z.ZodString;
+    release_id: z.ZodNumber;
+    tag_name: z.ZodOptional<z.ZodString>;
+    target_commitish: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    body: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    draft: z.ZodOptional<z.ZodBoolean>;
+    prerelease: z.ZodOptional<z.ZodBoolean>;
+    make_latest: z.ZodOptional<z.ZodEnum<{
+        false: "false";
+        legacy: "legacy";
+        true: "true";
+    }>>;
+    discussion_category_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateReleaseOutputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    node_id: z.ZodString;
+    tag_name: z.ZodString;
+    target_commitish: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    draft: z.ZodBoolean;
+    prerelease: z.ZodBoolean;
+    created_at: z.ZodString;
+    published_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+    html_url: z.ZodString;
+    assets_url: z.ZodString;
+    upload_url: z.ZodString;
+    tarball_url: z.ZodOptional<z.ZodString>;
+    zipball_url: z.ZodOptional<z.ZodString>;
+    author: z.ZodObject<{
+        login: z.ZodString;
+        id: z.ZodNumber;
+        node_id: z.ZodString;
+        avatar_url: z.ZodString;
+        gravatar_id: z.ZodOptional<z.ZodString>;
+        url: z.ZodString;
+        html_url: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$loose>;
+    assets: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strip>;
+export declare function updateReleaseTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    owner: string;
+    repo: string;
+    release_id: number;
+    tag_name?: string | undefined;
+    target_commitish?: string | undefined;
+    name?: string | null | undefined;
+    body?: string | null | undefined;
+    draft?: boolean | undefined;
+    prerelease?: boolean | undefined;
+    make_latest?: "false" | "legacy" | "true" | undefined;
+    discussion_category_name?: string | undefined;
+}, {
+    id: number;
+    node_id: string;
+    tag_name: string;
+    target_commitish: string;
+    name?: string | undefined;
+    body?: string | undefined;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at?: string | undefined;
+    updated_at?: string | undefined;
+    url: string;
+    html_url: string;
+    assets_url: string;
+    upload_url: string;
+    tarball_url?: string | undefined;
+    zipball_url?: string | undefined;
+    author: {
+        [x: string]: unknown;
+        login: string;
+        id: number;
+        node_id: string;
+        avatar_url: string;
+        gravatar_id?: string | undefined;
+        url: string;
+        html_url: string;
+        type: string;
+    };
+    assets: {
+        [x: string]: unknown;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "github_update_release", unknown>;
+//# sourceMappingURL=update-release.d.ts.map

package/dist/providers/github/tools/update-release.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-release.d.ts","sourceRoot":"","sources":["../../../../src/providers/github/tools/update-release.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;iBAqBnC,CAAC;AAqCH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BpC,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qIAoFrD"}

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

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

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

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

package/dist/providers/google-calendar/index.d.ts

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

package/dist/providers/google-calendar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/google-calendar/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,sBAAsB,EAAE,oBAIpC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/providers/google-calendar/tools/add-attendee.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const addAttendeeInputSchema: z.ZodObject<{
+    calendarId: z.ZodString;
+    eventId: z.ZodString;
+    email: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    responseStatus: z.ZodOptional<z.ZodEnum<{
+        accepted: "accepted";
+        declined: "declined";
+        needsAction: "needsAction";
+        tentative: "tentative";
+    }>>;
+    comment: z.ZodOptional<z.ZodString>;
+    additionalGuests: z.ZodOptional<z.ZodNumber>;
+    resource: z.ZodOptional<z.ZodBoolean>;
+    sendUpdates: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        externalOnly: "externalOnly";
+        none: "none";
+    }>>;
+}, z.core.$strip>;
+export declare const addAttendeeOutputSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    attendees: z.ZodArray<z.ZodObject<{
+        email: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        optional: z.ZodOptional<z.ZodBoolean>;
+        responseStatus: z.ZodOptional<z.ZodString>;
+        comment: z.ZodOptional<z.ZodString>;
+        additionalGuests: z.ZodOptional<z.ZodNumber>;
+        resource: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function addAttendeeTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    calendarId: string;
+    eventId: string;
+    email: string;
+    displayName?: string | undefined;
+    optional?: boolean | undefined;
+    responseStatus?: "accepted" | "declined" | "needsAction" | "tentative" | undefined;
+    comment?: string | undefined;
+    additionalGuests?: number | undefined;
+    resource?: boolean | undefined;
+    sendUpdates?: "all" | "externalOnly" | "none" | undefined;
+}, {
+    eventId: string;
+    attendees: {
+        email: string;
+        displayName?: string | undefined;
+        optional?: boolean | undefined;
+        responseStatus?: string | undefined;
+        comment?: string | undefined;
+        additionalGuests?: number | undefined;
+        resource?: boolean | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_add_attendee", unknown>;
+//# sourceMappingURL=add-attendee.d.ts.map

package/dist/providers/google-calendar/tools/add-attendee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-attendee.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/add-attendee.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;iBA8B+B,CAAC;AAiBnE,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAiBmC,CAAC;AAExE,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;4IAqEnD"}

package/dist/providers/google-calendar/tools/clear-calendar.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const clearCalendarInputSchema: z.ZodObject<{
+    calendarId: z.ZodOptional<z.ZodLiteral<"primary">>;
+}, z.core.$strip>;
+export declare const clearCalendarOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    calendarId: z.ZodString;
+}, z.core.$strip>;
+export declare function clearCalendarTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    calendarId?: "primary" | undefined;
+}, {
+    success: boolean;
+    calendarId: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_clear_calendar", unknown>;
+//# sourceMappingURL=clear-calendar.d.ts.map

package/dist/providers/google-calendar/tools/clear-calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear-calendar.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/clear-calendar.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,wBAAwB;;iBASsB,CAAC;AAE5D,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;8IAsBrD"}

package/dist/providers/google-calendar/tools/create-acl-rule.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createAclRuleInputSchema: z.ZodObject<{
+    calendarId: z.ZodString;
+    role: z.ZodEnum<{
+        freeBusyReader: "freeBusyReader";
+        none: "none";
+        owner: "owner";
+        reader: "reader";
+        writer: "writer";
+        writerWithoutPrivateAccess: "writerWithoutPrivateAccess";
+    }>;
+    scope: z.ZodObject<{
+        type: z.ZodEnum<{
+            default: "default";
+            domain: "domain";
+            group: "group";
+            user: "user";
+        }>;
+        value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    sendNotifications: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const createAclRuleOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    etag: z.ZodString;
+    kind: z.ZodString;
+    role: z.ZodString;
+    scope: z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare function createAclRuleTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    calendarId: string;
+    role: "freeBusyReader" | "none" | "owner" | "reader" | "writer" | "writerWithoutPrivateAccess";
+    scope: {
+        type: "default" | "domain" | "group" | "user";
+        value?: string | undefined;
+    };
+    sendNotifications?: boolean | undefined;
+}, {
+    id: string;
+    etag: string;
+    kind: string;
+    role: string;
+    scope: {
+        type: string;
+        value?: string | undefined;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_create_acl_rule", unknown>;
+//# sourceMappingURL=create-acl-rule.d.ts.map

package/dist/providers/google-calendar/tools/create-acl-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-acl-rule.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/create-acl-rule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;iBAsBgC,CAAC;AAatE,eAAO,MAAM,yBAAyB;;;;;;;;;iBAae,CAAC;AAEtD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;+IAiDrD"}

package/dist/providers/google-calendar/tools/create-all-day-event.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createAllDayEventInputSchema: z.ZodObject<{
+    calendarId: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodString;
+    endDate: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const createAllDayEventOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+    htmlLink: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createAllDayEventTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    calendarId?: string | undefined;
+    summary?: string | undefined;
+    startDate: string;
+    endDate: string;
+    description?: string | undefined;
+    location?: string | undefined;
+}, {
+    id: string;
+    summary?: string | undefined;
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+    htmlLink?: string | undefined;
+    status?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_create_all_day_event", unknown>;
+//# sourceMappingURL=create-all-day-event.d.ts.map

package/dist/providers/google-calendar/tools/create-all-day-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-all-day-event.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/create-all-day-event.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;;;;;;iBASgB,CAAC;AAmB1D,eAAO,MAAM,6BAA6B;;;;;;;iBASI,CAAC;AAE/C,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;oJAuCzD"}

package/dist/providers/google-calendar/tools/create-calendar.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createCalendarInputSchema: z.ZodObject<{
+    summary: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    time_zone: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const createCalendarOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    summary: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    time_zone: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createCalendarTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    summary: string;
+    description?: string | undefined;
+    location?: string | undefined;
+    time_zone?: string | undefined;
+}, {
+    id: string;
+    summary: string;
+    description?: string | undefined;
+    location?: string | undefined;
+    time_zone?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_create_calendar", unknown>;
+//# sourceMappingURL=create-calendar.d.ts.map

package/dist/providers/google-calendar/tools/create-calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-calendar.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/create-calendar.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;;;iBAO6B,CAAC;AAUpE,eAAO,MAAM,0BAA0B;;;;;;iBAQc,CAAC;AAEtD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;+IA+BtD"}

package/dist/providers/google-calendar/tools/create-event.d.ts

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createEventInputSchema: z.ZodObject<{
+    calendarId: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    start: z.ZodObject<{
+        dateTime: z.ZodOptional<z.ZodString>;
+        date: z.ZodOptional<z.ZodString>;
+        timeZone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    end: z.ZodObject<{
+        dateTime: z.ZodOptional<z.ZodString>;
+        date: z.ZodOptional<z.ZodString>;
+        timeZone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    attendees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        email: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        responseStatus: z.ZodOptional<z.ZodEnum<{
+            accepted: "accepted";
+            declined: "declined";
+            needsAction: "needsAction";
+            tentative: "tentative";
+        }>>;
+    }, z.core.$strip>>>;
+    reminders: z.ZodOptional<z.ZodObject<{
+        useDefault: z.ZodOptional<z.ZodBoolean>;
+        overrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            method: z.ZodEnum<{
+                email: "email";
+                popup: "popup";
+            }>;
+            minutes: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    recurrence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const createEventOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    status: z.ZodString;
+    htmlLink: z.ZodString;
+    created: z.ZodString;
+    updated: z.ZodString;
+    start: z.ZodOptional<z.ZodObject<{
+        dateTime: z.ZodOptional<z.ZodString>;
+        date: z.ZodOptional<z.ZodString>;
+        timeZone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    end: z.ZodOptional<z.ZodObject<{
+        dateTime: z.ZodOptional<z.ZodString>;
+        date: z.ZodOptional<z.ZodString>;
+        timeZone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    iCalUID: z.ZodString;
+    organizer: z.ZodOptional<z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function createEventTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    calendarId: string;
+    summary?: string | undefined;
+    description?: string | undefined;
+    location?: string | undefined;
+    start: {
+        dateTime?: string | undefined;
+        date?: string | undefined;
+        timeZone?: string | undefined;
+    };
+    end: {
+        dateTime?: string | undefined;
+        date?: string | undefined;
+        timeZone?: string | undefined;
+    };
+    attendees?: {
+        email: string;
+        displayName?: string | undefined;
+        responseStatus?: "accepted" | "declined" | "needsAction" | "tentative" | undefined;
+    }[] | undefined;
+    reminders?: {
+        useDefault?: boolean | undefined;
+        overrides?: {
+            method: "email" | "popup";
+            minutes: number;
+        }[] | undefined;
+    } | undefined;
+    recurrence?: string[] | undefined;
+}, {
+    id: string;
+    summary?: string | undefined;
+    description?: string | undefined;
+    location?: string | undefined;
+    status: string;
+    htmlLink: string;
+    created: string;
+    updated: string;
+    start?: {
+        dateTime?: string | undefined;
+        date?: string | undefined;
+        timeZone?: string | undefined;
+    } | undefined;
+    end?: {
+        dateTime?: string | undefined;
+        date?: string | undefined;
+        timeZone?: string | undefined;
+    } | undefined;
+    iCalUID: string;
+    organizer?: {
+        email?: string | undefined;
+        displayName?: string | undefined;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_create_event", unknown>;
+//# sourceMappingURL=create-event.d.ts.map

package/dist/providers/google-calendar/tools/create-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-event.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/create-event.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AA0BxE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0B/B,CAAC;AAaL,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;iBAeoB,CAAC;AA4BzD,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4IA+DnD"}

package/dist/providers/google-calendar/tools/create-recurring-event.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createRecurringEventInputSchema: z.ZodObject<{
+    calendarId: z.ZodOptional<z.ZodString>;
+    summary: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    start: z.ZodString;
+    end: z.ZodString;
+    rrule: z.ZodString;
+    timezone: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const createRecurringEventOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    htmlLink: z.ZodString;
+    summary: z.ZodString;
+    start: z.ZodString;
+    end: z.ZodString;
+    recurrence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    status: z.ZodString;
+}, z.core.$strip>;
+export declare function createRecurringEventTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    calendarId?: string | undefined;
+    summary: string;
+    description?: string | undefined;
+    location?: string | undefined;
+    start: string;
+    end: string;
+    rrule: string;
+    timezone?: string | undefined;
+}, {
+    id: string;
+    htmlLink: string;
+    summary: string;
+    start: string;
+    end: string;
+    recurrence?: string[] | undefined;
+    status: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_create_recurring_event", unknown>;
+//# sourceMappingURL=create-recurring-event.d.ts.map

package/dist/providers/google-calendar/tools/create-recurring-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-recurring-event.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/create-recurring-event.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,+BAA+B;;;;;;;;;iBAqBoB,CAAC;AAoBjE,eAAO,MAAM,gCAAgC;;;;;;;;iBAaa,CAAC;AAE3D,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;sJA6D5D"}

package/dist/providers/google-calendar/tools/delete-acl-rule.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteAclRuleInputSchema: z.ZodObject<{
+    calendarId: z.ZodString;
+    ruleId: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteAclRuleOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    calendarId: z.ZodString;
+    ruleId: z.ZodString;
+}, z.core.$strip>;
+export declare function deleteAclRuleTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    calendarId: string;
+    ruleId: string;
+}, {
+    success: boolean;
+    calendarId: string;
+    ruleId: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_delete_acl_rule", unknown>;
+//# sourceMappingURL=delete-acl-rule.d.ts.map

package/dist/providers/google-calendar/tools/delete-acl-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-acl-rule.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/delete-acl-rule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,wBAAwB;;;iBAOyB,CAAC;AAE/D,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;+IAqBrD"}

package/dist/providers/google-calendar/tools/delete-calendar.d.ts

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

package/dist/providers/google-calendar/tools/delete-calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-calendar.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/delete-calendar.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;iBAIc,CAAC;AAErD,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;+IAoBtD"}

package/dist/providers/google-calendar/tools/delete-event.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteEventInputSchema: z.ZodObject<{
+    calendarId: z.ZodString;
+    eventId: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteEventOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare function deleteEventTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    calendarId: string;
+    eventId: string;
+}, {
+    success: boolean;
+    message: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_delete_event", unknown>;
+//# sourceMappingURL=delete-event.d.ts.map

package/dist/providers/google-calendar/tools/delete-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-event.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/delete-event.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;iBAOoB,CAAC;AAExD,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;4IAoBnD"}

package/dist/providers/google-calendar/tools/find-free-slots.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const findFreeSlotsInputSchema: z.ZodObject<{
+    calendarIds: z.ZodArray<z.ZodString>;
+    timeMin: z.ZodString;
+    timeMax: z.ZodString;
+    timeZone: z.ZodOptional<z.ZodString>;
+    durationMinutes: z.ZodNumber;
+}, z.core.$strip>;
+export declare const findFreeSlotsOutputSchema: z.ZodObject<{
+    freeSlots: z.ZodArray<z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+        durationMinutes: z.ZodNumber;
+    }, z.core.$strip>>;
+    calendarsChecked: z.ZodNumber;
+}, z.core.$strip>;
+export declare function findFreeSlotsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    calendarIds: string[];
+    timeMin: string;
+    timeMax: string;
+    timeZone?: string | undefined;
+    durationMinutes: number;
+}, {
+    freeSlots: {
+        start: string;
+        end: string;
+        durationMinutes: number;
+    }[];
+    calendarsChecked: number;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_find_free_slots", unknown>;
+//# sourceMappingURL=find-free-slots.d.ts.map

package/dist/providers/google-calendar/tools/find-free-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-free-slots.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/find-free-slots.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAMxE,eAAO,MAAM,wBAAwB;;;;;;iBAiB6B,CAAC;AAQnE,eAAO,MAAM,yBAAyB;;;;;;;iBAGpC,CAAC;AA6BH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;+IAiLrD"}

package/dist/providers/google-calendar/tools/get-acl-rule.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getAclRuleInputSchema: z.ZodObject<{
+    calendarId: z.ZodString;
+    ruleId: z.ZodString;
+}, z.core.$strip>;
+export declare const getAclRuleOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodString;
+    scope: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    kind: z.ZodOptional<z.ZodString>;
+    etag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function getAclRuleTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    calendarId: string;
+    ruleId: string;
+}, {
+    id: string;
+    role: string;
+    scope?: {
+        type: string;
+        value?: string | undefined;
+    } | undefined;
+    kind?: string | undefined;
+    etag?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_calendar_get_acl_rule", unknown>;
+//# sourceMappingURL=get-acl-rule.d.ts.map

package/dist/providers/google-calendar/tools/get-acl-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-acl-rule.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-calendar/tools/get-acl-rule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;iBAO4C,CAAC;AAe/E,eAAO,MAAM,sBAAsB;;;;;;;;;iBAqBwB,CAAC;AAE5D,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;4IAqClD"}