@mastra/connect 0.1.0-alpha.0 → 0.2.0-alpha.1

package/dist/providers/notion/tools/search-databases.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const searchDatabasesInputSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const searchDatabasesOutputSchema: z.ZodObject<{
+    object: z.ZodString;
+    results: z.ZodArray<z.ZodAny>;
+    has_more: z.ZodBoolean;
+    next_cursor: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+}, z.core.$strip>;
+export declare function searchDatabasesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    query?: string | undefined;
+    page_size?: number | undefined;
+    cursor?: string | undefined;
+}, {
+    object: string;
+    results: any[];
+    has_more: boolean;
+    next_cursor: string | null;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "notion_search_databases", unknown>;
+//# sourceMappingURL=search-databases.d.ts.map

package/dist/providers/notion/tools/search-databases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-databases.d.ts","sourceRoot":"","sources":["../../../../src/providers/notion/tools/search-databases.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;iBAKtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;uIA+BvD"}

package/dist/providers/notion/tools/search-pages.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const searchPagesInputSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const searchPagesOutputSchema: z.ZodObject<{
+    object: z.ZodString;
+    results: z.ZodArray<z.ZodAny>;
+    has_more: z.ZodBoolean;
+    next_cursor: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+}, z.core.$strip>;
+export declare function searchPagesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    query?: string | undefined;
+    page_size?: number | undefined;
+    cursor?: string | undefined;
+}, {
+    object: string;
+    results: any[];
+    has_more: boolean;
+    next_cursor: string | null;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "notion_search_pages", unknown>;
+//# sourceMappingURL=search-pages.d.ts.map

package/dist/providers/notion/tools/search-pages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-pages.d.ts","sourceRoot":"","sources":["../../../../src/providers/notion/tools/search-pages.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;mIA+BnD"}

package/dist/providers/notion/tools/search.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const searchInputSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    filter: z.ZodOptional<z.ZodObject<{
+        property: z.ZodLiteral<"object">;
+        value: z.ZodEnum<{
+            data_source: "data_source";
+            page: "page";
+        }>;
+    }, z.core.$strip>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        timestamp: z.ZodEnum<{
+            created_time: "created_time";
+            last_edited_time: "last_edited_time";
+        }>;
+        direction: z.ZodEnum<{
+            ascending: "ascending";
+            descending: "descending";
+        }>;
+    }, z.core.$strip>>;
+    start_cursor: z.ZodOptional<z.ZodString>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const searchOutputSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodUnknown>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+    has_more: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function searchTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    query?: string | undefined;
+    filter?: {
+        property: "object";
+        value: "data_source" | "page";
+    } | undefined;
+    sort?: {
+        timestamp: "created_time" | "last_edited_time";
+        direction: "ascending" | "descending";
+    } | undefined;
+    start_cursor?: string | undefined;
+    page_size?: number | undefined;
+}, {
+    results: unknown[];
+    next_cursor?: string | undefined;
+    has_more: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "notion_search", unknown>;
+//# sourceMappingURL=search.d.ts.map

package/dist/providers/notion/tools/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/providers/notion/tools/search.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;iBAkB5B,CAAC;AAWH,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AAEH,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;6HA8C9C"}

package/dist/providers/notion/tools/update-block.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateBlockInputSchema: z.ZodObject<{
+    block_id: z.ZodString;
+    content: z.ZodObject<{}, z.core.$loose>;
+}, z.core.$strip>;
+export declare const updateBlockOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    object: z.ZodString;
+}, z.core.$strip>;
+export declare function updateBlockTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    block_id: string;
+    content: {
+        [x: string]: unknown;
+    };
+}, {
+    id: string;
+    type: string;
+    object: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "notion_update_block", unknown>;
+//# sourceMappingURL=update-block.d.ts.map

package/dist/providers/notion/tools/update-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-block.d.ts","sourceRoot":"","sources":["../../../../src/providers/notion/tools/update-block.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAQH,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;mIAgDnD"}

package/dist/providers/notion/tools/update-data-source.d.ts

@@ -0,0 +1,249 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateDataSourceInputSchema: z.ZodObject<{
+    dataSourceId: z.ZodString;
+    title: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodObject<{
+            content: z.ZodString;
+            link: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+                url: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    description: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodObject<{
+            content: z.ZodString;
+            link: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+                url: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodNull]>>>;
+    inTrash: z.ZodOptional<z.ZodBoolean>;
+    parent: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"database_id">;
+        database_id: z.ZodString;
+    }, z.core.$strip>>;
+    icon: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"emoji">;
+        emoji: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"external">;
+        external: z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        file: z.ZodObject<{
+            url: z.ZodString;
+            expiry_time: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"custom_emoji">;
+        custom_emoji: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"icon">;
+        icon: z.ZodObject<{
+            name: z.ZodString;
+            color: z.ZodOptional<z.ZodEnum<{
+                blue: "blue";
+                brown: "brown";
+                gray: "gray";
+                green: "green";
+                lightgray: "lightgray";
+                orange: "orange";
+                pink: "pink";
+                purple: "purple";
+                red: "red";
+                yellow: "yellow";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>>;
+}, z.core.$strip>;
+export declare const updateDataSourceOutputSchema: z.ZodObject<{
+    object: z.ZodLiteral<"data_source">;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        text: z.ZodObject<{
+            content: z.ZodString;
+            link: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+                url: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        annotations: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        plain_text: z.ZodOptional<z.ZodString>;
+        href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>;
+    description: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        text: z.ZodObject<{
+            content: z.ZodString;
+            link: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+                url: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        annotations: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        plain_text: z.ZodOptional<z.ZodString>;
+        href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>;
+    parent: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"database_id">;
+        database_id: z.ZodString;
+    }, z.core.$strip>>;
+    database_parent: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        page_id: z.ZodOptional<z.ZodString>;
+        workspace: z.ZodOptional<z.ZodBoolean>;
+        block_id: z.ZodOptional<z.ZodString>;
+        database_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    is_inline: z.ZodOptional<z.ZodBoolean>;
+    in_trash: z.ZodOptional<z.ZodBoolean>;
+    created_time: z.ZodOptional<z.ZodString>;
+    last_edited_time: z.ZodOptional<z.ZodString>;
+    created_by: z.ZodOptional<z.ZodObject<{
+        object: z.ZodLiteral<"user">;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    last_edited_by: z.ZodOptional<z.ZodObject<{
+        object: z.ZodLiteral<"user">;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{}, z.core.$loose>>>;
+    icon: z.ZodOptional<z.ZodUnknown>;
+    cover: z.ZodNullable<z.ZodOptional<z.ZodUnknown>>;
+    url: z.ZodOptional<z.ZodString>;
+    public_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare function updateDataSourceTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    dataSourceId: string;
+    title?: {
+        type: "text";
+        text: {
+            content: string;
+            link?: {
+                url: string;
+            } | null | undefined;
+        };
+    }[] | undefined;
+    description?: {
+        type: "text";
+        text: {
+            content: string;
+            link?: {
+                url: string;
+            } | null | undefined;
+        };
+    }[] | undefined;
+    properties?: Record<string, {
+        name?: string | undefined;
+        description?: string | null | undefined;
+        type?: string | undefined;
+    } | null> | undefined;
+    inTrash?: boolean | undefined;
+    parent?: {
+        type: "database_id";
+        database_id: string;
+    } | undefined;
+    icon?: {
+        type: "emoji";
+        emoji: string;
+    } | {
+        type: "external";
+        external: {
+            url: string;
+        };
+    } | {
+        type: "file";
+        file: {
+            url: string;
+            expiry_time?: string | undefined;
+        };
+    } | {
+        type: "custom_emoji";
+        custom_emoji: {
+            id: string;
+            name?: string | undefined;
+            url?: string | undefined;
+        };
+    } | {
+        type: "icon";
+        icon: {
+            name: string;
+            color?: "blue" | "brown" | "gray" | "green" | "lightgray" | "orange" | "pink" | "purple" | "red" | "yellow" | undefined;
+        };
+    } | null | undefined;
+}, {
+    object: "data_source";
+    id: string;
+    title?: {
+        type: string;
+        text: {
+            content: string;
+            link?: {
+                url: string;
+            } | null | undefined;
+        };
+        annotations?: {
+            [x: string]: unknown;
+        } | undefined;
+        plain_text?: string | undefined;
+        href?: string | null | undefined;
+    }[] | undefined;
+    description?: {
+        type: string;
+        text: {
+            content: string;
+            link?: {
+                url: string;
+            } | null | undefined;
+        };
+        annotations?: {
+            [x: string]: unknown;
+        } | undefined;
+        plain_text?: string | undefined;
+        href?: string | null | undefined;
+    }[] | undefined;
+    parent?: {
+        type: "database_id";
+        database_id: string;
+    } | undefined;
+    database_parent?: {
+        type: string;
+        page_id?: string | undefined;
+        workspace?: boolean | undefined;
+        block_id?: string | undefined;
+        database_id?: string | undefined;
+    } | undefined;
+    is_inline?: boolean | undefined;
+    in_trash?: boolean | undefined;
+    created_time?: string | undefined;
+    last_edited_time?: string | undefined;
+    created_by?: {
+        object: "user";
+        id: string;
+    } | undefined;
+    last_edited_by?: {
+        object: "user";
+        id: string;
+    } | undefined;
+    properties?: Record<string, {
+        [x: string]: unknown;
+    }> | undefined;
+    icon?: unknown;
+    cover?: unknown;
+    url?: string | undefined;
+    public_url?: string | null | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "notion_update_data_source", unknown>;
+//# sourceMappingURL=update-data-source.d.ts.map

package/dist/providers/notion/tools/update-data-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-data-source.d.ts","sourceRoot":"","sources":["../../../../src/providers/notion/tools/update-data-source.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAyExE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgBtC,CAAC;AAyBH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BvC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yIA2KxD"}

package/dist/providers/notion/tools/update-database.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updateDatabaseInputSchema: z.ZodObject<{
+    database_id: z.ZodString;
+    title: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        text: z.ZodObject<{
+            content: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    description: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+export declare const updateDatabaseOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodString;
+    title: z.ZodArray<z.ZodAny>;
+    properties: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+export declare function updateDatabaseTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    database_id: string;
+    title?: {
+        text: {
+            content: string;
+        };
+    }[] | undefined;
+    description?: any[] | undefined;
+    properties?: Record<string, any> | undefined;
+}, {
+    id: string;
+    object: string;
+    title: any[];
+    properties: Record<string, any>;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "notion_update_database", unknown>;
+//# sourceMappingURL=update-database.d.ts.map

package/dist/providers/notion/tools/update-database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-database.d.ts","sourceRoot":"","sources":["../../../../src/providers/notion/tools/update-database.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,yBAAyB;;;;;;;;;iBAcpC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;sIA8BtD"}

package/dist/providers/notion/tools/update-page-markdown.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updatePageMarkdownInputSchema: z.ZodObject<{
+    page_id: z.ZodString;
+    type: z.ZodEnum<{
+        insert_content: "insert_content";
+        replace_content: "replace_content";
+        replace_content_range: "replace_content_range";
+        update_content: "update_content";
+    }>;
+    update_content: z.ZodOptional<z.ZodObject<{
+        content_updates: z.ZodArray<z.ZodObject<{
+            old_str: z.ZodString;
+            new_str: z.ZodString;
+            replace_all_matches: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        allow_deleting_content: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    replace_content: z.ZodOptional<z.ZodObject<{
+        new_str: z.ZodString;
+        allow_deleting_content: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    insert_content: z.ZodOptional<z.ZodObject<{
+        content: z.ZodString;
+        after: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    replace_content_range: z.ZodOptional<z.ZodObject<{
+        content: z.ZodString;
+        range: z.ZodString;
+        allow_deleting_content: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const updatePageMarkdownOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    markdown: z.ZodString;
+    truncated: z.ZodBoolean;
+    unknown_block_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare function updatePageMarkdownTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    page_id: string;
+    type: "insert_content" | "replace_content" | "replace_content_range" | "update_content";
+    update_content?: {
+        content_updates: {
+            old_str: string;
+            new_str: string;
+            replace_all_matches?: boolean | undefined;
+        }[];
+        allow_deleting_content?: boolean | undefined;
+    } | undefined;
+    replace_content?: {
+        new_str: string;
+        allow_deleting_content?: boolean | undefined;
+    } | undefined;
+    insert_content?: {
+        content: string;
+        after?: string | undefined;
+    } | undefined;
+    replace_content_range?: {
+        content: string;
+        range: string;
+        allow_deleting_content?: boolean | undefined;
+    } | undefined;
+}, {
+    id: string;
+    markdown: string;
+    truncated: boolean;
+    unknown_block_ids?: string[] | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "notion_update_page_markdown", unknown>;
+//# sourceMappingURL=update-page-markdown.d.ts.map

package/dist/providers/notion/tools/update-page-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-page-markdown.d.ts","sourceRoot":"","sources":["../../../../src/providers/notion/tools/update-page-markdown.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAaxE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CxC,CAAC;AAUH,eAAO,MAAM,8BAA8B;;;;;iBAKzC,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2IAmE1D"}

package/dist/providers/notion/tools/update-page.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const updatePageInputSchema: z.ZodObject<{
+    page_id: z.ZodString;
+    properties: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodUnknown>;
+    cover: z.ZodOptional<z.ZodUnknown>;
+    is_locked: z.ZodOptional<z.ZodBoolean>;
+    in_trash: z.ZodOptional<z.ZodBoolean>;
+    is_archived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updatePageOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodOptional<z.ZodString>;
+    created_time: z.ZodOptional<z.ZodString>;
+    last_edited_time: z.ZodOptional<z.ZodString>;
+    in_trash: z.ZodOptional<z.ZodBoolean>;
+    is_archived: z.ZodOptional<z.ZodBoolean>;
+    is_locked: z.ZodOptional<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodString>;
+    public_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    parent: z.ZodOptional<z.ZodUnknown>;
+    properties: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodUnknown>;
+    cover: z.ZodOptional<z.ZodUnknown>;
+    created_by: z.ZodOptional<z.ZodUnknown>;
+    last_edited_by: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare function updatePageTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    page_id: string;
+    properties?: unknown;
+    icon?: unknown;
+    cover?: unknown;
+    is_locked?: boolean | undefined;
+    in_trash?: boolean | undefined;
+    is_archived?: boolean | undefined;
+}, {
+    id: string;
+    object?: string | undefined;
+    created_time?: string | undefined;
+    last_edited_time?: string | undefined;
+    in_trash?: boolean | undefined;
+    is_archived?: boolean | undefined;
+    is_locked?: boolean | undefined;
+    url?: string | undefined;
+    public_url?: string | null | undefined;
+    parent?: unknown;
+    properties?: unknown;
+    icon?: unknown;
+    cover?: unknown;
+    created_by?: unknown;
+    last_edited_by?: unknown;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "notion_update_page", unknown>;
+//# sourceMappingURL=update-page.d.ts.map

package/dist/providers/notion/tools/update-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-page.d.ts","sourceRoot":"","sources":["../../../../src/providers/notion/tools/update-page.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAUxE,eAAO,MAAM,qBAAqB;;;;;;;;iBAchC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;iBAgBjC,CAAC;AAEH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;kIA+ElD"}

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/openai/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,eAAO,MAAM,cAAc,EAAE,oBAI5B,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/providers/openai/tools/add-vector-store-file.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const addVectorStoreFileInputSchema: z.ZodObject<{
+    vector_store_id: z.ZodString;
+    file_id: z.ZodString;
+    chunking_strategy: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"auto">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"static">;
+        static: z.ZodObject<{
+            max_chunk_size_tokens: z.ZodNumber;
+            chunk_overlap_tokens: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+export declare const addVectorStoreFileOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    vector_store_id: z.ZodString;
+    status: z.ZodUnion<readonly [z.ZodLiteral<"in_progress">, z.ZodLiteral<"completed">, z.ZodLiteral<"failed">, z.ZodLiteral<"cancelled">]>;
+    created_at: z.ZodNumber;
+    usage_bytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function addVectorStoreFileTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    vector_store_id: string;
+    file_id: string;
+    chunking_strategy?: {
+        type: "auto";
+    } | {
+        type: "static";
+        static: {
+            max_chunk_size_tokens: number;
+            chunk_overlap_tokens: number;
+        };
+    } | undefined;
+    attributes?: Record<string, any> | undefined;
+}, {
+    id: string;
+    vector_store_id: string;
+    status: "cancelled" | "completed" | "failed" | "in_progress";
+    created_at: number;
+    usage_bytes?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_add_vector_store_file", unknown>;
+//# sourceMappingURL=add-vector-store-file.d.ts.map

package/dist/providers/openai/tools/add-vector-store-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-vector-store-file.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/add-vector-store-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;iBAmBxC,CAAC;AAUH,eAAO,MAAM,8BAA8B;;;;;;iBAMzC,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;4IA8B1D"}