@mastra/connect 0.5.1-alpha.0 → 0.6.0-alpha.1

package/dist/providers/google-drive/tools/list-drives.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listDrivesInputSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    query: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listDrivesOutputSchema: z.ZodObject<{
+    drives: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        colorRgb: z.ZodOptional<z.ZodString>;
+        backgroundImageLink: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
+        capabilities: z.ZodOptional<z.ZodObject<{
+            canAddChildren: z.ZodOptional<z.ZodBoolean>;
+            canChangeCopyRequiresWriterPermissionRestriction: z.ZodOptional<z.ZodBoolean>;
+            canChangeDomainUsersOnlyRestriction: z.ZodOptional<z.ZodBoolean>;
+            canChangeDriveBackground: z.ZodOptional<z.ZodBoolean>;
+            canChangeDriveMembersOnlyRestriction: z.ZodOptional<z.ZodBoolean>;
+            canComment: z.ZodOptional<z.ZodBoolean>;
+            canCopy: z.ZodOptional<z.ZodBoolean>;
+            canDeleteChildren: z.ZodOptional<z.ZodBoolean>;
+            canDeleteDrive: z.ZodOptional<z.ZodBoolean>;
+            canDownload: z.ZodOptional<z.ZodBoolean>;
+            canEdit: z.ZodOptional<z.ZodBoolean>;
+            canListChildren: z.ZodOptional<z.ZodBoolean>;
+            canManageMembers: z.ZodOptional<z.ZodBoolean>;
+            canReadRevisions: z.ZodOptional<z.ZodBoolean>;
+            canRename: z.ZodOptional<z.ZodBoolean>;
+            canRenameDrive: z.ZodOptional<z.ZodBoolean>;
+            canResetDriveRestrictions: z.ZodOptional<z.ZodBoolean>;
+            canShare: z.ZodOptional<z.ZodBoolean>;
+            canTrashChildren: z.ZodOptional<z.ZodBoolean>;
+            canUntrashChildren: z.ZodOptional<z.ZodBoolean>;
+            canViewItemCounts: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        restrictions: z.ZodOptional<z.ZodObject<{
+            adminManagedRestrictions: z.ZodOptional<z.ZodBoolean>;
+            copyRequiresWriterPermission: z.ZodOptional<z.ZodBoolean>;
+            domainUsersOnly: z.ZodOptional<z.ZodBoolean>;
+            driveMembersOnly: z.ZodOptional<z.ZodBoolean>;
+            sharingFoldersRequiresOrganizerPermission: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listDrivesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+    limit?: number | undefined;
+    query?: string | undefined;
+}, {
+    drives: {
+        id: string;
+        name: string;
+        colorRgb?: string | undefined;
+        backgroundImageLink?: string | undefined;
+        kind?: string | undefined;
+        hidden?: boolean | undefined;
+        capabilities?: {
+            canAddChildren?: boolean | undefined;
+            canChangeCopyRequiresWriterPermissionRestriction?: boolean | undefined;
+            canChangeDomainUsersOnlyRestriction?: boolean | undefined;
+            canChangeDriveBackground?: boolean | undefined;
+            canChangeDriveMembersOnlyRestriction?: boolean | undefined;
+            canComment?: boolean | undefined;
+            canCopy?: boolean | undefined;
+            canDeleteChildren?: boolean | undefined;
+            canDeleteDrive?: boolean | undefined;
+            canDownload?: boolean | undefined;
+            canEdit?: boolean | undefined;
+            canListChildren?: boolean | undefined;
+            canManageMembers?: boolean | undefined;
+            canReadRevisions?: boolean | undefined;
+            canRename?: boolean | undefined;
+            canRenameDrive?: boolean | undefined;
+            canResetDriveRestrictions?: boolean | undefined;
+            canShare?: boolean | undefined;
+            canTrashChildren?: boolean | undefined;
+            canUntrashChildren?: boolean | undefined;
+            canViewItemCounts?: boolean | undefined;
+        } | undefined;
+        restrictions?: {
+            adminManagedRestrictions?: boolean | undefined;
+            copyRequiresWriterPermission?: boolean | undefined;
+            domainUsersOnly?: boolean | undefined;
+            driveMembersOnly?: boolean | undefined;
+            sharingFoldersRequiresOrganizerPermission?: boolean | undefined;
+        } | undefined;
+    }[];
+    nextPageToken?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_drive_list_drives", unknown>;
+//# sourceMappingURL=list-drives.d.ts.map

package/dist/providers/google-drive/tools/list-drives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-drives.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-drive/tools/list-drives.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAC;AA6CH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMjC,CAAC;AAEH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wIAsDlD"}

package/dist/providers/google-drive/tools/list-files-non-unified.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listFilesNonUnifiedInputSchema: z.ZodObject<{
+    folderId: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    includeSharedDrives: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const listFilesNonUnifiedOutputSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        isFolder: z.ZodBoolean;
+        parentId: z.ZodOptional<z.ZodString>;
+        createdTime: z.ZodOptional<z.ZodString>;
+        modifiedTime: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+        webViewLink: z.ZodOptional<z.ZodString>;
+        thumbnailLink: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodOptional<z.ZodString>;
+    totalCount: z.ZodNumber;
+}, z.core.$strip>;
+export declare function listFilesNonUnifiedTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    folderId?: string | undefined;
+    cursor?: string | undefined;
+    limit?: number | undefined;
+    includeSharedDrives?: boolean | undefined;
+}, {
+    files: {
+        id: string;
+        name: string;
+        mimeType: string;
+        isFolder: boolean;
+        parentId?: string | undefined;
+        createdTime?: string | undefined;
+        modifiedTime?: string | undefined;
+        size?: number | undefined;
+        webViewLink?: string | undefined;
+        thumbnailLink?: string | undefined;
+    }[];
+    nextPageToken?: string | undefined;
+    totalCount: number;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_drive_list_files_non_unified", unknown>;
+//# sourceMappingURL=list-files-non-unified.d.ts.map

package/dist/providers/google-drive/tools/list-files-non-unified.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-files-non-unified.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-drive/tools/list-files-non-unified.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,8BAA8B;;;;;iBAKzC,CAAC;AAeH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;iBAI1C,CAAC;AAEH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;mJAmE3D"}

package/dist/providers/google-drive/tools/list-permissions.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listPermissionsInputSchema: z.ZodObject<{
+    fileId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const listPermissionsOutputSchema: z.ZodObject<{
+    permissions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        role: z.ZodString;
+        emailAddress: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        domain: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listPermissionsTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    fileId: string;
+    cursor?: string | undefined;
+    pageSize?: number | undefined;
+}, {
+    permissions: {
+        id: string;
+        type: string;
+        role: string;
+        emailAddress?: string | undefined;
+        displayName?: string | undefined;
+        domain?: string | undefined;
+    }[];
+    nextPageToken?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_drive_list_permissions", unknown>;
+//# sourceMappingURL=list-permissions.d.ts.map

package/dist/providers/google-drive/tools/list-permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-permissions.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-drive/tools/list-permissions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;;;iBAWrC,CAAC;AAWH,eAAO,MAAM,2BAA2B;;;;;;;;;;iBAGtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;6IA4CvD"}

package/dist/providers/google-drive/tools/move-file.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const moveFileInputSchema: z.ZodObject<{
+    fileId: z.ZodString;
+    fromFolderId: z.ZodString;
+    toFolderId: z.ZodString;
+}, z.core.$strip>;
+export declare const moveFileOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodString>;
+    parents: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare function moveFileTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    fileId: string;
+    fromFolderId: string;
+    toFolderId: string;
+}, {
+    id: string;
+    name?: string | undefined;
+    mimeType?: string | undefined;
+    parents: string[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_drive_move_file", unknown>;
+//# sourceMappingURL=move-file.d.ts.map

package/dist/providers/google-drive/tools/move-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-file.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-drive/tools/move-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,mBAAmB;;;;iBAM9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;iBAK/B,CAAC;AAEH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa;;;;;;;;;sIAmChD"}

package/dist/providers/google-drive/tools/unhide-shared-drive.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const unhideSharedDriveInputSchema: z.ZodObject<{
+    driveId: z.ZodString;
+}, z.core.$strip>;
+export declare const unhideSharedDriveOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    createdTime: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function unhideSharedDriveTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    driveId: string;
+}, {
+    id: string;
+    name?: string | undefined;
+    hidden?: boolean | undefined;
+    createdTime?: string | undefined;
+    kind?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_drive_unhide_shared_drive", unknown>;
+//# sourceMappingURL=unhide-shared-drive.d.ts.map

package/dist/providers/google-drive/tools/unhide-shared-drive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unhide-shared-drive.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-drive/tools/unhide-shared-drive.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;iBAMxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;gJA+BzD"}

package/dist/providers/google-drive/tools/update-comment.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateCommentInputSchema: z.ZodObject<{
+    fileId: z.ZodString;
+    commentId: z.ZodString;
+    content: z.ZodString;
+    resolved: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updateCommentOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    htmlContent: z.ZodString;
+    createdTime: z.ZodString;
+    modifiedTime: z.ZodString;
+    author: z.ZodObject<{
+        displayName: z.ZodString;
+        kind: z.ZodString;
+        me: z.ZodBoolean;
+        photoLink: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    deleted: z.ZodBoolean;
+    resolved: z.ZodOptional<z.ZodBoolean>;
+    replies: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare function updateCommentTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    fileId: string;
+    commentId: string;
+    content: string;
+    resolved?: boolean | undefined;
+}, {
+    id: string;
+    content: string;
+    htmlContent: string;
+    createdTime: string;
+    modifiedTime: string;
+    author: {
+        displayName: string;
+        kind: string;
+        me: boolean;
+        photoLink?: string | undefined;
+    };
+    deleted: boolean;
+    resolved?: boolean | undefined;
+    replies?: Record<string, never>[] | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_drive_update_comment", unknown>;
+//# sourceMappingURL=update-comment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-comment.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-drive/tools/update-comment.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,wBAAwB;;;;;iBAOnC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;iBAepC,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;2IA6CrD"}

package/dist/providers/google-drive/tools/update-file.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateFileInputSchema: z.ZodObject<{
+    fileId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodString>;
+    starred: z.ZodOptional<z.ZodBoolean>;
+    trashed: z.ZodOptional<z.ZodBoolean>;
+    parents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    appProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const updateFileOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    mimeType: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    starred: z.ZodBoolean;
+    trashed: z.ZodBoolean;
+    parents: z.ZodArray<z.ZodString>;
+    createdTime: z.ZodString;
+    modifiedTime: z.ZodString;
+    size: z.ZodOptional<z.ZodString>;
+    webViewLink: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function updateFileTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    fileId: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    mimeType?: string | undefined;
+    starred?: boolean | undefined;
+    trashed?: boolean | undefined;
+    parents?: string[] | undefined;
+    appProperties?: Record<string, string> | undefined;
+    properties?: Record<string, string> | undefined;
+}, {
+    id: string;
+    name: string;
+    mimeType: string;
+    description?: string | undefined;
+    starred: boolean;
+    trashed: boolean;
+    parents: string[];
+    createdTime: string;
+    modifiedTime: string;
+    size?: string | undefined;
+    webViewLink?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_drive_update_file", unknown>;
+//# sourceMappingURL=update-file.d.ts.map

package/dist/providers/google-drive/tools/update-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-file.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-drive/tools/update-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAUhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;iBAYjC,CAAC;AAEH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;wIAgDlD"}

package/dist/providers/google-drive/tools/update-permission.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updatePermissionInputSchema: z.ZodObject<{
+    fileId: z.ZodString;
+    permissionId: z.ZodString;
+    role: z.ZodEnum<{
+        commenter: "commenter";
+        fileOrganizer: "fileOrganizer";
+        organizer: "organizer";
+        owner: "owner";
+        reader: "reader";
+        writer: "writer";
+    }>;
+}, z.core.$strip>;
+export declare const updatePermissionOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodOptional<z.ZodString>;
+    role: z.ZodString;
+    emailAddress: z.ZodOptional<z.ZodString>;
+    domain: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    allowFileDiscovery: z.ZodOptional<z.ZodBoolean>;
+    kind: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function updatePermissionTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    fileId: string;
+    permissionId: string;
+    role: "commenter" | "fileOrganizer" | "organizer" | "owner" | "reader" | "writer";
+}, {
+    id: string;
+    type?: string | undefined;
+    role: string;
+    emailAddress?: string | undefined;
+    domain?: string | undefined;
+    displayName?: string | undefined;
+    allowFileDiscovery?: boolean | undefined;
+    kind?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_drive_update_permission", unknown>;
+//# sourceMappingURL=update-permission.d.ts.map

package/dist/providers/google-drive/tools/update-permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-permission.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-drive/tools/update-permission.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,2BAA2B;;;;;;;;;;;iBAMtC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;iBASvC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;8IAsCxD"}

package/dist/providers/google-drive/tools/update-shared-drive.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateSharedDriveInputSchema: z.ZodObject<{
+    driveId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    colorRgb: z.ZodOptional<z.ZodString>;
+    restrictions: z.ZodOptional<z.ZodObject<{
+        adminManagedRestrictions: z.ZodOptional<z.ZodBoolean>;
+        copyRequiresWriterPermission: z.ZodOptional<z.ZodBoolean>;
+        domainUsersOnly: z.ZodOptional<z.ZodBoolean>;
+        driveMembersOnly: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const updateSharedDriveOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    colorRgb: z.ZodOptional<z.ZodString>;
+    kind: z.ZodString;
+    createdTime: z.ZodOptional<z.ZodString>;
+    restrictions: z.ZodOptional<z.ZodObject<{
+        adminManagedRestrictions: z.ZodOptional<z.ZodBoolean>;
+        copyRequiresWriterPermission: z.ZodOptional<z.ZodBoolean>;
+        domainUsersOnly: z.ZodOptional<z.ZodBoolean>;
+        driveMembersOnly: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function updateSharedDriveTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    driveId: string;
+    name?: string | undefined;
+    colorRgb?: string | undefined;
+    restrictions?: {
+        adminManagedRestrictions?: boolean | undefined;
+        copyRequiresWriterPermission?: boolean | undefined;
+        domainUsersOnly?: boolean | undefined;
+        driveMembersOnly?: boolean | undefined;
+    } | undefined;
+}, {
+    id: string;
+    name?: string | undefined;
+    colorRgb?: string | undefined;
+    kind: string;
+    createdTime?: string | undefined;
+    restrictions?: {
+        adminManagedRestrictions?: boolean | undefined;
+        copyRequiresWriterPermission?: boolean | undefined;
+        domainUsersOnly?: boolean | undefined;
+        driveMembersOnly?: boolean | undefined;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_drive_update_shared_drive", unknown>;
+//# sourceMappingURL=update-shared-drive.d.ts.map

package/dist/providers/google-drive/tools/update-shared-drive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-shared-drive.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-drive/tools/update-shared-drive.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;;;;;;;;;iBAgBvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;iBAcxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;gJAuEzD"}

package/dist/providers/google-drive/tools/upload-document.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const uploadDocumentInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    content: z.ZodString;
+    mimeType: z.ZodString;
+    isBase64: z.ZodOptional<z.ZodBoolean>;
+    folderId: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const uploadDocumentOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    mimeType: z.ZodString;
+    webViewLink: z.ZodOptional<z.ZodString>;
+    webContentLink: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function uploadDocumentTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    name: string;
+    content: string;
+    mimeType: string;
+    isBase64?: boolean | undefined;
+    folderId?: string | undefined;
+    description?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    mimeType: string;
+    webViewLink?: string | undefined;
+    webContentLink?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_drive_upload_document", unknown>;
+//# sourceMappingURL=upload-document.d.ts.map

package/dist/providers/google-drive/tools/upload-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-document.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-drive/tools/upload-document.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;;;;;iBAYpC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;iBAMrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;4IAyGtD"}

package/dist/providers/google-drive/tools.d.ts

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

package/dist/providers/google-drive/tools.d.ts.map

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

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

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

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

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

package/dist/providers/google-sheet/tools/append-values-to-spreadsheet.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const appendValuesToSpreadsheetInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    range: z.ZodString;
+    values: z.ZodArray<z.ZodAny>;
+    valueInputOption: z.ZodOptional<z.ZodString>;
+    insertDataOption: z.ZodOptional<z.ZodString>;
+    majorDimension: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const appendValuesToSpreadsheetOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    tableRange: z.ZodString;
+    updatedRange: z.ZodString;
+    updatedRows: z.ZodNumber;
+    updatedColumns: z.ZodNumber;
+    updatedCells: z.ZodNumber;
+}, z.core.$strip>;
+export declare function appendValuesToSpreadsheetTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    range: string;
+    values: any[];
+    valueInputOption?: string | undefined;
+    insertDataOption?: string | undefined;
+    majorDimension?: string | undefined;
+}, {
+    spreadsheetId: string;
+    tableRange: string;
+    updatedRange: string;
+    updatedRows: number;
+    updatedColumns: number;
+    updatedCells: number;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_append_values_to_spreadsheet", unknown>;
+//# sourceMappingURL=append-values-to-spreadsheet.d.ts.map

package/dist/providers/google-sheet/tools/append-values-to-spreadsheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-values-to-spreadsheet.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/append-values-to-spreadsheet.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,oCAAoC;;;;;;;iBA4B/C,CAAC;AAEH,eAAO,MAAM,qCAAqC;;;;;;;iBAOhD,CAAC;AAEH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;yJA8CjE"}

package/dist/providers/google-sheet/tools/batch-clear-values-by-data-filter.d.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const batchClearValuesByDataFilterInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    dataFilters: z.ZodArray<z.ZodObject<{
+        a1Range: z.ZodOptional<z.ZodString>;
+        gridRange: z.ZodOptional<z.ZodObject<{
+            sheetId: z.ZodNumber;
+            startRowIndex: z.ZodOptional<z.ZodNumber>;
+            endRowIndex: z.ZodOptional<z.ZodNumber>;
+            startColumnIndex: z.ZodOptional<z.ZodNumber>;
+            endColumnIndex: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        developerMetadataLookup: z.ZodOptional<z.ZodObject<{
+            metadataId: z.ZodOptional<z.ZodNumber>;
+            metadataKey: z.ZodOptional<z.ZodString>;
+            metadataValue: z.ZodOptional<z.ZodString>;
+            locationMatchingStrategy: z.ZodOptional<z.ZodEnum<{
+                EXACT_LOCATION: "EXACT_LOCATION";
+                INTERSECTING_LOCATION: "INTERSECTING_LOCATION";
+            }>>;
+            location: z.ZodOptional<z.ZodObject<{
+                locationType: z.ZodOptional<z.ZodEnum<{
+                    COLUMN: "COLUMN";
+                    ROW: "ROW";
+                    SHEET: "SHEET";
+                    SPREADSHEET: "SPREADSHEET";
+                }>>;
+                dimensionRange: z.ZodOptional<z.ZodObject<{
+                    sheetId: z.ZodNumber;
+                    dimension: z.ZodEnum<{
+                        COLUMNS: "COLUMNS";
+                        ROWS: "ROWS";
+                    }>;
+                    startIndex: z.ZodOptional<z.ZodNumber>;
+                    endIndex: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                DOCUMENT: "DOCUMENT";
+                PROJECT: "PROJECT";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const batchClearValuesByDataFilterOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    clearedRanges: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare function batchClearValuesByDataFilterTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    dataFilters: {
+        a1Range?: string | undefined;
+        gridRange?: {
+            sheetId: number;
+            startRowIndex?: number | undefined;
+            endRowIndex?: number | undefined;
+            startColumnIndex?: number | undefined;
+            endColumnIndex?: number | undefined;
+        } | undefined;
+        developerMetadataLookup?: {
+            metadataId?: number | undefined;
+            metadataKey?: string | undefined;
+            metadataValue?: string | undefined;
+            locationMatchingStrategy?: "EXACT_LOCATION" | "INTERSECTING_LOCATION" | undefined;
+            location?: {
+                locationType?: "COLUMN" | "ROW" | "SHEET" | "SPREADSHEET" | undefined;
+                dimensionRange?: {
+                    sheetId: number;
+                    dimension: "COLUMNS" | "ROWS";
+                    startIndex?: number | undefined;
+                    endIndex?: number | undefined;
+                } | undefined;
+            } | undefined;
+            visibility?: "DOCUMENT" | "PROJECT" | undefined;
+        } | undefined;
+    }[];
+}, {
+    spreadsheetId: string;
+    clearedRanges: string[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_batch_clear_values_by_data_filter", unknown>;
+//# sourceMappingURL=batch-clear-values-by-data-filter.d.ts.map

package/dist/providers/google-sheet/tools/batch-clear-values-by-data-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-clear-values-by-data-filter.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/batch-clear-values-by-data-filter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AA+CxE,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGlD,CAAC;AAEH,eAAO,MAAM,wCAAwC;;;iBAGnD,CAAC;AAEH,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8JAuEpE"}