@neon/tools 0.2.0 → 0.4.0

package/dist/lib/envelope.d.ts

@@ -0,0 +1,5 @@
+export declare function optionalGroup<Value extends Record<string, unknown>>(value: Value, required: true): Value;
+export declare function optionalGroup<Value extends Record<string, unknown>>(value: Value, required: false): Value | undefined;
+export declare function decodeBinaryFields(body: Record<string, unknown>, fields: readonly string[], decode: (value: string) => Blob): Record<string, unknown>;
+export declare function decodeBinaryFields(body: Record<string, unknown> | undefined, fields: readonly string[], decode: (value: string) => Blob): Record<string, unknown> | undefined;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/lib/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../src/lib/envelope.ts"],"names":[],"mappings":"AAYA,wBAAgB,aAAa,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,IAAI,GACZ,KAAK,CAAC;AACT,wBAAgB,aAAa,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,KAAK,GACb,KAAK,GAAG,SAAS,CAAC;AAYrB,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAC3B,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACzC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC"}

package/dist/lib/envelope.js

@@ -0,0 +1,22 @@
+//#region src/lib/envelope.ts
+const defined = (value) => {
+	const next = {};
+	for (const [key, child] of Object.entries(value)) if (child !== void 0) next[key] = child;
+	return next;
+};
+function optionalGroup(value, required) {
+	const next = defined(value);
+	if (!required && Object.keys(next).length === 0) return;
+	return next;
+}
+function decodeBinaryFields(body, fields, decode) {
+	if (body === void 0) return;
+	const next = { ...body };
+	for (const field of fields) {
+		const value = next[field];
+		if (typeof value === "string") next[field] = decode(value);
+	}
+	return next;
+}
+//#endregion
+export { decodeBinaryFields, optionalGroup };

package/dist/lib/workflows.d.ts

