@schemarch/mcp-server-schemarch 0.0.0-stage → 0.14.0

package/dist/index.js

@@ -0,0 +1,2 @@
+import{a as c,b as a,c as p,d as m,h as s,i as n,j as e}from"./chunk-ONL2HNNT.js";import{a as r,g as t}from"./chunk-ORH6UYIY.js";import"./chunk-XKU4Q6WQ.js";import{createMcpHandler as i}from"@modelcontextprotocol/server";function h(o){return i(()=>e(o),{legacy:"reject"})}var v=r.version;export{p as CURRENT_ELICITATION_TOOLS,m as CURRENT_FEATURE_GROUPS,c as ToolCallerError,t as createFeedbackOperations,h as createSchemarchMcpHandler,e as createSchemarchMcpServer,n as createToolSchemas,a as isToolCallerError,s as schemarchMcpToolSchemas,v as version};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transports/http.ts","../src/index.ts"],"sourcesContent":["import { createMcpHandler } from '@modelcontextprotocol/server';\n\nimport {\n  createSchemarchMcpServer,\n  type SchemarchMcpServerOptions,\n} from '../server.js';\n\n// Modern protocol only: created with `legacy: 'reject'`, so a client that\n// speaks just the 2025-era protocol gets an HTTP 400 instead of being served.\nexport function createSchemarchMcpHandler(options: SchemarchMcpServerOptions) {\n  return createMcpHandler(() => createSchemarchMcpServer(options), {\n    legacy: 'reject',\n  });\n}\n","import packageJson from '../package.json' with { type: 'json' };\n\nexport type {\n  ObservationContext,\n  ObservationEnd,\n  ObservationFact,\n  ObservedMethod,\n  ObservedTool,\n  ConfirmationFeature,\n  RequestObservation,\n  RequestObserver,\n} from './observation.js';\nexport { isToolCallerError, ToolCallerError } from './errors.js';\nexport type { ToolCallCallback } from '@schemarch/mcp-utils';\nexport {\n  createFeedbackOperations,\n  type FeedbackOperationsOptions,\n} from './platform/feedback.js';\nexport type { FeedbackOperations, SchemarchPlatform } from './platform/index.js';\nexport {\n  createSchemarchMcpServer,\n  type SchemarchMcpServerOptions,\n} from './server.js';\nexport { createSchemarchMcpHandler } from './transports/http.js';\nexport {\n  CURRENT_ELICITATION_TOOLS,\n  CURRENT_FEATURE_GROUPS,\n  type ElicitationToolName,\n  type FeatureGroup,\n} from './types.js';\nexport const version = packageJson.version;\n\nexport {\n  createToolSchemas,\n  schemarchMcpToolSchemas,\n} from './tools/tool-schemas.js';\n"],"mappings":"6JAAA,OAAS,oBAAAA,MAAwB,+BAS1B,SAASC,EAA0BC,EAAoC,CAC5E,OAAOC,EAAiB,IAAMC,EAAyBF,CAAO,EAAG,CAC/D,OAAQ,QACV,CAAC,CACH,CCiBO,IAAMG,EAAUC,EAAY","names":["createMcpHandler","createSchemarchMcpHandler","options","createMcpHandler","createSchemarchMcpServer","version","package_default"]}

package/dist/platform/api-platform.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBV2TY4MOcjs = require('../chunk-BV2TY4MO.cjs');require('../chunk-N4WMNFDY.cjs');require('../chunk-PHWSETKC.cjs');require('../chunk-GEJ6NAOC.cjs');exports.createSchemarchApiPlatform = _chunkBV2TY4MOcjs.a;
+//# sourceMappingURL=api-platform.cjs.map

package/dist/platform/api-platform.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/copilot/dev/schemarch-rebuild/mcp/packages/mcp-server-schemarch/dist/platform/api-platform.cjs"],"names":[],"mappings":"AAAA,kIAAoC,iCAA8B,iCAA8B,iCAA8B,yDAAwC","file":"/home/copilot/dev/schemarch-rebuild/mcp/packages/mcp-server-schemarch/dist/platform/api-platform.cjs"}

