@neon/tools 0.4.0 → 0.6.0

package/dist/lib/ergonomic/composed.d.ts

@@ -0,0 +1,450 @@
+import * as z from "zod";
+import { type ToolClientOptions } from "./bind.js";
+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 getDefaultInputSchema: z.ZodObject<{
+    project_id: z.ZodString;
+}, z.core.$strict>;
+export declare const connectionStringInputSchema: z.ZodObject<{
+    project_id: z.ZodString;
+    branch_id: z.ZodOptional<z.ZodString>;
+    endpoint_id: z.ZodOptional<z.ZodString>;
+    database_name: z.ZodString;
+    role_name: z.ZodString;
+    pooled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const restoreSnapshotInputSchema: z.ZodObject<{
+    project_id: z.ZodString;
+    snapshot_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    target_branch_id: z.ZodOptional<z.ZodString>;
+    finalize: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const setScheduleInputSchema: z.ZodObject<{
+    project_id: z.ZodString;
+    branch_id: z.ZodString;
+    schedule: z.ZodArray<z.ZodObject<{
+        frequency: z.ZodEnum<{
+            daily: "daily";
+            monthly: "monthly";
+            weekly: "weekly";
+        }>;
+        hour: z.ZodOptional<z.ZodInt>;
+        day: z.ZodOptional<z.ZodInt>;
+        month: z.ZodOptional<z.ZodInt>;
+        retention_seconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const createBranchWithComputeTool: (options: ToolClientOptions) => import("../operation.js").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>, "branches_create_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;
+}>;
+export declare const createProjectAndConnectTool: (options: ToolClientOptions) => import("../operation.js").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>, "projects_create_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 declare const getDefaultTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+    project_id: z.ZodString;
+}, z.core.$strict>, "branches_get_default", {
+    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;
+}>;
+export declare const connectionStringTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+    project_id: z.ZodString;
+    branch_id: z.ZodOptional<z.ZodString>;
+    endpoint_id: z.ZodOptional<z.ZodString>;
+    database_name: z.ZodString;
+    role_name: z.ZodString;
+    pooled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, "postgres_connection_string", string>;
+export declare const restoreSnapshotTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+    project_id: z.ZodString;
+    snapshot_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    target_branch_id: z.ZodOptional<z.ZodString>;
+    finalize: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, "snapshots_restore", {
+    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;
+}>;
+export declare const setScheduleTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+    project_id: z.ZodString;
+    branch_id: z.ZodString;
+    schedule: z.ZodArray<z.ZodObject<{
+        frequency: z.ZodEnum<{
+            daily: "daily";
+            monthly: "monthly";
+            weekly: "weekly";
+        }>;
+        hour: z.ZodOptional<z.ZodInt>;
+        day: z.ZodOptional<z.ZodInt>;
+        month: z.ZodOptional<z.ZodInt>;
+        retention_seconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, "snapshots_set_schedule", null>;
+//# sourceMappingURL=composed.d.ts.map

package/dist/lib/ergonomic/composed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composed.d.ts","sourceRoot":"","sources":["../../../src/lib/ergonomic/composed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,OAAO,EAAY,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAuB7D,eAAO,MAAM,kCAAkC;;;;;;;;;;kBAY7C,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG7C,CAAC;AAEH,eAAO,MAAM,qBAAqB;;kBAEhC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;kBAOtC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;kBAWrC,CAAC;AAIH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;kBASjC,CAAC;AAEH,eAAO,MAAM,2BAA2B,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CpE,CAAC;AAEH,eAAO,MAAM,2BAA2B,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BpE,CAAC;AAEH,eAAO,MAAM,cAAc,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBvD,CAAC;AAEH,eAAO,MAAM,oBAAoB,GAAI,SAAS,iBAAiB;;;;;;;yDA0C7D,CAAC;AAEH,eAAO,MAAM,mBAAmB,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B5D,CAAC;AAEH,eAAO,MAAM,eAAe,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;mDA2BxD,CAAC"}

package/dist/lib/ergonomic/composed.js

@@ -0,0 +1,186 @@
+import { zBackupScheduleItem, zBranchCreateRequest, zComputeUnit, zCreateProjectBody, zCreateProjectBranchPath, zGetConnectionUriPath, zGetConnectionUriQuery, zListProjectBranchesPath, zRestoreSnapshotBody, zRestoreSnapshotPath, zSetSnapshotSchedulePath, zSuspendTimeoutSeconds } from "../../generated/zod.gen.js";
+import { bindTool } from "./bind.js";
+import * as z from "zod";
+//#region src/lib/ergonomic/composed.ts
+const writeAnnotations = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	openWorldHint: true
+};
+const readAnnotations = {
+	readOnlyHint: true,
+	openWorldHint: true
+};
+const pooledField = z.boolean().describe("Return a pooled connection string. Default true. Set false for a direct connection.").optional();
+const branchCreateFields = zBranchCreateRequest.shape.branch.unwrap().shape;
+const projectCreateFields = zCreateProjectBody.shape.project.shape;
+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 getDefaultInputSchema = z.strictObject({ project_id: zListProjectBranchesPath.shape.project_id });
+const connectionStringInputSchema = z.strictObject({
+	project_id: zGetConnectionUriPath.shape.project_id,
+	branch_id: zGetConnectionUriQuery.shape.branch_id,
+	endpoint_id: zGetConnectionUriQuery.shape.endpoint_id,
+	database_name: zGetConnectionUriQuery.shape.database_name,
+	role_name: zGetConnectionUriQuery.shape.role_name,
+	pooled: pooledField
+});
+const restoreSnapshotInputSchema = z.strictObject({
+	project_id: zRestoreSnapshotPath.shape.project_id,
+	snapshot_id: zRestoreSnapshotPath.shape.snapshot_id,
+	name: zRestoreSnapshotBody.shape.name,
+	target_branch_id: zRestoreSnapshotBody.shape.target_branch_id,
+	finalize: z.boolean().describe("Finalize immediately (move computes onto the restored branch). Defaults to true when restoring as a new branch and false when restoring onto an existing branch.").optional()
+});
+const snapshotFrequency = z.enum([
+	"daily",
+	"weekly",
+	"monthly"
+]);
+const setScheduleInputSchema = z.strictObject({
+	project_id: zSetSnapshotSchedulePath.shape.project_id,
+	branch_id: zSetSnapshotSchedulePath.shape.branch_id,
+	schedule: z.array(z.strictObject({
+		...zBackupScheduleItem.shape,
+		frequency: snapshotFrequency
+	}))
+});
+const createBranchWithComputeTool = (options) => bindTool(options, {
+	operationId: "branches.createWithCompute",
+	id: "branches_create_with_compute",
+	title: "Create branch with compute",
+	description: "Create a branch with a read-write endpoint and return its connection string. The call waits until operation-backed provisioning finishes, 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) => bindTool(options, {
+	operationId: "projects.createAndConnect",
+	id: "projects_create_and_connect",
+	title: "Create project and connect",
+	description: "Create a project and return a connection string to its default branch. The call waits until operation-backed provisioning finishes, 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 getDefaultTool = (options) => bindTool(options, {
+	operationId: "branches.getDefault",
+	id: "branches_get_default",
+	title: "Get default branch",
+	description: "Resolve the project's default branch by the default flag, not by name.",
+	inputSchema: getDefaultInputSchema,
+	annotations: readAnnotations,
+	requiresApproval: false,
+	metadata: {
+		method: "GET",
+		path: "/projects/{project_id}/branches",
+		stability: "stable",
+		deprecated: false,
+		tags: ["Branch"]
+	}
+}, (neon, input, signal) => neon.branches.getDefault(input.project_id, { signal }));
+const connectionStringTool = (options) => bindTool(options, {
+	operationId: "postgres.connectionString",
+	id: "postgres_connection_string",
+	title: "Get connection string",
+	description: "Resolve a Postgres connection string. Auto-selects the default branch and the sole role and database when those are omitted. Errors when the selection is ambiguous.",
+	inputSchema: connectionStringInputSchema,
+	annotations: readAnnotations,
+	requiresApproval: true,
+	metadata: {
+		method: "GET",
+		path: "/projects/{project_id}/connection_uri",
+		stability: "stable",
+		deprecated: false,
+		tags: ["Project"]
+	}
+}, (neon, input, signal) => neon.postgres.connectionString({
+	projectId: input.project_id,
+	...input.branch_id === void 0 ? {} : { branchId: input.branch_id },
+	...input.endpoint_id === void 0 ? {} : { endpointId: input.endpoint_id },
+	...input.database_name === void 0 ? {} : { databaseName: input.database_name },
+	...input.role_name === void 0 ? {} : { roleName: input.role_name },
+	...input.pooled === void 0 ? {} : { pooled: input.pooled }
+}, { signal }));
+const restoreSnapshotTool = (options) => bindTool(options, {
+	operationId: "snapshots.restore",
+	id: "snapshots_restore",
+	title: "Restore snapshot",
+	description: "Restore a snapshot onto a new or existing branch. The call waits until operation-backed provisioning finishes. Preview callbacks are not available on this tool.",
+	inputSchema: restoreSnapshotInputSchema,
+	annotations: writeAnnotations,
+	requiresApproval: true,
+	metadata: {
+		method: "POST",
+		path: "/projects/{project_id}/snapshots/{snapshot_id}/restore",
+		stability: "stable",
+		deprecated: false,
+		tags: ["Snapshot"]
+	}
+}, (neon, input, signal) => neon.snapshots.restore(input.project_id, input.snapshot_id, {
+	name: input.name,
+	targetBranchId: input.target_branch_id,
+	finalize: input.finalize
+}, { signal }));
+const setScheduleTool = (options) => bindTool(options, {
+	operationId: "snapshots.setSchedule",
+	id: "snapshots_set_schedule",
+	title: "Set snapshot schedule",
+	description: "Replace a branch's automatic snapshot schedule. Frequency must be daily, weekly, or monthly.",
+	inputSchema: setScheduleInputSchema,
+	annotations: writeAnnotations,
+	requiresApproval: true,
+	metadata: {
+		method: "PUT",
+		path: "/projects/{project_id}/branches/{branch_id}/backup_schedule",
+		stability: "stable",
+		deprecated: false,
+		tags: ["Snapshot"]
+	}
+}, (neon, input, signal) => neon.snapshots.setSchedule(input.project_id, input.branch_id, { schedule: input.schedule }, { signal }));
+//#endregion
+export { connectionStringInputSchema, connectionStringTool, createBranchWithComputeInputSchema, createBranchWithComputeTool, createProjectAndConnectInputSchema, createProjectAndConnectTool, getDefaultInputSchema, getDefaultTool, restoreSnapshotInputSchema, restoreSnapshotTool, setScheduleInputSchema, setScheduleTool };

package/dist/lib/ergonomic/ids.d.ts

@@ -0,0 +1,7 @@
+export declare const hiddenToolIds: readonly ["operations.waitFor", "branches.create", "projects.create", "postgres.roles.password", "storage.objects.get"];
+export type HiddenToolId = (typeof hiddenToolIds)[number];
+export declare const toolIds: readonly ["projects.list", "projects.get", "projects.createAndConnect", "projects.update", "projects.delete", "projects.recover", "projects.transfer", "projects.transferFromUser", "projects.permissions.list", "projects.permissions.grant", "projects.permissions.revoke", "projects.members.list", "projects.members.setRole", "projects.members.removeRole", "branches.list", "branches.get", "branches.createWithCompute", "branches.update", "branches.delete", "branches.getDefault", "branches.setDefault", "branches.finalizeRestore", "postgres.connectionString", "postgres.endpoints.list", "postgres.endpoints.listByBranch", "postgres.endpoints.get", "postgres.endpoints.create", "postgres.endpoints.update", "postgres.endpoints.delete", "postgres.endpoints.start", "postgres.endpoints.suspend", "postgres.endpoints.restart", "postgres.roles.list", "postgres.roles.get", "postgres.roles.create", "postgres.roles.delete", "postgres.roles.resetPassword", "postgres.databases.list", "postgres.databases.get", "postgres.databases.create", "postgres.databases.update", "postgres.databases.delete", "postgres.dataApi.get", "postgres.dataApi.create", "postgres.dataApi.update", "postgres.dataApi.delete", "storage.get", "storage.buckets.list", "storage.buckets.create", "storage.buckets.delete", "storage.objects.list", "storage.objects.delete", "storage.objects.deleteByPrefix", "storage.objects.presign", "functions.list", "functions.get", "functions.update", "functions.delete", "functions.deploy", "credentials.list", "credentials.create", "credentials.revoke", "aiGateway.get", "logs.query", "logs.fields", "logs.fieldValues", "snapshots.list", "snapshots.create", "snapshots.update", "snapshots.delete", "snapshots.restore", "snapshots.getSchedule", "snapshots.setSchedule", "operations.list", "operations.get", "auth.get", "auth.create", "auth.disable", "auth.updateConfig", "auth.oauthProviders.list", "auth.oauthProviders.add", "auth.oauthProviders.update", "auth.oauthProviders.delete", "auth.trustedDomains.list", "auth.trustedDomains.add", "auth.trustedDomains.delete", "auth.users.create", "auth.users.delete", "auth.users.updateRole", "consumption.perProject", "consumption.perProjectV2", "consumption.perBranchV2", "apiKeys.list", "apiKeys.create", "apiKeys.revoke", "regions.list", "user.me", "user.organizations"];
+export type NeonToolId = (typeof toolIds)[number];
+export declare const isNeonToolId: (id: string) => id is NeonToolId;
+export declare const unpublishedToolError: (id: string) => TypeError;
+//# sourceMappingURL=ids.d.ts.map

package/dist/lib/ergonomic/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../src/lib/ergonomic/ids.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,yHAMhB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1D,eAAO,MAAM,OAAO,gxEAmGV,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAElD,eAAO,MAAM,YAAY,GAAI,IAAI,MAAM,KAAG,EAAE,IAAI,UACJ,CAAC;AAa7C,eAAO,MAAM,oBAAoB,GAAI,IAAI,MAAM,KAAG,SAOjD,CAAC"}