@@ -0,0 +1,315 @@
+import { type NeonConfig } from "@neon/sdk";
+import * as z from "zod";
+import { type NeonBearerCredential } from "./auth.js";
+import type { NeonTool } from "./operation.js";
+export interface WorkflowClientOptions {
+    apiKey?: NeonBearerCredential;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    wait?: NeonConfig["wait"];
+}
+export declare const createBranchWithComputeInputSchema: z.ZodObject<{
+    project_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodString>;
+    compute: z.ZodOptional<z.ZodObject<{
+        min_cu: z.ZodOptional<z.ZodNumber>;
+        max_cu: z.ZodOptional<z.ZodNumber>;
+        suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>;
+    pooled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const createProjectAndConnectInputSchema: z.ZodObject<{
+    pooled: z.ZodOptional<z.ZodBoolean>;
+    settings: z.ZodOptional<z.ZodObject<{
+        quota: z.ZodOptional<z.ZodObject<{
+            active_time_seconds: z.ZodOptional<z.ZodInt>;
+            compute_time_seconds: z.ZodOptional<z.ZodInt>;
+            written_data_bytes: z.ZodOptional<z.ZodInt>;
+            data_transfer_bytes: z.ZodOptional<z.ZodInt>;
+            logical_size_bytes: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>>;
+        allowed_ips: z.ZodOptional<z.ZodObject<{
+            ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            protected_branches_only: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        enable_logical_replication: z.ZodOptional<z.ZodBoolean>;
+        maintenance_window: z.ZodOptional<z.ZodObject<{
+            weekdays: z.ZodArray<z.ZodInt>;
+            start_time: z.ZodString;
+            end_time: z.ZodString;
+        }, z.core.$strict>>;
+        block_public_connections: z.ZodOptional<z.ZodBoolean>;
+        block_vpc_connections: z.ZodOptional<z.ZodBoolean>;
+        audit_log_level: z.ZodOptional<z.ZodEnum<{
+            base: "base";
+            extended: "extended";
+            full: "full";
+        }>>;
+        hipaa: z.ZodOptional<z.ZodBoolean>;
+        preload_libraries: z.ZodOptional<z.ZodObject<{
+            use_defaults: z.ZodOptional<z.ZodBoolean>;
+            enabled_libraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    name: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        role_name: z.ZodOptional<z.ZodString>;
+        database_name: z.ZodOptional<z.ZodString>;
+        annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+    autoscaling_limit_min_cu: z.ZodOptional<z.ZodNumber>;
+    autoscaling_limit_max_cu: z.ZodOptional<z.ZodNumber>;
+    provisioner: z.ZodOptional<z.ZodString>;
+    region_id: z.ZodOptional<z.ZodString>;
+    default_endpoint_settings: z.ZodOptional<z.ZodObject<{
+        pg_settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        pgbouncer_settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        autoscaling_limit_min_cu: z.ZodOptional<z.ZodNumber>;
+        autoscaling_limit_max_cu: z.ZodOptional<z.ZodNumber>;
+        suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>;
+    pg_version: z.ZodOptional<z.ZodInt>;
+    store_passwords: z.ZodOptional<z.ZodBoolean>;
+    history_retention_seconds: z.ZodOptional<z.ZodInt>;
+    org_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const workflowIds: readonly ["createBranchWithCompute", "createProjectAndConnect"];
+export type NeonWorkflowId = (typeof workflowIds)[number];
+export declare const workflowFactories: {
+    createBranchWithCompute: (options: WorkflowClientOptions) => NeonTool<z.ZodObject<{
+        project_id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        parent_id: z.ZodOptional<z.ZodString>;
+        compute: z.ZodOptional<z.ZodObject<{
+            min_cu: z.ZodOptional<z.ZodNumber>;
+            max_cu: z.ZodOptional<z.ZodNumber>;
+            suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>>;
+        pooled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, "create_branch_with_compute", {
+        branch: {
+            id: string;
+            project_id: string;
+            parent_id?: string | null | undefined;
+            parent_lsn?: string | null | undefined;
+            parent_timestamp?: string | null | undefined;
+            name: string;
+            current_state: import("@neon/sdk").BranchState;
+            pending_state?: string | null | undefined;
+            state_changed_at: string;
+            logical_size?: number | null | undefined;
+            creation_source: string;
+            primary?: boolean | null | undefined;
+            default: boolean;
+            protected: boolean;
+            cpu_used_sec: number;
+            compute_time_seconds: number;
+            active_time_seconds: number;
+            written_data_bytes: number;
+            data_transfer_bytes: number;
+            created_at: string;
+            updated_at: string;
+            ttl_interval_seconds?: number | null | undefined;
+            expires_at?: string | null | undefined;
+            last_reset_at?: string | null | undefined;
+            created_by?: {
+                name?: string | null | undefined;
+                image?: string | null | undefined;
+            } | null | undefined;
+            init_source?: string | null | undefined;
+            restore_status?: string | null | undefined;
+            restored_from?: string | null | undefined;
+            restored_as?: string | null | undefined;
+            restricted_actions?: {
+                name: string;
+                reason: string;
+            }[] | null | undefined;
+            recovery?: {
+                deleted_at: string;
+                recoverable_until: string;
+                deletion_method: "user" | "ttl";
+            } | null | undefined;
+        };
+        endpoint: {
+            host: string;
+            id: string;
+            name?: string | null | undefined;
+            project_id: string;
+            branch_id: string;
+            autoscaling_limit_min_cu: import("@neon/sdk").ComputeUnit;
+            autoscaling_limit_max_cu: import("@neon/sdk").ComputeUnit;
+            region_id: string;
+            type: import("@neon/sdk").EndpointType;
+            current_state: import("@neon/sdk").EndpointState;
+            pending_state?: import("@neon/sdk").EndpointState | null | undefined;
+            settings: {
+                pg_settings?: {
+                    [x: string]: string;
+                } | null | undefined;
+                pgbouncer_settings?: {
+                    [x: string]: string;
+                } | null | undefined;
+                preload_libraries?: {
+                    use_defaults?: boolean | null | undefined;
+                    enabled_libraries?: string[] | null | undefined;
+                } | null | undefined;
+            };
+            pooler_enabled: boolean;
+            pooler_mode: import("@neon/sdk").EndpointPoolerMode;
+            disabled: boolean;
+            passwordless_access: boolean;
+            last_active?: string | null | undefined;
+            creation_source: string;
+            created_at: string;
+            updated_at: string;
+            started_at?: string | null | undefined;
+            suspended_at?: string | null | undefined;
+            proxy_host: string;
+            suspend_timeout_seconds: import("@neon/sdk").SuspendTimeoutSeconds;
+            provisioner: import("@neon/sdk").Provisioner;
+            compute_release_version?: string | null | undefined;
+        };
+        connectionString: string;
+    }>;
+    createProjectAndConnect: (options: WorkflowClientOptions) => NeonTool<z.ZodObject<{
+        pooled: z.ZodOptional<z.ZodBoolean>;
+        settings: z.ZodOptional<z.ZodObject<{
+            quota: z.ZodOptional<z.ZodObject<{
+                active_time_seconds: z.ZodOptional<z.ZodInt>;
+                compute_time_seconds: z.ZodOptional<z.ZodInt>;
+                written_data_bytes: z.ZodOptional<z.ZodInt>;
+                data_transfer_bytes: z.ZodOptional<z.ZodInt>;
+                logical_size_bytes: z.ZodOptional<z.ZodInt>;
+            }, z.core.$strict>>;
+            allowed_ips: z.ZodOptional<z.ZodObject<{
+                ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                protected_branches_only: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            enable_logical_replication: z.ZodOptional<z.ZodBoolean>;
+            maintenance_window: z.ZodOptional<z.ZodObject<{
+                weekdays: z.ZodArray<z.ZodInt>;
+                start_time: z.ZodString;
+                end_time: z.ZodString;
+            }, z.core.$strict>>;
+            block_public_connections: z.ZodOptional<z.ZodBoolean>;
+            block_vpc_connections: z.ZodOptional<z.ZodBoolean>;
+            audit_log_level: z.ZodOptional<z.ZodEnum<{
+                base: "base";
+                extended: "extended";
+                full: "full";
+            }>>;
+            hipaa: z.ZodOptional<z.ZodBoolean>;
+            preload_libraries: z.ZodOptional<z.ZodObject<{
+                use_defaults: z.ZodOptional<z.ZodBoolean>;
+                enabled_libraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        name: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            role_name: z.ZodOptional<z.ZodString>;
+            database_name: z.ZodOptional<z.ZodString>;
+            annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>>;
+        autoscaling_limit_min_cu: z.ZodOptional<z.ZodNumber>;
+        autoscaling_limit_max_cu: z.ZodOptional<z.ZodNumber>;
+        provisioner: z.ZodOptional<z.ZodString>;
+        region_id: z.ZodOptional<z.ZodString>;
+        default_endpoint_settings: z.ZodOptional<z.ZodObject<{
+            pg_settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            pgbouncer_settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            autoscaling_limit_min_cu: z.ZodOptional<z.ZodNumber>;
+            autoscaling_limit_max_cu: z.ZodOptional<z.ZodNumber>;
+            suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>>;
+        pg_version: z.ZodOptional<z.ZodInt>;
+        store_passwords: z.ZodOptional<z.ZodBoolean>;
+        history_retention_seconds: z.ZodOptional<z.ZodInt>;
+        org_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, "create_project_and_connect", {
+        project: {
+            data_storage_bytes_hour: number;
+            data_transfer_bytes: number;
+            written_data_bytes: number;
+            compute_time_seconds: number;
+            active_time_seconds: number;
+            cpu_used_sec: number;
+            id: string;
+            platform_id: string;
+            region_id: string;
+            name: string;
+            provisioner: import("@neon/sdk").Provisioner;
+            default_endpoint_settings?: {
+                pg_settings?: {
+                    [x: string]: string;
+                } | null | undefined;
+                pgbouncer_settings?: {
+                    [x: string]: string;
+                } | null | undefined;
+                autoscaling_limit_min_cu?: number | null | undefined;
+                autoscaling_limit_max_cu?: number | null | undefined;
+                suspend_timeout_seconds?: number | null | undefined;
+            } | null | undefined;
+            settings?: {
+                quota?: {
+                    active_time_seconds?: number | null | undefined;
+                    compute_time_seconds?: number | null | undefined;
+                    written_data_bytes?: number | null | undefined;
+                    data_transfer_bytes?: number | null | undefined;
+                    logical_size_bytes?: number | null | undefined;
+                } | null | undefined;
+                allowed_ips?: {
+                    ips?: string[] | null | undefined;
+                    protected_branches_only?: boolean | null | undefined;
+                } | null | undefined;
+                enable_logical_replication?: boolean | null | undefined;
+                maintenance_window?: {
+                    weekdays: number[];
+                    start_time: string;
+                    end_time: string;
+                } | null | undefined;
+                block_public_connections?: boolean | null | undefined;
+                block_vpc_connections?: boolean | null | undefined;
+                audit_log_level?: import("@neon/sdk").ProjectAuditLogLevel | null | undefined;
+                hipaa?: boolean | null | undefined;
+                preload_libraries?: {
+                    use_defaults?: boolean | null | undefined;
+                    enabled_libraries?: string[] | null | undefined;
+                } | null | undefined;
+            } | null | undefined;
+            pg_version: import("@neon/sdk").PgVersion;
+            proxy_host: string;
+            branch_logical_size_limit: number;
+            branch_logical_size_limit_bytes: number;
+            store_passwords: boolean;
+            maintenance_starts_at?: string | null | undefined;
+            creation_source: string;
+            history_retention_seconds: number;
+            created_at: string;
+            updated_at: string;
+            synthetic_storage_size?: number | null | undefined;
+            consumption_period_start: string;
+            consumption_period_end: string;
+            quota_reset_at?: string | null | undefined;
+            owner_id: string;
+            owner?: {
+                email: string;
+                name: string;
+                branches_limit: number;
+                subscription_type: import("@neon/sdk").BillingSubscriptionType;
+            } | null | undefined;
+            compute_last_active_at?: string | null | undefined;
+            org_id?: string | null | undefined;
+            maintenance_scheduled_for?: string | null | undefined;
+            hipaa_enabled_at?: string | null | undefined;
+            effective_project_permission?: (import("@neon/sdk").ProjectPermissionLevel | null) | undefined;
+        };
+        connectionString: string;
+    }>;
+};
+export type WorkflowFactories = typeof workflowFactories;
+export declare const isNeonWorkflowId: (id: string) => id is NeonWorkflowId;
+export declare const workflowFactoryFor: (workflowId: NeonWorkflowId) => WorkflowFactories[NeonWorkflowId];
+//# sourceMappingURL=workflows.d.ts.map

package/dist/lib/workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/lib/workflows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/E,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,OAAO,EAEN,KAAK,oBAAoB,EAEzB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAEX,QAAQ,EAER,MAAM,gBAAgB,CAAC;AAGxB,MAAM,WAAW,qBAAqB;IACrC,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,IAAI,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;CAC1B;AAkBD,eAAO,MAAM,kCAAkC;;;;;;;;;;kBAY7C,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG7C,CAAC;AAEH,eAAO,MAAM,WAAW,iEAGd,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAkI1D,eAAO,MAAM,iBAAiB;uCA1EgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA6CrB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgClE,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAEzD,eAAO,MAAM,gBAAgB,GAAI,IAAI,MAAM,KAAG,EAAE,IAAI,cACJ,CAAC;AAEjD,eAAO,MAAM,kBAAkB,GAC9B,YAAY,cAAc,KACxB,iBAAiB,CAAC,cAAc,CAQlC,CAAC"}

package/dist/lib/workflows.js

@@ -0,0 +1,113 @@
+import { missingBearerCredential, requireBearerCredential } from "./auth.js";
+import { zBranchCreateRequest, zComputeUnit, zCreateProjectBody, zCreateProjectBranchPath, zSuspendTimeoutSeconds } from "../generated/zod.gen.js";
+import { toToolResult } from "./result.js";
+import { createNeonClient } from "@neon/sdk";
+import * as z from "zod";
+//#region src/lib/workflows.ts
+const branchCreateFields = zBranchCreateRequest.shape.branch.unwrap().shape;
+const projectCreateFields = zCreateProjectBody.shape.project.shape;
+const writeAnnotations = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	openWorldHint: true
+};
+const pooledField = z.boolean().describe("Return a pooled connection string. Default true. Set false for a direct connection.").optional();
+const createBranchWithComputeInputSchema = z.strictObject({
+	project_id: zCreateProjectBranchPath.shape.project_id,
+	name: branchCreateFields.name,
+	parent_id: branchCreateFields.parent_id,
+	compute: z.strictObject({
+		min_cu: zComputeUnit.optional(),
+		max_cu: zComputeUnit.optional(),
+		suspend_timeout_seconds: zSuspendTimeoutSeconds.optional()
+	}).optional(),
+	pooled: pooledField
+});
+const createProjectAndConnectInputSchema = z.strictObject({
+	...projectCreateFields,
+	pooled: pooledField
+});
+const workflowIds = ["createBranchWithCompute", "createProjectAndConnect"];
+const resolveApiKey = (options, context) => {
+	if (context !== void 0 && "apiKey" in context) {
+		if (context.apiKey === void 0) throw new TypeError("A Neon API key or OAuth access token is required");
+		return requireBearerCredential(context.apiKey);
+	}
+	return options.apiKey === void 0 ? missingBearerCredential : requireBearerCredential(options.apiKey);
+};
+const workflowClient = (options, context) => createNeonClient({
+	apiKey: resolveApiKey(options, context),
+	throwOnError: true,
+	...options.baseUrl === void 0 ? {} : { baseUrl: options.baseUrl },
+	...options.fetch === void 0 ? {} : { fetch: options.fetch },
+	...options.wait === void 0 ? {} : { wait: options.wait }
+});
+const bindWorkflow = (options, tool, run) => ({
+	...tool,
+	async execute(input, context) {
+		const parsed = await tool.inputSchema.parseAsync(input);
+		const result = await run(workflowClient(options, context), parsed, context?.signal);
+		return toToolResult(result);
+	}
+});
+const createBranchWithComputeTool = (options) => bindWorkflow(options, {
+	operationId: "createBranchWithCompute",
+	id: "create_branch_with_compute",
+	title: "Create branch with compute",
+	description: "Create a branch with a read-write endpoint and return its connection string. Use this instead of create_project_branch when the next step needs to connect: create_project_branch omits compute unless you pass endpoints, and it does not wait or return a connection string. The call waits until the compute is ready, up to five minutes by default.",
+	inputSchema: createBranchWithComputeInputSchema,
+	annotations: writeAnnotations,
+	requiresApproval: true,
+	metadata: {
+		method: "POST",
+		path: "/projects/{project_id}/branches",
+		stability: "stable",
+		deprecated: false,
+		tags: ["Branch"]
+	}
+}, (neon, input, signal) => neon.branches.createWithCompute(input.project_id, {
+	name: input.name,
+	parentId: input.parent_id,
+	compute: input.compute === void 0 ? void 0 : {
+		minCu: input.compute.min_cu,
+		maxCu: input.compute.max_cu,
+		suspendTimeoutSeconds: input.compute.suspend_timeout_seconds
+	}
+}, {
+	signal,
+	...input.pooled === void 0 ? {} : { pooled: input.pooled }
+}));
+const createProjectAndConnectTool = (options) => bindWorkflow(options, {
+	operationId: "createProjectAndConnect",
+	id: "create_project_and_connect",
+	title: "Create project and connect",
+	description: "Create a project and return a connection string to its default branch. Use this instead of create_project when the next step needs to connect. The call waits until the default compute is ready, up to five minutes by default.",
+	inputSchema: createProjectAndConnectInputSchema,
+	annotations: writeAnnotations,
+	requiresApproval: true,
+	metadata: {
+		method: "POST",
+		path: "/projects",
+		stability: "stable",
+		deprecated: false,
+		tags: ["Project"]
+	}
+}, (neon, input, signal) => {
+	const { pooled, ...project } = input;
+	return neon.projects.createAndConnect(project, {
+		signal,
+		...pooled === void 0 ? {} : { pooled }
+	});
+});
+const workflowFactories = {
+	createBranchWithCompute: createBranchWithComputeTool,
+	createProjectAndConnect: createProjectAndConnectTool
+};
+const isNeonWorkflowId = (id) => workflowIds.includes(id);
+const workflowFactoryFor = (workflowId) => {
+	const knownWorkflowId = workflowIds.find((candidate) => candidate === workflowId);
+	if (knownWorkflowId === void 0) throw new TypeError(`Unknown Neon workflow "${workflowId}".`);
+	return workflowFactories[knownWorkflowId];
+};
+//#endregion
+export { createBranchWithComputeInputSchema, createProjectAndConnectInputSchema, isNeonWorkflowId, workflowFactories, workflowFactoryFor, workflowIds };