package/dist/platform/api-platform.d.cts

@@ -0,0 +1,20 @@
+import { SchemarchPlatform } from './index.cjs';
+import '@schemarch/mcp-utils';
+import 'zod/v4';
+
+type SchemarchApiPlatformOptions = {
+    /**
+     * The access token for the Schemarch Management API.
+     */
+    accessToken: string;
+    /**
+     * The API URL for the Schemarch Management API.
+     */
+    apiUrl?: string;
+};
+/**
+ * Creates a Schemarch platform implementation using the Schemarch Management API.
+ */
+declare function createSchemarchApiPlatform(options: SchemarchApiPlatformOptions): SchemarchPlatform;
+
+export { type SchemarchApiPlatformOptions, createSchemarchApiPlatform };

package/dist/platform/api-platform.d.ts

@@ -0,0 +1,20 @@
+import { SchemarchPlatform } from './index.js';
+import '@schemarch/mcp-utils';
+import 'zod/v4';
+
+type SchemarchApiPlatformOptions = {
+    /**
+     * The access token for the Schemarch Management API.
+     */
+    accessToken: string;
+    /**
+     * The API URL for the Schemarch Management API.
+     */
+    apiUrl?: string;
+};
+/**
+ * Creates a Schemarch platform implementation using the Schemarch Management API.
+ */
+declare function createSchemarchApiPlatform(options: SchemarchApiPlatformOptions): SchemarchPlatform;
+
+export { type SchemarchApiPlatformOptions, createSchemarchApiPlatform };

package/dist/platform/api-platform.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-5DTK5H23.js";import"../chunk-ORH6UYIY.js";import"../chunk-LU6L7C36.js";import"../chunk-XKU4Q6WQ.js";export{a as createSchemarchApiPlatform};
+//# sourceMappingURL=api-platform.js.map

package/dist/platform/api-platform.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/platform/index.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../chunk-PHWSETKC.cjs');var _chunkGEJ6NAOCcjs = require('../chunk-GEJ6NAOC.cjs');exports.apiKeyTypeSchema = _chunkGEJ6NAOCcjs.x; exports.applyMigrationOptionsSchema = _chunkGEJ6NAOCcjs.n; exports.branchSchema = _chunkGEJ6NAOCcjs.f; exports.createBranchOptionsSchema = _chunkGEJ6NAOCcjs.j; exports.createNotebookOptionsSchema = _chunkGEJ6NAOCcjs.u; exports.createProjectOptionsSchema = _chunkGEJ6NAOCcjs.i; exports.deployEdgeFunctionOptionsSchema = _chunkGEJ6NAOCcjs.l; exports.edgeFunctionSchema = _chunkGEJ6NAOCcjs.g; exports.edgeFunctionWithBodySchema = _chunkGEJ6NAOCcjs.h; exports.executeSqlOptionsSchema = _chunkGEJ6NAOCcjs.m; exports.generateTypescriptTypesResultSchema = _chunkGEJ6NAOCcjs.s; exports.getLogsOptionsSchema = _chunkGEJ6NAOCcjs.q; exports.logsServiceSchema = _chunkGEJ6NAOCcjs.p; exports.migrationSchema = _chunkGEJ6NAOCcjs.o; exports.notebookCellSchema = _chunkGEJ6NAOCcjs.t; exports.notebookSchema = _chunkGEJ6NAOCcjs.v; exports.notebookWithContentSchema = _chunkGEJ6NAOCcjs.w; exports.organizationSchema = _chunkGEJ6NAOCcjs.d; exports.projectSchema = _chunkGEJ6NAOCcjs.e; exports.queryLogsOptionsSchema = _chunkGEJ6NAOCcjs.r; exports.resetBranchOptionsSchema = _chunkGEJ6NAOCcjs.k; exports.storageBucketSchema = _chunkGEJ6NAOCcjs.b; exports.storageConfigSchema = _chunkGEJ6NAOCcjs.c;
+//# sourceMappingURL=index.cjs.map

package/dist/platform/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/copilot/dev/schemarch-rebuild/mcp/packages/mcp-server-schemarch/dist/platform/index.cjs"],"names":[],"mappings":"AAAA,0GAA6B,yDAAoM,ysCAA4nB","file":"/home/copilot/dev/schemarch-rebuild/mcp/packages/mcp-server-schemarch/dist/platform/index.cjs"}

package/dist/platform/index.d.cts

@@ -0,0 +1,577 @@
+import { InitData } from '@schemarch/mcp-utils';
+import { z } from 'zod/v4';
+
+type SuccessResponse = {
+    success: true;
+};
+declare const storageBucketSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    owner: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    public: z.ZodBoolean;
+}, z.core.$strip>;
+declare const storageConfigSchema: z.ZodObject<{
+    fileSizeLimit: z.ZodNumber;
+    features: z.ZodObject<{
+        imageTransformation: z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>;
+        s3Protocol: z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const organizationSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    plan: z.ZodOptional<z.ZodString>;
+    allowed_release_channels: z.ZodArray<z.ZodString>;
+    opt_in_tags: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const projectSchema: z.ZodObject<{
+    id: z.ZodString;
+    ref: z.ZodString;
+    organization_id: z.ZodString;
+    organization_slug: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodString;
+    created_at: z.ZodString;
+    region: z.ZodString;
+}, z.core.$strip>;
+declare const branchSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    project_ref: z.ZodString;
+    parent_project_ref: z.ZodString;
+    is_default: z.ZodBoolean;
+    git_branch: z.ZodOptional<z.ZodString>;
+    pr_number: z.ZodOptional<z.ZodNumber>;
+    latest_check_run_id: z.ZodOptional<z.ZodNumber>;
+    persistent: z.ZodBoolean;
+    status: z.ZodEnum<{
+        CREATING_PROJECT: "CREATING_PROJECT";
+        RUNNING_MIGRATIONS: "RUNNING_MIGRATIONS";
+        MIGRATIONS_PASSED: "MIGRATIONS_PASSED";
+        MIGRATIONS_FAILED: "MIGRATIONS_FAILED";
+        FUNCTIONS_DEPLOYED: "FUNCTIONS_DEPLOYED";
+        FUNCTIONS_FAILED: "FUNCTIONS_FAILED";
+    }>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+declare const edgeFunctionSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodString;
+    version: z.ZodNumber;
+    created_at: z.ZodOptional<z.ZodNumber>;
+    updated_at: z.ZodOptional<z.ZodNumber>;
+    verify_jwt: z.ZodOptional<z.ZodBoolean>;
+    import_map: z.ZodOptional<z.ZodBoolean>;
+    import_map_path: z.ZodOptional<z.ZodString>;
+    entrypoint_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const edgeFunctionWithBodySchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodString;
+    version: z.ZodNumber;
+    created_at: z.ZodOptional<z.ZodNumber>;
+    updated_at: z.ZodOptional<z.ZodNumber>;
+    verify_jwt: z.ZodOptional<z.ZodBoolean>;
+    import_map: z.ZodOptional<z.ZodBoolean>;
+    import_map_path: z.ZodOptional<z.ZodString>;
+    entrypoint_path: z.ZodOptional<z.ZodString>;
+    files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const createProjectOptionsSchema: z.ZodObject<{
+    name: z.ZodString;
+    organization_id: z.ZodString;
+    region: z.ZodEnum<{
+        "us-west-1": "us-west-1";
+        "us-east-1": "us-east-1";
+        "us-east-2": "us-east-2";
+        "ca-central-1": "ca-central-1";
+        "eu-west-1": "eu-west-1";
+        "eu-west-2": "eu-west-2";
+        "eu-west-3": "eu-west-3";
+        "eu-central-1": "eu-central-1";
+        "eu-central-2": "eu-central-2";
+        "eu-north-1": "eu-north-1";
+        "ap-south-1": "ap-south-1";
+        "ap-southeast-1": "ap-southeast-1";
+        "ap-northeast-1": "ap-northeast-1";
+        "ap-northeast-2": "ap-northeast-2";
+        "ap-southeast-2": "ap-southeast-2";
+        "sa-east-1": "sa-east-1";
+    }>;
+    db_pass: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const createBranchOptionsSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+declare const resetBranchOptionsSchema: z.ZodObject<{
+    migration_version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const deployEdgeFunctionOptionsSchema: z.ZodObject<{
+    name: z.ZodString;
+    entrypoint_path: z.ZodString;
+    import_map_path: z.ZodOptional<z.ZodString>;
+    verify_jwt: z.ZodOptional<z.ZodBoolean>;
+    files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const executeSqlOptionsSchema: z.ZodObject<{
+    query: z.ZodString;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    read_only: z.ZodOptional<z.ZodBoolean>;
+    max_result_bytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const applyMigrationOptionsSchema: z.ZodObject<{
+    name: z.ZodString;
+    query: z.ZodString;
+}, z.core.$strip>;
+declare const migrationSchema: z.ZodObject<{
+    version: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const logsServiceSchema: z.ZodEnum<{
+    storage: "storage";
+    api: "api";
+    "branch-action": "branch-action";
+    postgres: "postgres";
+    "edge-function": "edge-function";
+    "edge-function-runtime": "edge-function-runtime";
+    auth: "auth";
+    realtime: "realtime";
+}>;
+declare const getLogsOptionsSchema: z.ZodObject<{
+    service: z.ZodEnum<{
+        storage: "storage";
+        api: "api";
+        "branch-action": "branch-action";
+        postgres: "postgres";
+        "edge-function": "edge-function";
+        "edge-function-runtime": "edge-function-runtime";
+        auth: "auth";
+        realtime: "realtime";
+    }>;
+    iso_timestamp_start: z.ZodOptional<z.ZodString>;
+    iso_timestamp_end: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const queryLogsOptionsSchema: z.ZodObject<{
+    sql: z.ZodString;
+    iso_timestamp_start: z.ZodOptional<z.ZodString>;
+    iso_timestamp_end: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const generateTypescriptTypesResultSchema: z.ZodObject<{
+    types: z.ZodString;
+}, z.core.$strip>;
+declare const notebookCellSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"markdown">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"database">;
+    sql: z.ZodString;
+    row_limit: z.ZodNumber;
+    database_identifier: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    view: z.ZodOptional<z.ZodEnum<{
+        table: "table";
+        chart: "chart";
+    }>>;
+    chart: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            bar: "bar";
+            line: "line";
+        }>;
+        x_column: z.ZodString;
+        y_series: z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+        }, z.core.$strip>>;
+        scale: z.ZodEnum<{
+            linear: "linear";
+            log: "log";
+        }>;
+        cumulative: z.ZodBoolean;
+        show_labels: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"log">;
+    sql: z.ZodString;
+    time_range: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"absolute">;
+        start: z.ZodString;
+        end: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        unit: z.ZodEnum<{
+            minute: "minute";
+            hour: "hour";
+            day: "day";
+            week: "week";
+            month: "month";
+            year: "year";
+        }>;
+        amount: z.ZodNumber;
+    }, z.core.$strip>]>;
+    title: z.ZodOptional<z.ZodString>;
+    view: z.ZodOptional<z.ZodEnum<{
+        table: "table";
+        chart: "chart";
+    }>>;
+    chart: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            bar: "bar";
+            line: "line";
+        }>;
+        x_column: z.ZodString;
+        y_series: z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+        }, z.core.$strip>>;
+        scale: z.ZodEnum<{
+            linear: "linear";
+            log: "log";
+        }>;
+        cumulative: z.ZodBoolean;
+        show_labels: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">;
+declare const createNotebookOptionsSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    content: z.ZodObject<{
+        cells: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"markdown">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"database">;
+            title: z.ZodOptional<z.ZodString>;
+            view: z.ZodOptional<z.ZodEnum<{
+                table: "table";
+                chart: "chart";
+            }>>;
+            sql: z.ZodString;
+            row_limit: z.ZodNumber;
+            database_identifier: z.ZodOptional<z.ZodString>;
+            chart: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    bar: "bar";
+                    line: "line";
+                }>;
+                x_column: z.ZodString;
+                scale: z.ZodEnum<{
+                    linear: "linear";
+                    log: "log";
+                }>;
+                cumulative: z.ZodBoolean;
+                show_labels: z.ZodBoolean;
+                y_series: z.ZodArray<z.ZodObject<{
+                    column: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"log">;
+            title: z.ZodOptional<z.ZodString>;
+            view: z.ZodOptional<z.ZodEnum<{
+                table: "table";
+                chart: "chart";
+            }>>;
+            sql: z.ZodString;
+            time_range: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"absolute">;
+                start: z.ZodISODateTime;
+                end: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"relative">;
+                unit: z.ZodEnum<{
+                    minute: "minute";
+                    hour: "hour";
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    year: "year";
+                }>;
+                amount: z.ZodNumber;
+            }, z.core.$strict>], "type">;
+            chart: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    bar: "bar";
+                    line: "line";
+                }>;
+                x_column: z.ZodString;
+                scale: z.ZodEnum<{
+                    linear: "linear";
+                    log: "log";
+                }>;
+                cumulative: z.ZodBoolean;
+                show_labels: z.ZodBoolean;
+                y_series: z.ZodArray<z.ZodObject<{
+                    column: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "type">>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const notebookSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    favorite: z.ZodBoolean;
+    inserted_at: z.ZodString;
+    updated_at: z.ZodString;
+    owner: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+    }, z.core.$strip>>;
+    updated_by: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const notebookWithContentSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    favorite: z.ZodBoolean;
+    inserted_at: z.ZodString;
+    updated_at: z.ZodString;
+    owner: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+    }, z.core.$strip>>;
+    updated_by: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+    }, z.core.$strip>>;
+    content: z.ZodObject<{
+        schema_version: z.ZodNumber;
+        cells: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"markdown">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"database">;
+            sql: z.ZodString;
+            row_limit: z.ZodNumber;
+            database_identifier: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+            view: z.ZodOptional<z.ZodEnum<{
+                table: "table";
+                chart: "chart";
+            }>>;
+            chart: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    bar: "bar";
+                    line: "line";
+                }>;
+                x_column: z.ZodString;
+                y_series: z.ZodArray<z.ZodObject<{
+                    column: z.ZodString;
+                }, z.core.$strip>>;
+                scale: z.ZodEnum<{
+                    linear: "linear";
+                    log: "log";
+                }>;
+                cumulative: z.ZodBoolean;
+                show_labels: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"log">;
+            sql: z.ZodString;
+            time_range: z.ZodUnion<readonly [z.ZodObject<{
+                type: z.ZodLiteral<"absolute">;
+                start: z.ZodString;
+                end: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"relative">;
+                unit: z.ZodEnum<{
+                    minute: "minute";
+                    hour: "hour";
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    year: "year";
+                }>;
+                amount: z.ZodNumber;
+            }, z.core.$strip>]>;
+            title: z.ZodOptional<z.ZodString>;
+            view: z.ZodOptional<z.ZodEnum<{
+                table: "table";
+                chart: "chart";
+            }>>;
+            chart: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    bar: "bar";
+                    line: "line";
+                }>;
+                x_column: z.ZodString;
+                y_series: z.ZodArray<z.ZodObject<{
+                    column: z.ZodString;
+                }, z.core.$strip>>;
+                scale: z.ZodEnum<{
+                    linear: "linear";
+                    log: "log";
+                }>;
+                cumulative: z.ZodBoolean;
+                show_labels: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type Organization = z.infer<typeof organizationSchema>;
+type Project = z.infer<typeof projectSchema>;
+type Branch = z.infer<typeof branchSchema>;
+type EdgeFunction = z.infer<typeof edgeFunctionSchema>;
+type EdgeFunctionWithBody = z.infer<typeof edgeFunctionWithBodySchema>;
+type CreateProjectOptions = z.infer<typeof createProjectOptionsSchema>;
+type CreateBranchOptions = z.infer<typeof createBranchOptionsSchema>;
+type ResetBranchOptions = z.infer<typeof resetBranchOptionsSchema>;
+type DeployEdgeFunctionOptions = z.infer<typeof deployEdgeFunctionOptionsSchema>;
+type ExecuteSqlOptions = z.infer<typeof executeSqlOptionsSchema>;
+type ApplyMigrationOptions = z.infer<typeof applyMigrationOptionsSchema>;
+type Migration = z.infer<typeof migrationSchema>;
+type ListMigrationsResult = z.infer<typeof migrationSchema>;
+type LogsService = z.infer<typeof logsServiceSchema>;
+type GetLogsOptions = z.infer<typeof getLogsOptionsSchema>;
+type QueryLogsOptions = z.infer<typeof queryLogsOptionsSchema>;
+type GenerateTypescriptTypesResult = z.infer<typeof generateTypescriptTypesResultSchema>;
+type StorageConfig = z.infer<typeof storageConfigSchema>;
+type StorageBucket = z.infer<typeof storageBucketSchema>;
+type NotebookCell = z.infer<typeof notebookCellSchema>;
+type CreateNotebookOptions = z.infer<typeof createNotebookOptionsSchema>;
+type Notebook = z.infer<typeof notebookSchema>;
+type NotebookWithContent = z.infer<typeof notebookWithContentSchema>;
+type DatabaseOperations = {
+    executeSql<T>(projectId: string, options: ExecuteSqlOptions): Promise<T[]>;
+    listMigrations(projectId: string): Promise<Migration[]>;
+    applyMigration(projectId: string, options: ApplyMigrationOptions): Promise<void>;
+};
+type AccountOperations = {
+    listOrganizations(): Promise<{
+        id: string;
+        slug: string;
+        name: string;
+    }[]>;
+    getOrganization(organizationId: string): Promise<Organization>;
+    listProjects(): Promise<Project[]>;
+    getProject(projectId: string): Promise<Project>;
+    createProject(options: CreateProjectOptions): Promise<Project>;
+    pauseProject(projectId: string): Promise<void>;
+    restoreProject(projectId: string): Promise<void>;
+};
+type EdgeFunctionsOperations = {
+    listEdgeFunctions(projectId: string): Promise<EdgeFunction[]>;
+    getEdgeFunction(projectId: string, functionSlug: string): Promise<EdgeFunctionWithBody>;
+    deployEdgeFunction(projectId: string, options: DeployEdgeFunctionOptions): Promise<Omit<EdgeFunction, 'files'>>;
+};
+/**
+ * SQL dialect that a platform's logs endpoint speaks. Selects the
+ * dialect-appropriate `query_logs` description and `sql` parameter hint so a
+ * single tool can roll out across environments that back logs with different
+ * engines (hosted ClickHouse vs. self-hosted/CLI BigQuery).
+ */
+type LogsDialect = 'clickhouse' | 'bigquery';
+type DebuggingOperations = {
+    /**
+     * SQL dialect accepted by `queryLogs`. Defaults to `'clickhouse'` when unset,
+     * preserving the behavior of platforms that predate this field.
+     */
+    logsDialect?: LogsDialect;
+    getLogs(projectId: string, options: GetLogsOptions): Promise<unknown>;
+    queryLogs?(projectId: string, options: QueryLogsOptions): Promise<unknown>;
+    getSecurityAdvisors(projectId: string): Promise<unknown>;
+    getPerformanceAdvisors(projectId: string): Promise<unknown>;
+    getHealthAdvisors?(projectId: string): Promise<unknown>;
+};
+declare const apiKeyTypeSchema: z.ZodEnum<{
+    legacy: "legacy";
+    publishable: "publishable";
+}>;
+type ApiKeyType = z.infer<typeof apiKeyTypeSchema>;
+type ApiKey = {
+    api_key: string;
+    name: string;
+    type: ApiKeyType;
+    description?: string;
+    id?: string;
+    disabled?: boolean;
+};
+type DevelopmentOperations = {
+    getProjectUrl(projectId: string): Promise<string>;
+    getPublishableKeys(projectId: string): Promise<ApiKey[]>;
+    generateTypescriptTypes(projectId: string): Promise<GenerateTypescriptTypesResult>;
+};
+type StorageOperations = {
+    getStorageConfig(projectId: string): Promise<StorageConfig>;
+    updateStorageConfig(projectId: string, config: StorageConfig): Promise<void>;
+    listAllBuckets(projectId: string): Promise<StorageBucket[]>;
+};
+type BranchingOperations = {
+    listBranches(projectId: string): Promise<Branch[]>;
+    createBranch(projectId: string, options: CreateBranchOptions): Promise<Branch>;
+    deleteBranch(branchId: string): Promise<void>;
+    mergeBranch(branchId: string): Promise<void>;
+    resetBranch(branchId: string, options: ResetBranchOptions): Promise<void>;
+    rebaseBranch(branchId: string): Promise<void>;
+};
+/**
+ * Returns only the `updated_at` timestamp of the named secret, never its
+ * value or digest.
+ */
+type SecretOperations = {
+    getUpdatedAt(projectId: string, name: string): Promise<Date | undefined>;
+};
+type NotebookOperations = {
+    /** Optional for platforms that only support reading notebooks. */
+    createNotebook?(projectId: string, options: CreateNotebookOptions): Promise<NotebookWithContent>;
+    listNotebooks(projectId: string): Promise<Notebook[]>;
+    getNotebook(projectId: string, notebookId: string): Promise<NotebookWithContent>;
+};
+type FeedbackOperations = {
+    submit(input: {
+        feedback: string;
+        projectId?: string;
+        clientInfo?: {
+            name: string;
+            version: string;
+        };
+    }): Promise<{
+        deleteToken: string;
+    }>;
+    delete(input: {
+        deleteToken: string;
+        projectId?: string;
+    }): Promise<{
+        deleted: boolean;
+    }>;
+};
+type SchemarchPlatform = {
+    init?(info: InitData): Promise<void>;
+    account?: AccountOperations;
+    database?: DatabaseOperations;
+    functions?: EdgeFunctionsOperations;
+    debugging?: DebuggingOperations;
+    development?: DevelopmentOperations;
+    storage?: StorageOperations;
+    branching?: BranchingOperations;
+    secrets?: SecretOperations;
+    notebooks?: NotebookOperations;
+    feedback?: FeedbackOperations;
+};
+
+export { type AccountOperations, type ApiKey, type ApiKeyType, type ApplyMigrationOptions, type Branch, type BranchingOperations, type CreateBranchOptions, type CreateNotebookOptions, type CreateProjectOptions, type DatabaseOperations, type DebuggingOperations, type DeployEdgeFunctionOptions, type DevelopmentOperations, type EdgeFunction, type EdgeFunctionWithBody, type EdgeFunctionsOperations, type ExecuteSqlOptions, type FeedbackOperations, type GenerateTypescriptTypesResult, type GetLogsOptions, type ListMigrationsResult, type LogsDialect, type LogsService, type Migration, type Notebook, type NotebookCell, type NotebookOperations, type NotebookWithContent, type Organization, type Project, type QueryLogsOptions, type ResetBranchOptions, type SchemarchPlatform, type SecretOperations, type StorageBucket, type StorageConfig, type StorageOperations, type SuccessResponse, apiKeyTypeSchema, applyMigrationOptionsSchema, branchSchema, createBranchOptionsSchema, createNotebookOptionsSchema, createProjectOptionsSchema, deployEdgeFunctionOptionsSchema, edgeFunctionSchema, edgeFunctionWithBodySchema, executeSqlOptionsSchema, generateTypescriptTypesResultSchema, getLogsOptionsSchema, logsServiceSchema, migrationSchema, notebookCellSchema, notebookSchema, notebookWithContentSchema, organizationSchema, projectSchema, queryLogsOptionsSchema, resetBranchOptionsSchema, storageBucketSchema, storageConfigSchema };