@neon/tools 0.0.0 → 0.3.0

package/dist/generated/zod.gen.js

@@ -0,0 +1,2394 @@
+import * as z from "zod";
+//#region src/generated/zod.gen.ts
+const zComputeUnit = z.number().gte(.25);
+const zProvisioner = z.string();
+/**
+* Cursor-based pagination. The `cursor` value reflects the endpoint's sort field (for example, an ID or timestamp), so pass it back unchanged.
+*/
+const zPagination = z.strictObject({ cursor: z.string().min(1).register(z.globalRegistry, { description: "Cursor marking the last item in this response. Pass it unchanged as the `cursor` query parameter to fetch the next page." }) }).register(z.globalRegistry, { description: "Cursor-based pagination. The `cursor` value reflects the endpoint's sort field (for example, an ID or timestamp), so pass it back unchanged." });
+const zPaginationResponse = z.strictObject({ pagination: zPagination.optional() });
+/**
+* Empty response.
+*/
+const zEmptyResponse = z.record(z.string(), z.unknown()).register(z.globalRegistry, { description: "Empty response." });
+const zPlanVersion = z.strictObject({
+	major: z.int(),
+	minor: z.int()
+});
+const zPlanDetails = z.strictObject({
+	name: z.string().register(z.globalRegistry, { description: "Plan name, for example `free`, `launch`, or `scale`." }),
+	version: zPlanVersion.optional()
+});
+/**
+* Add a new JWKS to a specific endpoint of a project
+*/
+const zAddProjectJwksRequest = z.strictObject({
+	jwks_url: z.string().register(z.globalRegistry, { description: "URL of the provider's JWKS endpoint used to verify JWTs." }),
+	provider_name: z.string().register(z.globalRegistry, { description: "The name of the authentication provider (e.g., Clerk, Stytch, Auth0)" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID. Returned as `id` from `GET /projects/{project_id}/branches`." }).optional(),
+	jwt_audience: z.string().register(z.globalRegistry, { description: "Expected `aud` claim in incoming JWTs. When set, tokens with a different audience are rejected; tokens with no audience are still accepted. Omit to skip audience validation." }).optional(),
+	role_names: z.array(z.string()).min(0).max(10).register(z.globalRegistry, { description: "Deprecated. The roles the JWKS should be mapped to. By default, the JWKS is mapped to the `authenticator`, `authenticated`, and `anonymous` roles." }).optional(),
+	skip_role_creation: z.boolean().register(z.globalRegistry, { description: "Deprecated. Only used with Neon RLS. If true, role creation is skipped." }).optional()
+}).register(z.globalRegistry, { description: "Add a new JWKS to a specific endpoint of a project" });
+const zJwks = z.strictObject({
+	id: z.string().register(z.globalRegistry, { description: "The JWKS configuration's ID." }),
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID. Returned as `id` from `GET /projects`." }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID. Returned as `id` from `GET /projects/{project_id}/branches`." }).optional(),
+	jwks_url: z.string().register(z.globalRegistry, { description: "URL of the provider's JWKS endpoint used to verify JWTs." }),
+	provider_name: z.string().register(z.globalRegistry, { description: "The name of the authentication provider (e.g., Clerk, Stytch, Auth0)" }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "The date and time when the JWKS was created" }),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "The date and time when the JWKS was last modified" }),
+	jwt_audience: z.string().register(z.globalRegistry, { description: "Expected JWT `aud` claim value configured for this JWKS." }).optional(),
+	role_names: z.array(z.string()).register(z.globalRegistry, { description: "Database role names that are permitted to authenticate using this JWKS configuration." }).optional()
+});
+/**
+* The list of configured JWKS definitions for a project
+*/
+const zProjectJwksResponse = z.strictObject({ jwks: z.array(zJwks).register(z.globalRegistry, { description: "JWKS configurations associated with the project." }) }).register(z.globalRegistry, { description: "The list of configured JWKS definitions for a project" });
+/**
+* Category of an advisor issue
+*/
+const zAdvisorCategory = z.enum(["SECURITY", "PERFORMANCE"]).register(z.globalRegistry, { description: "Category of an advisor issue" });
+const zAdvisorIssue = z.strictObject({
+	name: z.string().register(z.globalRegistry, { description: "Unique identifier for the issue type" }),
+	title: z.string().register(z.globalRegistry, { description: "Human-readable title" }),
+	level: z.string().register(z.globalRegistry, { description: "Severity level of the issue" }),
+	facing: z.enum(["EXTERNAL", "INTERNAL"]).register(z.globalRegistry, { description: "Whether this issue affects external API exposure or is internal only" }),
+	categories: z.array(zAdvisorCategory).register(z.globalRegistry, { description: "Categories this issue belongs to" }),
+	description: z.string().register(z.globalRegistry, { description: "Detailed description of what this check detects" }),
+	detail: z.string().register(z.globalRegistry, { description: "Specific details about this instance of the issue" }),
+	remediation: z.string().register(z.globalRegistry, { description: "URL to documentation on how to fix this issue" }),
+	metadata: z.record(z.string(), z.unknown()).register(z.globalRegistry, { description: "Additional context-specific metadata" }),
+	cache_key: z.string().register(z.globalRegistry, { description: "Unique key for caching this issue result" })
+});
+const zApiKeyCreateRequest = z.strictObject({ key_name: z.string().max(64).register(z.globalRegistry, { description: "A user-specified API key name. This value is required when creating an API key." }) });
+const zOrgApiKeyCreateRequest = zApiKeyCreateRequest.merge(z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "If set, the API key can access only this project" }).optional() }));
+const zApiKeyCreateResponse = z.strictObject({
+	id: z.int().register(z.globalRegistry, { description: "The API key's unique numeric ID. Distinct from the API key token (`key`)." }),
+	key: z.string().register(z.globalRegistry, { description: "The generated 64-bit token required to access the Neon API" }),
+	name: z.string().register(z.globalRegistry, { description: "The user-specified API key name" }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the API key was created" }),
+	created_by: z.uuid().register(z.globalRegistry, { description: "ID of the user who created this API key" })
+});
+const zOrgApiKeyCreateResponse = zApiKeyCreateResponse.merge(z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "If set, the API key can access only this project" }).optional() }));
+const zApiKeyRevokeResponse = z.strictObject({
+	id: z.int().register(z.globalRegistry, { description: "The API key's unique numeric ID. Distinct from the API key token (`key`)." }),
+	name: z.string().register(z.globalRegistry, { description: "The user-specified API key name" }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the API key was created" }),
+	created_by: z.uuid().register(z.globalRegistry, { description: "ID of the user who created this API key" }),
+	last_used_at: z.iso.datetime().nullish(),
+	last_used_from_addr: z.string().register(z.globalRegistry, { description: "The IP address from which the API key was last used" }),
+	revoked: z.boolean().register(z.globalRegistry, { description: "A `true` or `false` value indicating whether the API key is revoked" })
+});
+const zOrgApiKeyRevokeResponse = zApiKeyRevokeResponse.merge(z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "If set, the API key can access only this project" }).optional() }));
+/**
+* The user data of the user that created this API key.
+*/
+const zApiKeyCreatorData = z.strictObject({
+	id: z.uuid().register(z.globalRegistry, { description: "ID of the user who created this API key" }),
+	name: z.string().register(z.globalRegistry, { description: "Display name of the user who created the API key." }),
+	image: z.string().register(z.globalRegistry, { description: "The URL to the user's avatar image." })
+}).register(z.globalRegistry, { description: "The user data of the user that created this API key." });
+const zApiKeysListResponseItem = z.strictObject({
+	id: z.int().register(z.globalRegistry, { description: "The API key's unique numeric ID. Distinct from the API key token (`key`)." }),
+	name: z.string().register(z.globalRegistry, { description: "The user-specified API key name" }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the API key was created" }),
+	created_by: zApiKeyCreatorData,
+	last_used_at: z.iso.datetime().nullish(),
+	last_used_from_addr: z.string().register(z.globalRegistry, { description: "The IP address from which the API key was last used" })
+});
+const zOrgApiKeysListResponseItem = zApiKeysListResponseItem.merge(z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "If set, the API key can access only this project" }).optional() }));
+/**
+* The action performed by the operation
+*/
+const zOperationAction = z.enum([
+	"create_compute",
+	"create_timeline",
+	"start_compute",
+	"suspend_compute",
+	"apply_config",
+	"check_availability",
+	"delete_timeline",
+	"create_branch",
+	"import_data",
+	"tenant_ignore",
+	"tenant_attach",
+	"tenant_detach",
+	"tenant_detach_safekeepers",
+	"tenant_attach_safekeepers",
+	"tenant_reattach",
+	"replace_safekeeper",
+	"disable_maintenance",
+	"apply_storage_config",
+	"prepare_secondary_pageserver",
+	"switch_pageserver",
+	"detach_parent_branch",
+	"timeline_archive",
+	"timeline_unarchive",
+	"start_reserved_compute",
+	"sync_dbs_and_roles_from_compute",
+	"apply_schema_from_branch",
+	"timeline_mark_invisible",
+	"timeline_update_protected_config",
+	"prewarm_replica",
+	"promote_replica",
+	"set_storage_non_dirty",
+	"swap_binding_id",
+	"finalize_migration",
+	"mark_migration_prepared",
+	"update_catalog",
+	"epc_sync"
+]).register(z.globalRegistry, { description: "The action performed by the operation" });
+/**
+* Lifecycle state of the operation. `scheduling`: queued, not yet started. `running`: actively executing. `finished`: completed successfully. `failed`: ended with a failure. `error`: ended with a terminal error. `cancelling`: cancellation requested but not yet complete. `cancelled`: stopped before completion. `skipped`: bypassed without executing.
+*/
+const zOperationStatus = z.enum([
+	"scheduling",
+	"running",
+	"finished",
+	"failed",
+	"error",
+	"cancelling",
+	"cancelled",
+	"skipped"
+]).register(z.globalRegistry, { description: "Lifecycle state of the operation. `scheduling`: queued, not yet started. `running`: actively executing. `finished`: completed successfully. `failed`: ended with a failure. `error`: ended with a terminal error. `cancelling`: cancellation requested but not yet complete. `cancelled`: stopped before completion. `skipped`: bypassed without executing." });
+/**
+* An asynchronous action Neon performs on your resources (for example, starting a compute or creating a branch). Fields such as `action`, `status`, and `total_duration_ms` describe the operation and its progress.
+*/
+const zOperation = z.strictObject({
+	id: z.uuid().register(z.globalRegistry, { description: "The operation ID" }),
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the project this operation ran on." }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the branch this operation ran on." }).optional(),
+	endpoint_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the compute endpoint this operation ran on." }).optional(),
+	action: zOperationAction,
+	status: zOperationStatus,
+	error: z.string().register(z.globalRegistry, { description: "Human-readable message describing why the operation failed." }).optional(),
+	failures_count: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The number of times the operation failed" }),
+	retry_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the operation was last retried" }).optional(),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the operation was created" }),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the operation status was last updated" }),
+	total_duration_ms: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The total duration of the operation in milliseconds" })
+}).register(z.globalRegistry, { description: "An asynchronous action Neon performs on your resources (for example, starting a compute or creating a branch). Fields such as `action`, `status`, and `total_duration_ms` describe the operation and its progress." });
+const zOperationResponse = z.strictObject({ operation: zOperation });
+const zOperationsResponse = z.strictObject({ operations: z.array(zOperation) });
+const zProjectTransferRequestResponse = z.strictObject({
+	id: z.uuid().register(z.globalRegistry, { description: "The unique identifier for the transfer request" }),
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the project that is being transferred" }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "The timestamp when the transfer request was created" }),
+	expires_at: z.iso.datetime().register(z.globalRegistry, { description: "The timestamp when the transfer request will expire" })
+});
+const zAcceptProjectTransferRequestSatisfiesPlanError = z.strictObject({ reasons: z.array(z.strictObject({
+	message: z.string().register(z.globalRegistry, { description: "Description of why the plan is not satisfied" }),
+	code: z.string().register(z.globalRegistry, { description: "A short code identifying the reason" })
+})).register(z.globalRegistry, { description: "List of reasons why the target account's plan cannot satisfy the transfer requirements. Each item contains a `code` identifying the constraint and a `message` with a human-readable explanation." }) });
+const zProjectPermission = z.strictObject({
+	id: z.string().register(z.globalRegistry, { description: "The project permission's ID." }),
+	granted_to_email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address of the user who has been granted access to the project." }),
+	granted_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp when the permission was granted." }),
+	revoked_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp when the permission was revoked. Null if the permission is still active." }).optional()
+});
+const zProjectPermissions = z.strictObject({ project_permissions: z.array(zProjectPermission) });
+const zGrantPermissionToProjectRequest = z.strictObject({ email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address of the user to grant project access to." }) });
+/**
+* Per-project role. `viewer` maps to `VIEWER`, `editor` maps to `EDITOR`,
+* and `admin` maps to `ADMIN`.
+*
+*/
+const zProjectRole = z.enum([
+	"viewer",
+	"editor",
+	"admin"
+]).register(z.globalRegistry, { description: "Per-project role. `viewer` maps to `VIEWER`, `editor` maps to `EDITOR`,\nand `admin` maps to `ADMIN`.\n" });
+/**
+* The caller's effective permission for a project when
+* per-project permissions are enabled. `VIEWER` grants read access,
+* `EDITOR` adds update access, and `ADMIN` grants full management.
+* Omitted for personal projects, flag-off organizations, and non-user
+* subjects.
+*
+*/
+const zProjectPermissionLevel = z.enum([
+	"VIEWER",
+	"EDITOR",
+	"ADMIN"
+]).register(z.globalRegistry, { description: "The caller's effective permission for a project when\nper-project permissions are enabled. `VIEWER` grants read access,\n`EDITOR` adds update access, and `ADMIN` grants full management.\nOmitted for personal projects, flag-off organizations, and non-user\nsubjects.\n" });
+/**
+* How a member's project access is granted.
+*
+*/
+const zProjectMemberGrantSource = z.enum([
+	"explicit",
+	"org_role_default",
+	"org_admin_override",
+	"unassigned"
+]).register(z.globalRegistry, { description: "How a member's project access is granted.\n" });
+/**
+* Organization-level role used by project member role management.
+*
+*/
+const zProjectMemberOrgRole = z.enum([
+	"admin",
+	"member",
+	"editor",
+	"viewer",
+	"collaborator"
+]).register(z.globalRegistry, { description: "Organization-level role used by project member role management.\n" });
+const zProjectMember = z.strictObject({
+	member_id: z.uuid().register(z.globalRegistry, { description: "The organization member ID." }),
+	user_id: z.uuid().register(z.globalRegistry, { description: "The user ID for the organization member." }),
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address of the user who has been granted access to the project." }).optional(),
+	name: z.string().register(z.globalRegistry, { description: "The user's display name." }).optional(),
+	org_role: zProjectMemberOrgRole,
+	project_role: zProjectRole.optional(),
+	org_default_project_permission: zProjectPermissionLevel.optional(),
+	explicit_project_permission: zProjectPermissionLevel.optional(),
+	effective_project_permission: zProjectPermissionLevel.optional(),
+	grant_source: zProjectMemberGrantSource.optional()
+});
+const zSetProjectMemberRoleRequest = z.strictObject({ role: zProjectRole });
+const zProjectMemberRoleResponse = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/),
+	member_id: z.uuid(),
+	user_id: z.uuid(),
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address of the user who has been granted access to the project." }).optional(),
+	name: z.string().register(z.globalRegistry, { description: "The user's display name." }).optional(),
+	org_role: zProjectMemberOrgRole,
+	project_role: zProjectRole.optional(),
+	org_default_project_permission: zProjectPermissionLevel.optional(),
+	explicit_project_permission: zProjectPermissionLevel.optional(),
+	effective_project_permission: zProjectPermissionLevel.optional(),
+	credential_rotation_recommended: z.boolean().register(z.globalRegistry, { description: "Hint that database credentials may need rotation after the role change.\n" }).optional(),
+	org_api_key_rotation_recommended: z.boolean().register(z.globalRegistry, { description: "Hint that project-scoped org API keys created by the target user may need rotation.\n" }).optional()
+});
+const zConsumptionHistoryPerTimeframe = z.strictObject({
+	timeframe_start: z.iso.datetime().register(z.globalRegistry, { description: "The specified start date-time for the reported consumption.\n" }),
+	timeframe_end: z.iso.datetime().register(z.globalRegistry, { description: "The specified end date-time for the reported consumption.\n" }),
+	active_time_seconds: z.int().min(0, { error: "Invalid value: Expected uint64 to be >= 0" }).register(z.globalRegistry, { description: "Seconds. The amount of time the compute endpoints have been active.\n" }),
+	compute_time_seconds: z.int().min(0, { error: "Invalid value: Expected uint64 to be >= 0" }).register(z.globalRegistry, { description: "Seconds. The number of CPU seconds used by compute endpoints, including compute endpoints that have been deleted.\n" }),
+	written_data_bytes: z.int().min(0, { error: "Invalid value: Expected uint64 to be >= 0" }).register(z.globalRegistry, { description: "Bytes. The amount of written data for all branches.\n" }),
+	synthetic_storage_size_bytes: z.int().min(0, { error: "Invalid value: Expected uint64 to be >= 0" }).register(z.globalRegistry, { description: "Bytes. The space occupied in Postgres storage. Synthetic Postgres storage size combines the logical data size and Write-Ahead Log (WAL) size for all branches.\n" }),
+	data_storage_bytes_hour: z.int().min(0, { error: "Invalid value: Expected uint64 to be >= 0" }).register(z.globalRegistry, { description: "Bytes-Hour. The amount of Postgres storage consumed hourly.\n" }).optional(),
+	logical_size_bytes: z.int().min(0, { error: "Invalid value: Expected uint64 to be >= 0" }).register(z.globalRegistry, { description: "Bytes. The amount of logical size consumed.\n" }).optional(),
+	logical_size_bytes_hour: z.int().min(0, { error: "Invalid value: Expected uint64 to be >= 0" }).register(z.globalRegistry, { description: "Bytes-Hour. The amount of logical size consumed hourly.\n" }).optional()
+});
+const zConsumptionHistoryPerPeriod = z.strictObject({
+	period_id: z.uuid().register(z.globalRegistry, { description: "The ID assigned to the specified billing period." }),
+	period_plan: z.string().register(z.globalRegistry, { description: "The billing plan applicable during the billing period." }),
+	period_start: z.iso.datetime().register(z.globalRegistry, { description: "The start date-time of the billing period.\n" }),
+	period_end: z.iso.datetime().register(z.globalRegistry, { description: "The end date-time of the billing period, available for the past periods only.\n" }).optional(),
+	consumption: z.array(zConsumptionHistoryPerTimeframe).register(z.globalRegistry, { description: "Consumption metric records for the billing period." })
+});
+const zConsumptionHistoryPerProject = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID. Returned as `id` from `GET /projects`." }),
+	periods: z.array(zConsumptionHistoryPerPeriod).register(z.globalRegistry, { description: "Consumption periods for the project, each covering a discrete billing interval." })
+});
+const zConsumptionHistoryPerProjectResponse = z.strictObject({ projects: z.array(zConsumptionHistoryPerProject).register(z.globalRegistry, { description: "Per-project consumption history records included in the response." }) });
+const zConsumptionMetricValue = z.strictObject({
+	metric_name: z.string().register(z.globalRegistry, { description: "Name of the consumption metric, such as compute_time or data_storage_bytes_hour." }),
+	value: z.int().register(z.globalRegistry, { description: "Measured quantity for the metric named by `metric_name`." })
+});
+const zConsumptionHistoryPerTimeframeV2 = z.strictObject({
+	timeframe_start: z.iso.datetime().register(z.globalRegistry, { description: "The specified start date-time for the reported consumption.\n" }).optional(),
+	timeframe_end: z.iso.datetime().register(z.globalRegistry, { description: "The specified end date-time for the reported consumption.\n" }).optional(),
+	metrics: z.array(zConsumptionMetricValue).register(z.globalRegistry, { description: "Consumption metric values recorded for the timeframe." }).optional()
+});
+const zConsumptionHistoryPerPeriodV2 = z.strictObject({
+	period_id: z.uuid().register(z.globalRegistry, { description: "The ID assigned to the specified billing period." }),
+	period_plan: z.string().register(z.globalRegistry, { description: "The billing plan applicable during the billing period." }),
+	period_start: z.iso.datetime().register(z.globalRegistry, { description: "The start date-time of the billing period.\n" }),
+	period_end: z.iso.datetime().register(z.globalRegistry, { description: "The end date-time of the billing period, available for the past periods only.\n" }).optional(),
+	consumption: z.array(zConsumptionHistoryPerTimeframeV2).register(z.globalRegistry, { description: "Consumption metric records for the billing period." })
+});
+const zConsumptionHistoryPerProjectV2 = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID. Returned as `id` from `GET /projects`." }),
+	periods: z.array(zConsumptionHistoryPerPeriodV2).register(z.globalRegistry, { description: "Consumption periods recorded for this project." })
+});
+const zConsumptionHistoryPerProjectV2Response = z.strictObject({ projects: z.array(zConsumptionHistoryPerProjectV2).register(z.globalRegistry, { description: "Per-project consumption history entries for the requested time range." }) });
+const zConsumptionHistoryPerBranchV2 = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the project that owns this branch." }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID. Returned as `id` from `GET /projects/{project_id}/branches`." }),
+	periods: z.array(zConsumptionHistoryPerPeriodV2).register(z.globalRegistry, { description: "Consumption history records for the branch, grouped by billing period." })
+});
+const zConsumptionHistoryPerBranchV2Response = z.strictObject({ branches: z.array(zConsumptionHistoryPerBranchV2).register(z.globalRegistry, { description: "Per-branch consumption history records returned for the requested time range." }) });
+const zConsumptionHistoryGranularity = z.enum([
+	"hourly",
+	"daily",
+	"monthly"
+]);
+const zConsumptionHistoryQueryMetrics = z.array(z.string());
+const zProjectAuditLogLevel = z.enum([
+	"base",
+	"extended",
+	"full"
+]);
+const zAvailablePreloadLibrary = z.strictObject({
+	library_name: z.string().register(z.globalRegistry, { description: "Name of the Postgres shared preload library as it appears in the `shared_preload_libraries` parameter (for example, `pg_stat_statements`)." }),
+	description: z.string().register(z.globalRegistry, { description: "Human-readable explanation of the library's purpose and behavior." }),
+	is_default: z.boolean().register(z.globalRegistry, { description: "Whether this library is loaded by default in the `shared_preload_libraries` configuration for new compute endpoints." }),
+	is_experimental: z.boolean().register(z.globalRegistry, { description: "Marks the library as experimental. Experimental libraries may be unstable, subject to breaking changes, or not recommended for production use." }),
+	version: z.string().register(z.globalRegistry, { description: "Version of the preload library." })
+});
+const zAvailablePreloadLibraries = z.strictObject({ libraries: z.array(zAvailablePreloadLibrary).register(z.globalRegistry, { description: "Preload libraries available for the project's Postgres version. Each entry includes `library_name`, `description`, `is_default`, `is_experimental`, and `version`." }).optional() });
+/**
+* The branch’s state, indicating if it is initializing, ready for use, or archived.
+* * 'init' - the branch is being created but is not available for querying.
+* * 'resetting' - the branch is being reset to a specific point in time or LSN and is not yet available for querying.
+* * 'ready' - the branch is fully operational and ready for querying. Expect normal query response times.
+* * 'archived' - the branch is stored in cost-effective archival Postgres storage. Expect slow query response times.
+*
+*/
+const zBranchState = z.string().register(z.globalRegistry, { description: "The branch’s state, indicating if it is initializing, ready for use, or archived.\n  * 'init' - the branch is being created but is not available for querying.\n  * 'resetting' - the branch is being reset to a specific point in time or LSN and is not yet available for querying.\n  * 'ready' - the branch is fully operational and ready for querying. Expect normal query response times.\n  * 'archived' - the branch is stored in cost-effective archival Postgres storage. Expect slow query response times.\n" });
+/**
+* Could be `restored`, `finalized` or `detaching`.
+* A `restored` branch becomes permanently `finalized` when you call `finalizeRestoreBranch`
+* A `restored` or `finalized` branch may begin `detaching` as a one-time performance optimisation, after which it will continue in its original state
+*
+*/
+const zBranchRestoreStatus = z.string().register(z.globalRegistry, { description: "Could be `restored`, `finalized` or `detaching`.\nA `restored` branch becomes permanently `finalized` when you call `finalizeRestoreBranch`\nA `restored` or `finalized` branch may begin `detaching` as a one-time performance optimisation, after which it will continue in its original state\n" });
+/**
+* An action that is currently restricted for the branch and the reason why.
+*
+*/
+const zBranchRestrictedAction = z.strictObject({
+	name: z.string().register(z.globalRegistry, { description: "The name of a restricted action on a branch. `restore`: the branch cannot be used as a restore target. `delete-rw-endpoint`: the read-write endpoint for the branch cannot be deleted.\n" }),
+	reason: z.string().register(z.globalRegistry, { description: "A human-readable explanation of why the action is restricted.\n" })
+}).register(z.globalRegistry, { description: "An action that is currently restricted for the branch and the reason why.\n" });
+/**
+* Recovery information for a deleted branch. Only present when listing deleted branches
+* with `include_deleted=true`.
+*
+* This is part of the Branch Recovery feature, which is in preview and not available to all users.
+*
+*/
+const zBranchRecoveryInfo = z.strictObject({
+	deleted_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp when the branch was deleted\n" }),
+	recoverable_until: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp when the recovery window expires and the branch will be permanently deleted\n" }),
+	deletion_method: z.enum(["user", "ttl"]).register(z.globalRegistry, { description: "How the branch was deleted: 'user' for manual deletion, 'ttl' for TTL expiration\n" })
+}).register(z.globalRegistry, { description: "Recovery information for a deleted branch. Only present when listing deleted branches\nwith `include_deleted=true`.\n\nThis is part of the Branch Recovery feature, which is in preview and not available to all users.\n" });
+const zBranch = z.strictObject({
+	id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID. This value is generated when a branch is created. A `branch_id` value has a `br` prefix. For example: `br-small-term-683261`.\n" }),
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the project this branch belongs to." }),
+	parent_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The `branch_id` of the parent branch\n" }).optional(),
+	parent_lsn: z.string().register(z.globalRegistry, { description: "The Log Sequence Number (LSN) on the parent branch from which this branch was created.\nWhen restoring a branch using the `POST /projects/{project_id}/branches/{branch_id}/restore` endpoint,\nthis value isn’t finalized until all operations related to the restore have completed successfully.\n" }).optional(),
+	parent_timestamp: z.iso.datetime().register(z.globalRegistry, { description: "The point in time on the parent branch from which this branch was created.\nWhen restoring a branch using the `POST /projects/{project_id}/branches/{branch_id}/restore` endpoint,\nthis value isn’t finalized until all operations related to the restore have completed successfully.\nAfter all the operations completed, this value might stay empty.\n" }).optional(),
+	name: z.string().register(z.globalRegistry, { description: "The branch name\n" }),
+	current_state: zBranchState,
+	pending_state: zBranchState.optional(),
+	state_changed_at: z.iso.datetime().register(z.globalRegistry, { description: "A UTC timestamp indicating when the `current_state` began\n" }),
+	logical_size: z.int().register(z.globalRegistry, { description: "The logical size of the branch, in bytes\n" }).optional(),
+	creation_source: z.string().register(z.globalRegistry, { description: "The branch creation source\n" }),
+	primary: z.boolean().register(z.globalRegistry, { description: "Deprecated. Use the `default` field. Whether the branch is the project's primary branch.\n" }).optional(),
+	default: z.boolean().register(z.globalRegistry, { description: "Whether the branch is the project's default branch\n" }),
+	protected: z.boolean().register(z.globalRegistry, { description: "Whether the branch is protected. Protected branches (and their computes) cannot be deleted, archived, or reset, and block deletion of the project.\n" }),
+	cpu_used_sec: z.int().register(z.globalRegistry, { description: "Deprecated. Use `compute_time_seconds` instead. CPU seconds used by all of the branch's compute endpoints, including deleted ones. This value is reset at the beginning of each billing period.\n" }),
+	compute_time_seconds: z.int().register(z.globalRegistry, { description: "Total Postgres compute time consumed by this branch during the current billing period, in CU-seconds (weighted by compute size). Divide by 3600 for CU-hours." }),
+	active_time_seconds: z.int().register(z.globalRegistry, { description: "Total time this branch's compute has been active during the current billing period, in seconds (not weighted by compute size). Distinct from `compute_time_seconds`, which is CU-weighted." }),
+	written_data_bytes: z.int().register(z.globalRegistry, { description: "Data written by this branch during the current billing period, in bytes." }),
+	data_transfer_bytes: z.int().register(z.globalRegistry, { description: "Total data transferred out of the branch, in bytes. Used as a consumption metric." }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the branch was created\n" }),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the branch was last updated\n" }),
+	ttl_interval_seconds: z.int().register(z.globalRegistry, { description: "The time-to-live (TTL) duration originally configured for the branch, in seconds. This read-only value represents the interval between the time `expires_at` was set and the expiration timestamp itself. It is preserved to ensure the same TTL duration is reapplied when resetting the branch from its parent, and only updates when a new `expires_at` value is set.\n\nAccess to this feature is currently limited to participants in the Early Access Program.\n" }).optional(),
+	expires_at: z.iso.datetime().register(z.globalRegistry, { description: "The timestamp when the branch is scheduled to expire and be automatically deleted. Must be set by the client following the [RFC 3339, section 5.6](https://tools.ietf.org/html/rfc3339#section-5.6) format with precision up to seconds (such as 2025-06-09T18:02:16Z). Deletion is performed by a background job and may not occur exactly at the specified time.\n\nAccess to this feature is currently limited to participants in the Early Access Program.\n" }).optional(),
+	last_reset_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the branch was last reset\n" }).optional(),
+	created_by: z.strictObject({
+		name: z.string().register(z.globalRegistry, { description: "Display name of the user who created the branch." }).optional(),
+		image: z.string().register(z.globalRegistry, { description: "The URL to the user's avatar image." }).optional()
+	}).register(z.globalRegistry, { description: "The resolved user model that contains details of the user/org/integration/api_key used for branch creation. This field is filled only in listing/get/create/get/update/delete methods, if it is empty when calling other handlers, it does not mean that it is empty in the system.\n" }).optional(),
+	init_source: z.string().register(z.globalRegistry, { description: "Source of initialization for the branch. `parent-data` (default) copies schema and data from the parent. `parent-schema` copies schema only from the parent. `schema-only` creates a root branch with schema only. `import` initializes from an external import.\n" }).optional(),
+	restore_status: zBranchRestoreStatus.optional(),
+	restored_from: z.string().register(z.globalRegistry, { description: "ID of the snapshot that was the restore source for this branch\n" }).optional(),
+	restored_as: z.string().register(z.globalRegistry, { description: "ID of the target branch which was replaced when this branch was restored\n" }).optional(),
+	restricted_actions: z.array(zBranchRestrictedAction).register(z.globalRegistry, { description: "A list of actions that are currently restricted for this branch and the reason why.\n" }).optional(),
+	recovery: zBranchRecoveryInfo.optional()
+});
+const zBranchUpdateRequest = z.strictObject({ branch: z.strictObject({
+	name: z.string().min(1).max(256).register(z.globalRegistry, { description: "New display name for the branch." }).optional(),
+	protected: z.boolean().register(z.globalRegistry, { description: "Whether the branch is protected. Protected branches (and their computes) cannot be deleted, archived, or reset, and block deletion of the project. Can be gated by `protected_branches_only` in the IP allowlist. Paid plans only.\n" }).optional(),
+	expires_at: z.iso.datetime().nullish()
+}).register(z.globalRegistry, { description: "Branch attributes to update. Supply only the fields you want to change, for example `name` or `protected`." }) });
+const zBranchRestoreRequest = z.strictObject({
+	source_branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The `branch_id` of the restore source branch.\nIf `source_timestamp` and `source_lsn` are omitted, the branch will be restored to head.\nIf `source_branch_id` is equal to the branch's id, `source_timestamp` or `source_lsn` is required.\n" }),
+	source_lsn: z.string().register(z.globalRegistry, { description: "A Postgres LSN (for example, `0/1A2B3C4`) on the source branch to restore from.\nMutually exclusive with `source_timestamp`. Omit both to restore to head.\n" }).optional(),
+	source_timestamp: z.iso.datetime().register(z.globalRegistry, { description: "A point in time on the source branch to restore from, in RFC 3339 format. When omitted alongside `source_lsn`, the branch is restored to the latest available state of the source branch.\n" }).optional(),
+	preserve_under_name: z.string().register(z.globalRegistry, { description: "Name under which to save the current branch state before restoring. Required when the branch has children or when `source_branch_id` equals the branch being restored; in those cases all existing child branches are moved to the newly created branch. If omitted and not required, the previous state is not preserved.\n" }).optional()
+});
+const zBranchResponse = z.strictObject({ branch: zBranch });
+const zBranchSchemaCompareResponse = z.strictObject({ diff: z.string().register(z.globalRegistry, { description: "Unified diff of the SQL schema changes between the compared branches." }).optional() });
+const zBranchesResponse = z.strictObject({ branches: z.array(zBranch).register(z.globalRegistry, { description: "Branches in the project. Each includes `id`, `name`, `current_state`, and `created_at`." }) });
+const zBranchesCountResponse = z.strictObject({ count: z.int().register(z.globalRegistry, { description: "Total number of branches in the project." }) });
+const zMaskingRule = z.strictObject({
+	database_name: z.string().register(z.globalRegistry, { description: "The name of the database containing the table to be masked\n" }),
+	schema_name: z.string().register(z.globalRegistry, { description: "The name of the schema containing the table to be masked\n" }),
+	table_name: z.string().register(z.globalRegistry, { description: "The name of the table containing the column to be masked\n" }),
+	column_name: z.string().register(z.globalRegistry, { description: "The name of the column to be masked\n" }),
+	masking_function: z.string().register(z.globalRegistry, { description: "The PostgreSQL Anonymizer masking function to apply.\nCan be a predefined function (e.g., 'anon.random_string(10)', 'anon.fake_email()')\nor a custom function definition (e.g., 'anon.hash(column_name)')\n" }).optional(),
+	masking_value: z.string().register(z.globalRegistry, { description: "A literal value to set on the column when masking.\n" }).optional()
+});
+const zMaskingRulesResponse = z.strictObject({ masking_rules: z.array(zMaskingRule).register(z.globalRegistry, { description: "List of masking rules for the branch\n" }) });
+const zMaskingRulesUpdateRequest = z.strictObject({ masking_rules: z.array(zMaskingRule).register(z.globalRegistry, { description: "List of masking rules to apply to the branch.\nThis will replace all existing masking rules for the branch.\n" }) });
+/**
+* Metadata about the most recent anonymization attempt for the branch.
+*/
+const zAnonymizationRunMetadata = z.strictObject({
+	started_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp indicating when the latest anonymization attempt started.\n" }).optional(),
+	completed_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp indicating when the latest anonymization attempt completed.\nPopulated even if the attempt failed.\n" }).optional(),
+	triggered_by: z.uuid().register(z.globalRegistry, { description: "UUID of the user who triggered the latest anonymization attempt.\n" }).optional(),
+	triggered_by_username: z.string().register(z.globalRegistry, { description: "Username of the user who triggered the latest anonymization attempt.\n" }).optional(),
+	masked_columns: z.int().register(z.globalRegistry, { description: "Number of columns that had masking rules applied during the attempt.\n" }).optional()
+}).register(z.globalRegistry, { description: "Metadata about the most recent anonymization attempt for the branch." });
+const zAnonymizedBranchStatusResponse = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the project this branch belongs to." }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the anonymized branch." }),
+	state: z.string().register(z.globalRegistry, { description: "The current state of the anonymized branch. `created`: branch record exists but setup has not started. `initialized`: setup is complete and the branch is ready for anonymization. `initialization_error`: an error occurred during setup. `anonymizing`: the anonymization process is currently running. `anonymized`: anonymization completed successfully. `error`: an error occurred during anonymization.\n" }),
+	status_message: z.string().register(z.globalRegistry, { description: "A descriptive message about the current status or any errors\n" }).optional(),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the anonymized branch was created\n" }),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the anonymized branch status was last updated\n" }),
+	failed_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the anonymized branch operation failed (if applicable)\n" }).optional(),
+	last_run: zAnonymizationRunMetadata.optional()
+});
+const zConnectionParameters = z.strictObject({
+	database: z.string().register(z.globalRegistry, { description: "Name of the Postgres database used in the connection URI.\n" }),
+	password: z.string().register(z.globalRegistry, { description: "Authentication password for the role, used in the connection URI.\n" }),
+	role: z.string().register(z.globalRegistry, { description: "Postgres role used to authenticate the database connection.\n" }),
+	host: z.string().register(z.globalRegistry, { description: "Hostname of the compute endpoint. Use `pooler_host` for the pooled connection hostname.\n" }),
+	pooler_host: z.string().register(z.globalRegistry, { description: "PgBouncer (transaction mode) pooled host, the `-pooler` variant of `host`. Connect through it to work around the Postgres `max_connections` limit for serverless or connection-per-request workloads.\n" })
+});
+const zConnectionDetails = z.strictObject({
+	connection_uri: z.string().register(z.globalRegistry, { description: "The connection URI is defined as specified here: [Connection URIs](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING-URIS)\nThe connection URI can be used to connect to a Postgres database with psql or defined in a DATABASE_URL environment variable.\nWhen creating a branch from a parent with more than one role or database, the response body does not include a connection URI.\n" }),
+	connection_parameters: zConnectionParameters
+});
+const zConnectionUriResponse = z.strictObject({ uri: z.string().register(z.globalRegistry, { description: "The connection URI.\n" }) });
+/**
+* Lifecycle state of the compute endpoint. `init`: being initialized. `active`: running and accepting connections. `idle`: suspended (scaled to zero).
+*/
+const zEndpointState = z.enum([
+	"init",
+	"active",
+	"idle"
+]).register(z.globalRegistry, { description: "Lifecycle state of the compute endpoint. `init`: being initialized. `active`: running and accepting connections. `idle`: suspended (scaled to zero)." });
+/**
+* Compute endpoint type. `read_write`: the primary read-write endpoint (one per branch). `read_only`: a read replica endpoint (multiple allowed per branch).
+*/
+const zEndpointType = z.enum(["read_only", "read_write"]).register(z.globalRegistry, { description: "Compute endpoint type. `read_write`: the primary read-write endpoint (one per branch). `read_only`: a read replica endpoint (multiple allowed per branch)." });
+/**
+* Deprecated. The connection pooler mode. Neon supports PgBouncer in `transaction` mode only. Removal scheduled for June 20, 2026.
+*
+*
+* @deprecated
+*/
+const zEndpointPoolerMode = z.enum(["transaction"]).register(z.globalRegistry, { description: "Deprecated. The connection pooler mode. Neon supports PgBouncer in `transaction` mode only. Removal scheduled for June 20, 2026.\n" });
+/**
+* Duration of inactivity in seconds after which the compute endpoint is
+* automatically suspended. The value `0` means use the default value.
+* The value `-1` means never suspend. The default value is `300` seconds (5 minutes).
+* The minimum value is `60` seconds (1 minute).
+* The maximum value is `604800` seconds (1 week). For more information, see
+* [Scale to zero configuration](https://neon.com/docs/manage/endpoints#scale-to-zero-configuration).
+*
+*/
+const zSuspendTimeoutSeconds = z.int().gte(-1).lte(604800).register(z.globalRegistry, { description: "Duration of inactivity in seconds after which the compute endpoint is\nautomatically suspended. The value `0` means use the default value.\nThe value `-1` means never suspend. The default value is `300` seconds (5 minutes).\nThe minimum value is `60` seconds (1 minute).\nThe maximum value is `604800` seconds (1 week). For more information, see\n[Scale to zero configuration](https://neon.com/docs/manage/endpoints#scale-to-zero-configuration).\n" });
+/**
+* A list of IP addresses that are allowed to connect to the compute endpoint.
+* If the list is empty or not set, all IP addresses are allowed.
+* If protected_branches_only is true, the list will be applied only to protected branches.
+*
+*/
+const zAllowedIps = z.strictObject({
+	ips: z.array(z.string()).register(z.globalRegistry, { description: "A list of IP addresses that are allowed to connect to the endpoint." }).optional(),
+	protected_branches_only: z.boolean().register(z.globalRegistry, { description: "If true, the list will be applied only to protected branches." }).optional()
+}).register(z.globalRegistry, { description: "A list of IP addresses that are allowed to connect to the compute endpoint.\nIf the list is empty or not set, all IP addresses are allowed.\nIf protected_branches_only is true, the list will be applied only to protected branches.\n" });
+/**
+* A maintenance window is a time period during which Neon may perform maintenance on the project's infrastructure.
+* During this time, the project's compute endpoints may be unavailable and existing connections can be
+* interrupted.
+*
+*/
+const zMaintenanceWindow = z.strictObject({
+	weekdays: z.array(z.int()).register(z.globalRegistry, { description: "A list of weekdays when the maintenance window is active.\nEncoded as ints, where 1 - Monday, and 7 - Sunday.\n" }),
+	start_time: z.string().register(z.globalRegistry, { description: "Start time of the maintenance window, in the format of \"HH:MM\". Uses UTC.\n" }),
+	end_time: z.string().register(z.globalRegistry, { description: "End time of the maintenance window, in the format of \"HH:MM\". Uses UTC.\n" })
+}).register(z.globalRegistry, { description: "A maintenance window is a time period during which Neon may perform maintenance on the project's infrastructure.\nDuring this time, the project's compute endpoints may be unavailable and existing connections can be\ninterrupted.\n" });
+/**
+* The shared libraries to preload into the project's compute instances.
+*
+*/
+const zPreloadLibraries = z.strictObject({
+	use_defaults: z.boolean().register(z.globalRegistry, { description: "When true, the project's preload libraries include the platform default set in addition to any libraries listed in `enabled_libraries`." }).optional(),
+	enabled_libraries: z.array(z.string()).register(z.globalRegistry, { description: "Names of shared preload libraries to enable for the project." }).optional()
+}).register(z.globalRegistry, { description: "The shared libraries to preload into the project's compute instances.\n" });
+const zConnectionUrisResponse = z.strictObject({ connection_uris: z.array(zConnectionDetails).register(z.globalRegistry, { description: "Connection URIs for the project. Each entry contains credentials and should be treated as sensitive." }) });
+const zConnectionUrisOptionalResponse = z.strictObject({ connection_uris: z.array(zConnectionDetails).register(z.globalRegistry, { description: "Connection URIs for the compute endpoint, including credentials." }).optional() });
+const zVpcEndpoint = z.strictObject({
+	vpc_endpoint_id: z.string().register(z.globalRegistry, { description: "Cloud provider identifier for the VPC endpoint." }),
+	label: z.string().register(z.globalRegistry, { description: "A descriptive label for the VPC endpoint" })
+});
+const zVpcEndpointsResponse = z.strictObject({ endpoints: z.array(zVpcEndpoint).register(z.globalRegistry, { description: "List of VPC endpoints returned by the request." }) });
+const zVpcEndpointWithRegion = zVpcEndpoint.merge(z.strictObject({ region_id: z.string().register(z.globalRegistry, { description: "The region where the VPC endpoint is located" }) }));
+const zVpcEndpointsWithRegionResponse = z.strictObject({ endpoints: z.array(zVpcEndpointWithRegion).register(z.globalRegistry, { description: "VPC endpoints associated with the region." }) });
+const zVpcEndpointDetails = z.strictObject({
+	vpc_endpoint_id: z.string().register(z.globalRegistry, { description: "Cloud provider identifier for the VPC endpoint." }),
+	label: z.string().register(z.globalRegistry, { description: "A descriptive label for the VPC endpoint" }),
+	state: z.string().register(z.globalRegistry, { description: "The current state of the VPC endpoint. `new` means the endpoint has just been configured and is pending acceptance by Neon. `accepted` means the VPC connection has been accepted by Neon.\n" }),
+	num_restricted_projects: z.int().register(z.globalRegistry, { description: "The number of projects that are restricted to use this VPC endpoint.\n" }),
+	example_restricted_projects: z.array(z.string()).register(z.globalRegistry, { description: "A list of example projects that are restricted to use this VPC endpoint.\nThere are at most 3 projects in the list, even if more projects are restricted.\n" })
+});
+const zVpcEndpointAssignment = z.strictObject({ label: z.string().register(z.globalRegistry, { description: "Human-readable name for the VPC endpoint assignment, used to identify it within the organization." }) });
+const zRole = z.strictObject({
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the branch this role belongs to." }),
+	name: z.string().register(z.globalRegistry, { description: "Postgres role name within the branch.\n" }),
+	password: z.string().register(z.globalRegistry, { description: "The role password\n" }).optional(),
+	protected: z.boolean().register(z.globalRegistry, { description: "Whether or not the role is system-protected\n" }).optional(),
+	authentication_method: z.string().register(z.globalRegistry, { description: "Authentication method configured for this role: `password`, `oauth`, or `no_login`.\n" }).optional(),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the role was created\n" }),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the role was last updated\n" })
+});
+const zRoleCreateRequest = z.strictObject({ role: z.strictObject({
+	name: z.string().register(z.globalRegistry, { description: "The role name. Cannot exceed 63 bytes in length.\n" }),
+	no_login: z.boolean().register(z.globalRegistry, { description: "Whether to create a role that cannot login.\n" }).optional()
+}).register(z.globalRegistry, { description: "Properties of the role to create." }) });
+const zRoleResponse = z.strictObject({ role: zRole });
+const zJwksResponse = z.strictObject({ jwks: zJwks });
+const zRolesResponse = z.strictObject({ roles: z.array(zRole).register(z.globalRegistry, { description: "Roles belonging to the branch. Each role includes fields such as `branch_id`, `name`, `protected`, `created_at`, and `updated_at`.\n" }) });
+const zRolePasswordResponse = z.strictObject({ password: z.string().register(z.globalRegistry, { description: "The role password\n" }) });
+const zPaymentSourceBankCard = z.strictObject({
+	last4: z.string().register(z.globalRegistry, { description: "Last 4 digits of the card.\n" }),
+	brand: z.enum([
+		"amex",
+		"diners",
+		"discover",
+		"jcb",
+		"mastercard",
+		"unionpay",
+		"unknown",
+		"visa"
+	]).register(z.globalRegistry, { description: "Card network reported by the payment processor. Set to `unknown` when the network cannot be determined.\n" }).optional(),
+	exp_month: z.int().register(z.globalRegistry, { description: "Credit card expiration month\n" }).optional(),
+	exp_year: z.int().register(z.globalRegistry, { description: "Credit card expiration year\n" }).optional()
+});
+const zPaymentSource = z.strictObject({
+	type: z.string().register(z.globalRegistry, { description: "Type of payment source. E.g. \"card\".\n" }),
+	card: zPaymentSourceBankCard.optional()
+});
+const zSpendingLimitUpdateRequest = z.strictObject({ spending_limit_cents: z.int().gte(1).register(z.globalRegistry, { description: "Monthly spending cap in cents. Must be positive. To remove a\npreviously configured limit, send a DELETE request to the\nspending_limit endpoint — `0` and `null` are rejected here.\nThe cap is alert-only: notifications fire at 80% and 100%, but\ncomputes are not suspended. Setting a cap below the period's\nalready-accrued spend is permitted and will trigger the\nover-limit notification on the next worker run.\n" }) });
+const zSpendingLimitResponse = z.strictObject({ spending_limit_cents: z.int().nullable() });
+/**
+* State of the billing account.
+*
+*/
+const zBillingAccountState = z.enum([
+	"UNKNOWN",
+	"active",
+	"suspended",
+	"deactivated",
+	"deleted"
+]).register(z.globalRegistry, { description: "State of the billing account.\n" });
+/**
+* Type of subscription to Neon Cloud.
+* Notice that for users without billing account this will be "UNKNOWN"
+*
+*/
+const zBillingSubscriptionType = z.enum([
+	"UNKNOWN",
+	"direct_sales",
+	"direct_sales_v3",
+	"aws_marketplace",
+	"free_v2",
+	"free_v3",
+	"launch",
+	"launch_v3",
+	"scale",
+	"scale_v3",
+	"business",
+	"vercel_pg_legacy"
+]).register(z.globalRegistry, { description: "Type of subscription to Neon Cloud.\nNotice that for users without billing account this will be \"UNKNOWN\"\n" });
+/**
+* Indicates whether and how an account makes payments.
+*
+*/
+const zBillingPaymentMethod = z.enum([
+	"UNKNOWN",
+	"none",
+	"stripe",
+	"direct_payment",
+	"aws_mp",
+	"azure_mp",
+	"vercel_mp",
+	"staff",
+	"trial",
+	"sponsorship",
+	"shared_payment_token"
+]).register(z.globalRegistry, { description: "Indicates whether and how an account makes payments.\n" });
+const zBillingAccount = z.strictObject({
+	state: zBillingAccountState,
+	payment_source: zPaymentSource,
+	subscription_type: zBillingSubscriptionType,
+	payment_method: zBillingPaymentMethod,
+	quota_reset_at_last: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp of the last quota reset. Set to the account creation time when the account is first created.\n" }),
+	name: z.string().register(z.globalRegistry, { description: "The full name of the individual or entity that owns the billing account. This name appears on invoices." }),
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Billing email, to receive emails related to invoices and subscriptions.\n" }),
+	address_city: z.string().register(z.globalRegistry, { description: "Billing address city.\n" }),
+	address_country: z.string().register(z.globalRegistry, { description: "Billing address country code defined by ISO 3166-1 alpha-2.\n" }),
+	address_country_name: z.string().register(z.globalRegistry, { description: "Billing address country name.\n" }).optional(),
+	address_line1: z.string().register(z.globalRegistry, { description: "Billing address line 1.\n" }),
+	address_line2: z.string().register(z.globalRegistry, { description: "Billing address line 2.\n" }),
+	address_postal_code: z.string().register(z.globalRegistry, { description: "Billing address postal code.\n" }),
+	address_state: z.string().register(z.globalRegistry, { description: "Billing address state or region.\n" }),
+	orb_portal_url: z.string().register(z.globalRegistry, { description: "Orb user portal url\n" }).optional(),
+	tax_id: z.string().register(z.globalRegistry, { description: "The tax identification number for the billing account, displayed on invoices.\n" }).optional(),
+	tax_id_type: z.string().register(z.globalRegistry, { description: "The type of the tax identification number based on the country.\n" }).optional(),
+	plan_details: zPlanDetails.optional(),
+	spending_limit_cents: z.int().nullish()
+});
+const zDatabase = z.strictObject({
+	id: z.int().register(z.globalRegistry, { description: "The database ID\n" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the branch this database belongs to." }),
+	name: z.string().register(z.globalRegistry, { description: "The database name\n" }),
+	owner_name: z.string().register(z.globalRegistry, { description: "The name of role that owns the database\n" }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the database was created\n" }),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the database was last updated\n" })
+});
+const zDatabaseCreateRequest = z.strictObject({ database: z.strictObject({
+	name: z.string().register(z.globalRegistry, { description: "Name of the database to create.\n" }),
+	owner_name: z.string().register(z.globalRegistry, { description: "The name of the role that owns the database\n" })
+}).register(z.globalRegistry, { description: "Configuration for the new Postgres database." }) });
+const zDatabaseUpdateRequest = z.strictObject({ database: z.strictObject({
+	name: z.string().register(z.globalRegistry, { description: "Name of the database to update.\n" }).optional(),
+	owner_name: z.string().register(z.globalRegistry, { description: "The name of the role that owns the database\n" }).optional()
+}).register(z.globalRegistry, { description: "Properties to update on the database." }) });
+const zDatabaseResponse = z.strictObject({ database: zDatabase });
+const zDatabasesResponse = z.strictObject({ databases: z.array(zDatabase).register(z.globalRegistry, { description: "Databases on the branch. Each includes `id`, `name`, `owner_name`, and `created_at`." }) });
+/**
+* Organization member's role. `admin`: full administrative access. `editor` (and its legacy alias `member`): standard access governed by project permissions. `viewer` and `collaborator`: additional scoped project roles. Some values may not be available for all organizations.
+*/
+const zMemberRole = z.enum([
+	"admin",
+	"member",
+	"editor",
+	"viewer",
+	"collaborator"
+]).register(z.globalRegistry, { description: "Organization member's role. `admin`: full administrative access. `editor` (and its legacy alias `member`): standard access governed by project permissions. `viewer` and `collaborator`: additional scoped project roles. Some values may not be available for all organizations." });
+const zInvitation = z.strictObject({
+	id: z.uuid().register(z.globalRegistry, { description: "The invitation ID." }),
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email of the invited user" }),
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "Organization id as it is stored in Neon" }),
+	invited_by: z.uuid().register(z.globalRegistry, { description: "UUID for the user_id who extended the invitation" }),
+	invited_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp when the invitation was created" }),
+	role: zMemberRole
+});
+const zMember = z.strictObject({
+	id: z.uuid().register(z.globalRegistry, { description: "The organization member's ID." }),
+	user_id: z.uuid().register(z.globalRegistry, { description: "The Neon user ID." }),
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID. Returned as `id` from `GET /users/me/organizations`." }),
+	role: zMemberRole,
+	joined_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp when the user joined the organization." }).optional()
+});
+const zMemberUserInfo = z.strictObject({
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address of the organization member's user account." }),
+	has_mfa: z.boolean().register(z.globalRegistry, { description: "Whether the member has MFA (TOTP) enabled" }).optional(),
+	deactivated_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp of when the user account was deactivated.\nAbsent for active users. When present, the UI should render a\n\"Deactivated\" badge inline next to the member.\n" }).optional()
+});
+const zMemberWithUser = z.strictObject({
+	member: zMember,
+	user: zMemberUserInfo
+});
+const zOrganization = z.strictObject({
+	id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID. Use as the `org_id` path parameter in other endpoints." }),
+	name: z.string().register(z.globalRegistry, { description: "Human-readable display name of the organization." }),
+	handle: z.string().register(z.globalRegistry, { description: "URL-safe identifier for the organization, used in API paths. Distinct from the display name." }),
+	plan: z.string().register(z.globalRegistry, { description: "Billing plan for the organization, for example `free`, `launch`, or `scale`." }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicting when the organization was created\n" }),
+	managed_by: z.string().register(z.globalRegistry, { description: "Organizations created via the Console or the API are managed by `console`.\nOrganizations created by other methods can't be deleted via the Console or the API.\n" }),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the organization was updated\n" }),
+	allow_hipaa_projects: z.boolean().register(z.globalRegistry, { description: "If true, allow account to mark projects as HIPAA" }).optional(),
+	require_mfa: z.boolean().register(z.globalRegistry, { description: "If true, all members must have MFA enabled to access this organization" }).optional()
+});
+const zOrganizationsResponse = z.strictObject({ organizations: z.array(zOrganization).register(z.globalRegistry, { description: "Organizations returned by the request. Each includes `id`, `name`, `handle`, and `plan`." }) });
+const zOrganizationInvitationsResponse = z.strictObject({ invitations: z.array(zInvitation).register(z.globalRegistry, { description: "List of pending invitations for the organization." }) });
+const zOrganizationInviteCreateRequest = z.strictObject({
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address of the person to invite to the organization." }),
+	role: zMemberRole
+});
+const zOrganizationInvitesCreateRequest = z.strictObject({ invitations: z.array(zOrganizationInviteCreateRequest).register(z.globalRegistry, { description: "Invitations to create for the organization." }) });
+const zOrganizationMemberUpdateRequest = z.strictObject({ role: zMemberRole });
+const zOrganizationMembersResponse = z.strictObject({ members: z.array(zMemberWithUser).register(z.globalRegistry, { description: "Members of the organization, each combining membership details (role, status) with the associated user's identity." }) });
+const zRegionResponse = z.strictObject({
+	region_id: z.string().register(z.globalRegistry, { description: "Cloud region where the resource's Postgres compute and storage reside (for example, `aws-us-east-1`). Valid values are returned by `GET /regions`." }),
+	name: z.string().register(z.globalRegistry, { description: "A short description of the region." }),
+	default: z.boolean().register(z.globalRegistry, { description: "True if this region is selected by default when no region is specified during project creation." }),
+	geo_lat: z.string().register(z.globalRegistry, { description: "The geographical latitude (approximate) for the region. Empty if unknown." }),
+	geo_long: z.string().register(z.globalRegistry, { description: "The geographical longitude (approximate) for the region. Empty if unknown." })
+});
+const zActiveRegionsResponse = z.strictObject({ regions: z.array(zRegionResponse).register(z.globalRegistry, { description: "The list of active regions" }) });
+const zAuthDetailsResponse = z.strictObject({
+	account_id: z.string().register(z.globalRegistry, { description: "The ID of the account associated with this authentication record." }),
+	auth_method: z.enum([
+		"keycloak",
+		"session_cookie",
+		"api_key_user",
+		"api_key_org",
+		"oauth"
+	]).register(z.globalRegistry, { description: "Authentication method used for the request:\n- `keycloak`: Keycloak identity provider authentication.\n- `session_cookie`: Browser session cookie authentication.\n- `api_key_user`: API key scoped to a user account.\n- `api_key_org`: API key scoped to an organization.\n- `oauth`: OAuth-based authentication.\n" }),
+	auth_data: z.string().optional()
+});
+const zTransferProjectsToOrganizationRequest = z.strictObject({
+	destination_org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The destination organization identifier" }),
+	project_ids: z.array(z.string().regex(/^[a-z0-9-]{1,60}$/)).min(1).max(400).register(z.globalRegistry, { description: "The list of projects ids to transfer. Maximum of 400 project ids" })
+});
+/**
+* Identity provider id from keycloak
+*/
+const zIdentityProviderId = z.enum([
+	"github",
+	"google",
+	"hasura",
+	"microsoft",
+	"microsoftv2",
+	"vercelmp",
+	"keycloak"
+]).register(z.globalRegistry, { description: "Identity provider id from keycloak" });
+const zCurrentUserAuthAccount = z.strictObject({
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address associated with this auth account." }),
+	image: z.string().register(z.globalRegistry, { description: "URL of the user's profile picture as provided by the identity provider." }),
+	login: z.string().register(z.globalRegistry, { description: "Deprecated. Use the `email` field.\n" }),
+	name: z.string().register(z.globalRegistry, { description: "Display name of the account as provided by the identity provider." }),
+	provider: zIdentityProviderId
+});
+const zCurrentUserInfoResponse = z.strictObject({
+	active_seconds_limit: z.int().register(z.globalRegistry, { description: "Control plane observes active endpoints of a user this amount of wall-clock time.\n" }),
+	billing_account: zBillingAccount.optional(),
+	auth_accounts: z.array(zCurrentUserAuthAccount).register(z.globalRegistry, { description: "Authentication provider accounts linked to the current user." }),
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address of the authenticated user." }),
+	id: z.string().register(z.globalRegistry, { description: "The Neon user ID." }),
+	image: z.string().register(z.globalRegistry, { description: "URL of the user's profile avatar image." }),
+	login: z.string().register(z.globalRegistry, { description: "Deprecated. Use the `email` field.\n" }),
+	name: z.string().register(z.globalRegistry, { description: "First name of the current user." }),
+	last_name: z.string().register(z.globalRegistry, { description: "Last name of the current user." }),
+	projects_limit: z.int().register(z.globalRegistry, { description: "Maximum number of projects the account is allowed to create under the current plan." }),
+	branches_limit: z.int().register(z.globalRegistry, { description: "Maximum number of branches allowed for the account under the current plan." }),
+	max_autoscaling_limit: z.number().register(z.globalRegistry, { description: "The maximum autoscaling limit in Compute Units.\nA value of 0 indicates no limit is configured.\n" }),
+	compute_seconds_limit: z.int().register(z.globalRegistry, { description: "Maximum Postgres compute time, in seconds, allowed under the account's current plan." }).optional(),
+	plan: z.string().register(z.globalRegistry, { description: "Current billing plan for the user's account." })
+});
+/**
+* Per-project consumption quotas. If a quota is exceeded, all active computes
+* are automatically suspended and cannot be started via API calls or incoming connections.
+*
+* The exception is `logical_size_bytes`, which is enforced per branch.
+* If a branch exceeds its `logical_size_bytes` quota, computes can still be started,
+* but write operations will fail—allowing data to be deleted to free up space.
+* Computes on other branches are not affected.
+*
+* Setting `logical_size_bytes` overrides any lower value set by the `neon.max_cluster_size` Postgres setting.
+*
+* Quotas are enforced using per-project consumption metrics with the same names.
+* These metrics reset at the start of each billing period. `logical_size_bytes`
+* is also an exception—it reflects the total data stored in a branch and does not reset.
+*
+* A zero or empty quota value means “unlimited.”
+*
+*/
+const zProjectQuota = z.strictObject({
+	active_time_seconds: z.int().gte(0).register(z.globalRegistry, { description: "The total amount of wall-clock time allowed to be spent by the project's compute endpoints.\n" }).optional(),
+	compute_time_seconds: z.int().gte(0).register(z.globalRegistry, { description: "The total amount of CPU seconds allowed to be spent by the project's compute endpoints.\n" }).optional(),
+	written_data_bytes: z.int().gte(0).register(z.globalRegistry, { description: "Total amount of data written to all of a project's branches.\n" }).optional(),
+	data_transfer_bytes: z.int().gte(0).register(z.globalRegistry, { description: "Total amount of data transferred from all of a project's branches using the proxy.\n" }).optional(),
+	logical_size_bytes: z.int().gte(0).register(z.globalRegistry, { description: "Limit on the logical size of every project's branch.\n\nIf a branch exceeds its `logical_size_bytes` quota, computes can still be started,\nbut write operations will fail—allowing data to be deleted to free up space.\nComputes on other branches are not affected.\n\nSetting `logical_size_bytes` overrides any lower value set by the `neon.max_cluster_size` Postgres setting.\n" }).optional()
+}).register(z.globalRegistry, { description: "Per-project consumption quotas. If a quota is exceeded, all active computes\nare automatically suspended and cannot be started via API calls or incoming connections.\n\nThe exception is `logical_size_bytes`, which is enforced per branch.\nIf a branch exceeds its `logical_size_bytes` quota, computes can still be started,\nbut write operations will fail—allowing data to be deleted to free up space.\nComputes on other branches are not affected.\n\nSetting `logical_size_bytes` overrides any lower value set by the `neon.max_cluster_size` Postgres setting.\n\nQuotas are enforced using per-project consumption metrics with the same names.\nThese metrics reset at the start of each billing period. `logical_size_bytes`\nis also an exception—it reflects the total data stored in a branch and does not reset.\n\nA zero or empty quota value means “unlimited.”\n" });
+const zProjectSettingsData = z.strictObject({
+	quota: zProjectQuota.optional(),
+	allowed_ips: zAllowedIps.optional(),
+	enable_logical_replication: z.boolean().register(z.globalRegistry, { description: "Sets wal_level=logical for all compute endpoints in this project.\nAll active endpoints will be suspended.\nOnce enabled, logical replication cannot be disabled.\n" }).optional(),
+	maintenance_window: zMaintenanceWindow.optional(),
+	block_public_connections: z.boolean().register(z.globalRegistry, { description: "When set, connections from the public internet\nare disallowed. This supersedes the AllowedIPs list.\nThis parameter is under active development and its semantics may change in the future.\n" }).optional(),
+	block_vpc_connections: z.boolean().register(z.globalRegistry, { description: "When set, connections using VPC endpoints are disallowed.\nThis parameter is under active development and its semantics may change in the future.\n" }).optional(),
+	audit_log_level: zProjectAuditLogLevel.optional(),
+	hipaa: z.boolean().register(z.globalRegistry, { description: "Enables HIPAA compliance mode for the project, including audit logging." }).optional(),
+	preload_libraries: zPreloadLibraries.optional()
+});
+/**
+* A raw representation of Postgres settings
+*/
+const zPgSettingsData = z.record(z.string(), z.string()).register(z.globalRegistry, { description: "A raw representation of Postgres settings" });
+/**
+* Deprecated. A raw representation of PgBouncer settings. Removal scheduled for June 20, 2026.
+*
+*
+* @deprecated
+*/
+const zPgbouncerSettingsData = z.record(z.string(), z.string()).register(z.globalRegistry, { description: "Deprecated. A raw representation of PgBouncer settings. Removal scheduled for June 20, 2026.\n" });
+/**
+* A collection of settings for a compute endpoint
+*/
+const zEndpointSettingsData = z.strictObject({
+	pg_settings: zPgSettingsData.optional(),
+	pgbouncer_settings: zPgbouncerSettingsData.optional(),
+	preload_libraries: zPreloadLibraries.optional()
+}).register(z.globalRegistry, { description: "A collection of settings for a compute endpoint" });
+const zBranchCreateRequestEndpointOptions = z.strictObject({
+	type: zEndpointType,
+	settings: zEndpointSettingsData.optional(),
+	autoscaling_limit_min_cu: zComputeUnit.optional(),
+	autoscaling_limit_max_cu: zComputeUnit.optional(),
+	provisioner: zProvisioner.optional(),
+	suspend_timeout_seconds: zSuspendTimeoutSeconds.optional()
+});
+const zBranchCreateRequest = z.strictObject({
+	endpoints: z.array(zBranchCreateRequestEndpointOptions).register(z.globalRegistry, { description: "Compute endpoints to create together with the branch. If omitted, the branch is created without any compute endpoint. Endpoints can be added to the branch separately after creation." }).optional(),
+	branch: z.strictObject({
+		parent_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The `branch_id` of the parent branch. If omitted or empty, the branch will be created from the project's default branch.\n" }).optional(),
+		name: z.string().min(1).max(256).register(z.globalRegistry, { description: "The branch name\n" }).optional(),
+		parent_lsn: z.string().register(z.globalRegistry, { description: "A Log Sequence Number (LSN) on the parent branch. The branch will be created with data from this LSN.\n" }).optional(),
+		parent_timestamp: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp identifying a point in time on the parent branch. The branch will be created with data starting from this point in time. RFC 3339 format.\n" }).optional(),
+		protected: z.boolean().register(z.globalRegistry, { description: "Whether the branch is protected. Protected branches (and their computes) cannot be deleted, archived, or reset, and block deletion of the project. Can be gated by `protected_branches_only` in the IP allowlist. Paid plans only.\n" }).optional(),
+		archived: z.boolean().register(z.globalRegistry, { description: "Whether to create the branch in the archived state. When omitted, the branch is created as a normal (non-archived) branch.\n" }).optional(),
+		init_source: z.string().register(z.globalRegistry, { description: "Source of initialization for the branch. `parent-data` copies schema and data from the parent branch. `parent-schema` copies schema only from the parent branch. `schema-only` creates a new root branch containing schema only, using `parent_id` as the source; optionally, `parent_lsn` or `parent_timestamp` can narrow the source point. `import` initializes the branch from an external import." }).optional(),
+		expires_at: z.iso.datetime().register(z.globalRegistry, { description: "The timestamp when the branch is scheduled to expire and be automatically deleted. Must be set by the client following the [RFC 3339, section 5.6](https://tools.ietf.org/html/rfc3339#section-5.6) format with precision up to seconds (such as 2025-06-09T18:02:16Z). Deletion is performed by a background job and may not occur exactly at the specified time.\n\nAccess to this feature is currently limited to participants in the Early Access Program.\n" }).optional()
+	}).register(z.globalRegistry, { description: "Optional configuration for the new branch, for example `name`, `parent_id` (fork from a branch), `parent_lsn` or `parent_timestamp` (point-in-time branching), and `protected`." }).optional()
+});
+const zEndpoint = z.strictObject({
+	host: z.string().register(z.globalRegistry, { description: "The hostname of the compute endpoint. This is the hostname specified when connecting to a Neon database.\n" }),
+	id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The compute endpoint ID. Compute endpoint IDs have an `ep-` prefix. For example: `ep-little-smoke-851426`\n" }),
+	name: z.string().register(z.globalRegistry, { description: "Optional name of the compute endpoint\n" }).optional(),
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the project this compute endpoint belongs to." }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the branch this compute endpoint belongs to." }),
+	autoscaling_limit_min_cu: zComputeUnit,
+	autoscaling_limit_max_cu: zComputeUnit,
+	region_id: z.string().register(z.globalRegistry, { description: "Cloud region where the resource's Postgres compute and storage reside (for example, `aws-us-east-1`). Valid values are returned by `GET /regions`.\n" }),
+	type: zEndpointType,
+	current_state: zEndpointState,
+	pending_state: zEndpointState.optional(),
+	settings: zEndpointSettingsData,
+	pooler_enabled: z.boolean().register(z.globalRegistry, { description: "Deprecated. To use connection pooling, append `-pooler` to the endpoint ID in the connection string.\n" }),
+	pooler_mode: zEndpointPoolerMode,
+	disabled: z.boolean().register(z.globalRegistry, { description: "Whether to restrict connections to the compute endpoint.\nEnabling this option schedules a suspend compute operation.\nA disabled compute endpoint cannot be enabled by a connection or\nconsole action.\n" }),
+	passwordless_access: z.boolean().register(z.globalRegistry, { description: "Whether to permit passwordless access to the compute endpoint\n" }),
+	last_active: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the compute endpoint was last active\n" }).optional(),
+	creation_source: z.string().register(z.globalRegistry, { description: "The compute endpoint creation source\n" }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the compute endpoint was created\n" }),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the compute endpoint was last updated\n" }),
+	started_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the compute endpoint was last started\n" }).optional(),
+	suspended_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the compute endpoint was last suspended\n" }).optional(),
+	proxy_host: z.string().register(z.globalRegistry, { description: "Deprecated. Use the `host` property instead.\n" }),
+	suspend_timeout_seconds: zSuspendTimeoutSeconds,
+	provisioner: zProvisioner,
+	compute_release_version: z.string().register(z.globalRegistry, { description: "Attached compute's release version number.\n" }).optional()
+});
+const zEndpointCreateRequest = z.strictObject({ endpoint: z.strictObject({
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The ID of the branch the compute endpoint will be associated with\n" }),
+	region_id: z.string().register(z.globalRegistry, { description: "The region where the compute endpoint will be created. Only the project's `region_id` is permitted.\n" }).optional(),
+	type: zEndpointType,
+	settings: zEndpointSettingsData.optional(),
+	autoscaling_limit_min_cu: zComputeUnit.optional(),
+	autoscaling_limit_max_cu: zComputeUnit.optional(),
+	provisioner: zProvisioner.optional(),
+	pooler_enabled: z.boolean().register(z.globalRegistry, { description: "Deprecated. To enable connection pooling, append `-pooler` to the endpoint ID in the connection string.\nSee [How to use connection pooling](https://neon.com/docs/connect/connection-pooling#how-to-use-connection-pooling)\n" }).optional(),
+	pooler_mode: zEndpointPoolerMode.optional(),
+	disabled: z.boolean().register(z.globalRegistry, { description: "Whether to restrict connections to the compute endpoint.\nEnabling this option schedules a suspend compute operation.\nA disabled compute endpoint cannot be enabled by a connection or\nconsole action. However, the compute endpoint is periodically\nenabled by check_availability operations.\n" }).optional(),
+	passwordless_access: z.boolean().register(z.globalRegistry, { description: "NOT YET IMPLEMENTED. Whether to permit passwordless access to the compute endpoint.\n" }).optional(),
+	suspend_timeout_seconds: zSuspendTimeoutSeconds.optional(),
+	name: z.string().min(1).max(64).register(z.globalRegistry, { description: "Optional name of the compute endpoint\n" }).optional()
+}).register(z.globalRegistry, { description: "Configuration for the compute endpoint to create." }) });
+const zEndpointUpdateRequest = z.strictObject({ endpoint: z.strictObject({
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "Deprecated. The destination branch ID; must not have an existing read-write endpoint.\n" }).optional(),
+	autoscaling_limit_min_cu: zComputeUnit.optional(),
+	autoscaling_limit_max_cu: zComputeUnit.optional(),
+	provisioner: zProvisioner.optional(),
+	settings: zEndpointSettingsData.optional(),
+	pooler_enabled: z.boolean().register(z.globalRegistry, { description: "Deprecated. To enable connection pooling, append `-pooler` to the endpoint ID in the connection string.\nSee [How to use connection pooling](https://neon.com/docs/connect/connection-pooling#how-to-use-connection-pooling)\n" }).optional(),
+	pooler_mode: zEndpointPoolerMode.optional(),
+	disabled: z.boolean().register(z.globalRegistry, { description: "Whether to restrict connections to the compute endpoint.\nEnabling this option schedules a suspend compute operation.\nA disabled compute endpoint cannot be enabled by a connection or\nconsole action. However, the compute endpoint is periodically\nenabled by check_availability operations.\n" }).optional(),
+	passwordless_access: z.boolean().register(z.globalRegistry, { description: "NOT YET IMPLEMENTED. Whether to permit passwordless access to the compute endpoint.\n" }).optional(),
+	suspend_timeout_seconds: zSuspendTimeoutSeconds.optional(),
+	name: z.string().min(1).max(64).register(z.globalRegistry, { description: "Optional name of the compute endpoint\n" }).optional()
+}).register(z.globalRegistry, { description: "Parameters for the compute endpoint update." }) });
+const zEndpointResponse = z.strictObject({ endpoint: zEndpoint });
+const zEndpointsResponse = z.strictObject({ endpoints: z.array(zEndpoint).register(z.globalRegistry, { description: "Compute endpoints in the project. Each includes `id`, `branch_id`, `host`, and `type`." }) });
+const zEndpointsOptionalResponse = z.strictObject({ endpoints: z.array(zEndpoint).register(z.globalRegistry, { description: "Compute endpoints associated with the project." }).optional() });
+/**
+* A collection of settings for a Neon endpoint
+*/
+const zDefaultEndpointSettings = z.strictObject({
+	pg_settings: zPgSettingsData.optional(),
+	pgbouncer_settings: zPgbouncerSettingsData.optional(),
+	autoscaling_limit_min_cu: zComputeUnit.optional(),
+	autoscaling_limit_max_cu: zComputeUnit.optional(),
+	suspend_timeout_seconds: zSuspendTimeoutSeconds.optional()
+}).register(z.globalRegistry, { description: "A collection of settings for a Neon endpoint" });
+const zProjectUpdateRequest = z.strictObject({ project: z.strictObject({
+	settings: zProjectSettingsData.optional(),
+	name: z.string().min(1).max(256).register(z.globalRegistry, { description: "The project name" }).optional(),
+	default_endpoint_settings: zDefaultEndpointSettings.optional(),
+	history_retention_seconds: z.int().gte(0).lte(2592e3).register(z.globalRegistry, { description: "History window (point-in-time restore range) for all branches, in seconds. `0` disables it. Default 1 day (Free: 6 hours). Maximum depends on plan: Free 6 hours (21600), Launch 7 days (604800), Scale 30 days (2592000).\n" }).optional()
+}) });
+/**
+* The major Postgres version number. Supported versions are `14`, `15`, `16`, `17`, and `18`. `19` is rolling out and is accepted only in regions where it is enabled; requesting it elsewhere returns an error.
+*/
+const zPgVersion = z.int().gte(14).lte(19).register(z.globalRegistry, { description: "The major Postgres version number. Supported versions are `14`, `15`, `16`, `17`, and `18`. `19` is rolling out and is accepted only in regions where it is enabled; requesting it elsewhere returns an error." });
+/**
+* Essential data about the project. Full data is available at `GET /projects/{project_id}`.
+*
+*/
+const zProjectListItem = z.strictObject({
+	id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID. Use as the `project_id` path parameter in other endpoints." }),
+	platform_id: z.string().register(z.globalRegistry, { description: "The cloud platform identifier. Currently, only AWS is supported, for which the identifier is `aws`.\n" }),
+	region_id: z.string().register(z.globalRegistry, { description: "Cloud region where the project's Postgres compute and storage reside (for example, `aws-us-east-2`). Valid values are returned by `GET /regions`.\n" }),
+	name: z.string().register(z.globalRegistry, { description: "The project name\n" }),
+	provisioner: zProvisioner,
+	default_endpoint_settings: zDefaultEndpointSettings.optional(),
+	settings: zProjectSettingsData.optional(),
+	pg_version: zPgVersion,
+	proxy_host: z.string().register(z.globalRegistry, { description: "The proxy host for the project. This value combines the `region_id`, the `platform_id`, and the Neon domain (`neon.tech`).\n" }),
+	branch_logical_size_limit: z.int().register(z.globalRegistry, { description: "The logical size limit for a branch. The value is in MiB.\n" }),
+	branch_logical_size_limit_bytes: z.int().register(z.globalRegistry, { description: "The logical size limit for a branch. The value is in B.\n" }),
+	store_passwords: z.boolean().register(z.globalRegistry, { description: "Whether or not passwords are stored for roles in the Neon project. Storing passwords facilitates access to Neon features that require authorization.\n" }),
+	active_time: z.int().gte(0).register(z.globalRegistry, { description: "Control plane observed endpoints of this project being active this amount of wall-clock time.\n" }),
+	cpu_used_sec: z.int().register(z.globalRegistry, { description: "Deprecated. Use `compute_time_seconds` from `GET /projects/{project_id}` instead.\n" }),
+	maintenance_starts_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when project maintenance begins. If set, the project is placed into maintenance mode at this time.\n" }).optional(),
+	creation_source: z.string().register(z.globalRegistry, { description: "The project creation source\n" }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the project was created\n" }),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the project was last updated\n" }),
+	synthetic_storage_size: z.int().register(z.globalRegistry, { description: "The current space occupied by the project in Postgres storage, in bytes. Synthetic Postgres storage size combines the logical data size and Write-Ahead Log (WAL) size for all branches in a project.\n" }).optional(),
+	quota_reset_at: z.iso.datetime().register(z.globalRegistry, { description: "Deprecated. Use `consumption_period_end` from `GET /projects/{project_id}` instead. A timestamp indicating when the project quota resets.\n" }).optional(),
+	owner_id: z.string().register(z.globalRegistry, { description: "ID of the organization that owns the project." }),
+	compute_last_active_at: z.iso.datetime().register(z.globalRegistry, { description: "The most recent time when any endpoint of this project was active.\n\nOmitted when observed no activity for endpoints of this project.\n" }).optional(),
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "ID of the organization that owns the project. Project permissions are granted to organization members as configured by the organization's admins, independent of which member created the project.\n" }).optional(),
+	org_name: z.string().register(z.globalRegistry, { description: "Name of the organization that owns the project.\n" }).optional(),
+	history_retention_seconds: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The number of seconds to retain the shared history for all branches in this project.\n" }).optional(),
+	hipaa_enabled_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when HIPAA was enabled for this project" }).optional(),
+	deleted_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the project was deleted" }).optional(),
+	recoverable_until: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating the project will be recoverable until this date and time." }).optional(),
+	effective_project_permission: zProjectPermissionLevel.nullish()
+}).register(z.globalRegistry, { description: "Essential data about the project. Full data is available at `GET /projects/{project_id}`.\n" });
+const zProjectsResponse = z.strictObject({
+	projects: z.array(zProjectListItem).register(z.globalRegistry, { description: "List of projects accessible to the caller. Projects that exist but could not be retrieved are identified in `unavailable_project_ids`." }),
+	unavailable_project_ids: z.array(z.string().regex(/^[a-z0-9-]{1,60}$/)).register(z.globalRegistry, { description: "A list of project IDs indicating which projects are known to exist, but whose details could not\nbe fetched within the requested (or implicit) time limit\n" }).optional()
+});
+const zProjectOwnerData = z.strictObject({
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address of the project owner." }),
+	name: z.string().register(z.globalRegistry, { description: "Display name of the project owner." }),
+	branches_limit: z.int().register(z.globalRegistry, { description: "Maximum number of branches the owner is allowed to create across their projects." }),
+	subscription_type: zBillingSubscriptionType
+});
+const zProject = z.strictObject({
+	data_storage_bytes_hour: z.int().gte(0).register(z.globalRegistry, { description: "Bytes-Hour. Project consumed that much Postgres storage hourly during the billing period. The value has some lag.\nThe value is reset at the beginning of each billing period.\n" }),
+	data_transfer_bytes: z.int().gte(0).register(z.globalRegistry, { description: "Bytes. Egress traffic from the Neon cloud to the client for given project over the billing period.\nIncludes deleted endpoints. The value has some lag. The value is reset at the beginning of each billing period.\n" }),
+	written_data_bytes: z.int().gte(0).register(z.globalRegistry, { description: "Bytes. Amount of WAL that travelled through Postgres storage for given project across all branches.\nThe value has some lag. The value is reset at the beginning of each billing period.\n" }),
+	compute_time_seconds: z.int().gte(0).register(z.globalRegistry, { description: "Seconds. The number of CPU seconds used by the project's compute endpoints, including compute endpoints that have been deleted.\nThe value has some lag. The value is reset at the beginning of each billing period.\nExamples:\n1. An endpoint that uses 1 CPU for 1 second is equal to `compute_time=1`.\n2. An endpoint that uses 2 CPUs simultaneously for 1 second is equal to `compute_time=2`.\n" }),
+	active_time_seconds: z.int().gte(0).register(z.globalRegistry, { description: "Seconds. Control plane observed endpoints of this project being active this amount of wall-clock time.\nThe value has some lag.\nThe value is reset at the beginning of each billing period.\n" }),
+	cpu_used_sec: z.int().register(z.globalRegistry, { description: "Deprecated. Use `compute_time_seconds` instead.\n" }),
+	id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID. Use as the `project_id` path parameter in other endpoints." }),
+	platform_id: z.string().register(z.globalRegistry, { description: "The cloud platform identifier. Currently, only AWS is supported, for which the identifier is `aws`.\n" }),
+	region_id: z.string().register(z.globalRegistry, { description: "Cloud region where the resource's Postgres compute and storage reside (for example, `aws-us-east-1`). Valid values are returned by `GET /regions`.\n" }),
+	name: z.string().register(z.globalRegistry, { description: "The project name\n" }),
+	provisioner: zProvisioner,
+	default_endpoint_settings: zDefaultEndpointSettings.optional(),
+	settings: zProjectSettingsData.optional(),
+	pg_version: zPgVersion,
+	proxy_host: z.string().register(z.globalRegistry, { description: "The proxy host for the project. This value combines the `region_id`, the `platform_id`, and the Neon domain (`neon.tech`).\n" }),
+	branch_logical_size_limit: z.int().register(z.globalRegistry, { description: "The logical size limit for a branch. The value is in MiB.\n" }),
+	branch_logical_size_limit_bytes: z.int().register(z.globalRegistry, { description: "The logical size limit for a branch. The value is in B.\n" }),
+	store_passwords: z.boolean().register(z.globalRegistry, { description: "Whether or not passwords are stored for roles in the Neon project. Storing passwords facilitates access to Neon features that require authorization.\n" }),
+	maintenance_starts_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when project maintenance begins. If set, the project is placed into maintenance mode at this time.\n" }).optional(),
+	creation_source: z.string().register(z.globalRegistry, { description: "The project creation source\n" }),
+	history_retention_seconds: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The number of seconds to retain the shared history for all branches in this project.\n" }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the project was created\n" }),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when the project was last updated\n" }),
+	synthetic_storage_size: z.int().register(z.globalRegistry, { description: "The current space occupied by the project in Postgres storage, in bytes. Synthetic Postgres storage size combines the logical data size and Write-Ahead Log (WAL) size for all branches in a project.\n" }).optional(),
+	consumption_period_start: z.iso.datetime().register(z.globalRegistry, { description: "A date-time indicating when Neon Cloud started measuring consumption for current consumption period.\n" }),
+	consumption_period_end: z.iso.datetime().register(z.globalRegistry, { description: "A date-time indicating when Neon Cloud plans to stop measuring consumption for current consumption period.\n" }),
+	quota_reset_at: z.iso.datetime().register(z.globalRegistry, { description: "Deprecated. Use the `consumption_period_end` field instead. A timestamp indicating when the project quota resets.\n" }).optional(),
+	owner_id: z.string().register(z.globalRegistry, { description: "ID of the organization that owns the project." }),
+	owner: zProjectOwnerData.optional(),
+	compute_last_active_at: z.iso.datetime().register(z.globalRegistry, { description: "The most recent time when any endpoint of this project was active.\n\nOmitted when observed no activity for endpoints of this project.\n" }).optional(),
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID. Returned as `id` from `GET /users/me/organizations`." }).optional(),
+	maintenance_scheduled_for: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when project update begins. If set, computes might experience a brief restart around this time.\n" }).optional(),
+	hipaa_enabled_at: z.iso.datetime().register(z.globalRegistry, { description: "A timestamp indicating when HIPAA was enabled for this project" }).optional(),
+	effective_project_permission: zProjectPermissionLevel.nullish()
+});
+const zProjectResponse = z.strictObject({ project: zProject });
+const zProjectRecoverResponse = zProjectResponse.merge(zBranchesResponse);
+const zLimitsUnsatisfiedResponse = z.strictObject({ limits: z.array(z.strictObject({
+	name: z.string().register(z.globalRegistry, { description: "Identifier of the unsatisfied limit. Possible values are:\n- subscription_type\n- projects_count\n- project_region\n" }),
+	expected: z.string().register(z.globalRegistry, { description: "Required value for the limit named by `name`. Compare with `actual` to determine the shortfall." }),
+	actual: z.string().register(z.globalRegistry, { description: "Current value of the named limit, which does not satisfy the required `expected` value." })
+})).register(z.globalRegistry, { description: "Plan limits that were not satisfied by the request." }) });
+const zProjectsWithIntegrationResponse = z.strictObject({ projects: z.array(z.strictObject({
+	id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID. Use as the `project_id` path parameter in other endpoints." }),
+	integration: z.string().register(z.globalRegistry, { description: "Name of the external integration associated with the project." })
+})).register(z.globalRegistry, { description: "Projects that have the requested integration, each including the project details and associated integration metadata." }) });
+/**
+* Configuration settings for the Neon Data API
+*/
+const zDataApiSettings = z.strictObject({
+	db_aggregates_enabled: z.boolean().register(z.globalRegistry, { description: "Enable aggregates feature" }).optional(),
+	db_anon_role: z.string().register(z.globalRegistry, { description: "Database role to use for anonymous requests" }).optional(),
+	db_extra_search_path: z.string().register(z.globalRegistry, { description: "Extra schemas to add to the search path" }).optional(),
+	db_max_rows: z.int().register(z.globalRegistry, { description: "Hard limit on the number of rows returned in a single Data API response. No limit when unset." }).optional(),
+	db_schemas: z.array(z.string()).register(z.globalRegistry, { description: "List of schemas to expose via the API. Default: [\"public\"]" }).optional(),
+	jwt_role_claim_key: z.string().register(z.globalRegistry, { description: "JWT claim key to use for role extraction" }).optional(),
+	jwt_cache_max_lifetime: z.int().register(z.globalRegistry, { description: "Maximum lifetime of the Data API's JWT cache, in seconds." }).optional(),
+	openapi_mode: z.string().register(z.globalRegistry, { description: "OpenAPI specification mode (ignore-privileges, disabled)" }).optional(),
+	server_cors_allowed_origins: z.string().register(z.globalRegistry, { description: "CORS allowed origins" }).optional(),
+	server_timing_enabled: z.boolean().register(z.globalRegistry, { description: "When enabled, the Data API adds `Server-Timing` headers to each response showing database execution and internal processing time. Default: disabled." }).optional()
+}).register(z.globalRegistry, { description: "Configuration settings for the Neon Data API" });
+/**
+* Create Neon Data API
+*/
+const zDataApiCreateRequest = z.strictObject({
+	auth_provider: z.enum(["neon_auth", "external"]).register(z.globalRegistry, { description: "Authentication provider for the Neon Data API. `neon_auth`: use Neon's built-in managed authentication (no JWKS configuration required). `external`: use an external JWT provider, which requires `jwks_url`. When omitted, no auth provider is configured (existing setup is kept)." }).optional(),
+	jwks_url: z.url().register(z.globalRegistry, { description: "URL of the JWKS endpoint used to verify JWTs for this Data API. Required when configuring JWT-based authentication; omit when using a non-JWT auth provider." }).optional(),
+	provider_name: z.string().register(z.globalRegistry, { description: "Display name for the authentication provider. Accepted values include \"Clerk\", \"Stytch\", and \"Auth0\", but any non-empty string is valid. Optional field." }).optional(),
+	jwt_audience: z.string().register(z.globalRegistry, { description: "Expected `aud` claim in incoming JWTs. When set, tokens with a different audience are rejected; tokens with no audience are still accepted. Omit to skip audience validation.\n" }).optional(),
+	add_default_grants: z.boolean().register(z.globalRegistry, { description: "Grant all permissions to the tables in the public schema to authenticated users" }).optional(),
+	skip_auth_schema: z.boolean().register(z.globalRegistry, { description: "Skip creating the auth schema and RLS functions" }).optional(),
+	settings: zDataApiSettings.optional()
+}).register(z.globalRegistry, { description: "Create Neon Data API" });
+/**
+* Neon Data API created successfully
+*/
+const zDataApiCreateResponse = z.strictObject({ url: z.url().register(z.globalRegistry, { description: "URL of the created Data API endpoint." }) }).register(z.globalRegistry, { description: "Neon Data API created successfully" });
+/**
+* Neon Data API response
+*/
+const zDataApiReponse = z.strictObject({
+	url: z.url().register(z.globalRegistry, { description: "The URL of the Neon Data API" }),
+	status: z.string().register(z.globalRegistry, { description: "The status of the Neon Data API deployment" }),
+	settings: zDataApiSettings.nullish(),
+	available_schemas: z.array(z.string()).nullish()
+}).register(z.globalRegistry, { description: "Neon Data API response" });
+/**
+* Update Neon Data API
+*/
+const zDataApiUpdateRequest = z.strictObject({ settings: zDataApiSettings.optional() }).register(z.globalRegistry, { description: "Update Neon Data API" });
+/**
+* Authentication provider integrated with this Neon Auth configuration. `better_auth` integrates with Better Auth (the current, recommended provider). `stack` integrates with Stack Auth (deprecated). `mock` is a simulated provider for local development and testing only.
+*/
+const zNeonAuthSupportedAuthProvider = z.enum([
+	"mock",
+	"stack",
+	"better_auth"
+]).register(z.globalRegistry, { description: "Authentication provider integrated with this Neon Auth configuration. `better_auth` integrates with Better Auth (the current, recommended provider). `stack` integrates with Stack Auth (deprecated). `mock` is a simulated provider for local development and testing only." });
+const zNeonAuthProviderProjectOwnedBy = z.enum(["user", "neon"]);
+const zNeonAuthProviderProjectTransferStatus = z.enum(["initiated", "finished"]);
+const zNeonAuthRedirectUriWhitelistDomain = z.strictObject({
+	domain: z.string().register(z.globalRegistry, { description: "Allowed redirect URI domain for the auth provider." }),
+	auth_provider: zNeonAuthSupportedAuthProvider
+});
+const zNeonAuthRedirectUriWhitelistResponse = z.strictObject({ domains: z.array(zNeonAuthRedirectUriWhitelistDomain).register(z.globalRegistry, { description: "Domains permitted as redirect URI targets in the whitelist." }) });
+const zNeonAuthAddDomainToRedirectUriWhitelistRequest = z.strictObject({
+	domain: z.url().register(z.globalRegistry, { description: "URI to add to the redirect URI allowlist for the auth provider." }),
+	auth_provider: zNeonAuthSupportedAuthProvider
+});
+const zNeonAuthDeleteDomainFromRedirectUriWhitelistItem = z.strictObject({ domain: z.url().register(z.globalRegistry, { description: "URI to remove from the redirect URI whitelist." }) });
+const zNeonAuthDeleteDomainFromRedirectUriWhitelistRequest = z.strictObject({
+	auth_provider: zNeonAuthSupportedAuthProvider,
+	domains: z.array(zNeonAuthDeleteDomainFromRedirectUriWhitelistItem).register(z.globalRegistry, { description: "Domain names to remove from the redirect URI whitelist for the specified auth provider." })
+});
+const zNeonAuthCreateIntegrationRequest = z.strictObject({
+	auth_provider: zNeonAuthSupportedAuthProvider,
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID. Returned as `id` from `GET /projects`." }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID. Returned as `id` from `GET /projects/{project_id}/branches`." }),
+	database_name: z.string().register(z.globalRegistry, { description: "Name of the database to associate with the Neon Auth integration. When omitted, the integration uses the project's default database." }).optional(),
+	role_name: z.string().register(z.globalRegistry, { description: "Deprecated. The database role for the auth integration. Omit this field; it is ignored." }).optional()
+});
+const zEnableNeonAuthIntegrationRequest = z.strictObject({
+	auth_provider: zNeonAuthSupportedAuthProvider,
+	database_name: z.string().register(z.globalRegistry, { description: "Name of the database to enable Neon Auth on. When omitted, the integration uses the project's default database." }).optional()
+});
+const zNeonAuthCreateIntegrationResponse = z.strictObject({
+	auth_provider: zNeonAuthSupportedAuthProvider,
+	auth_provider_project_id: z.string().register(z.globalRegistry, { description: "Project ID assigned by the auth provider for this integration." }),
+	pub_client_key: z.string().register(z.globalRegistry, { description: "Publishable SDK key from the auth provider. Populated only for Stack Auth (deprecated); empty for Better Auth." }),
+	secret_server_key: z.string().register(z.globalRegistry, { description: "Secret server-side SDK key from the auth provider. Populated only for Stack Auth (deprecated); empty for Better Auth. Treat as a credential." }),
+	jwks_url: z.string().register(z.globalRegistry, { description: "URL of the provider's JWKS endpoint used to verify JWTs." }),
+	schema_name: z.string().register(z.globalRegistry, { description: "Postgres schema containing the auth integration tables. Defaults to `neon_auth`." }),
+	table_name: z.string().register(z.globalRegistry, { description: "Postgres table in the integration schema where synced user records are stored." }),
+	base_url: z.string().register(z.globalRegistry, { description: "Base URL of the Neon Auth service for this integration. Set as the NEON_AUTH_BASE_URL environment variable in your application." }).optional()
+});
+const zNeonAuthCreateAuthProviderSdkKeysRequest = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID. Returned as `id` from `GET /projects`." }),
+	auth_provider: zNeonAuthSupportedAuthProvider
+});
+const zNeonAuthCreateNewUserRequest = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID. Returned as `id` from `GET /projects`." }),
+	auth_provider: zNeonAuthSupportedAuthProvider,
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address of the new user." }),
+	name: z.string().min(1).max(255).register(z.globalRegistry, { description: "Display name for the new user. When omitted, the created user has no display name." }).optional()
+});
+const zCreateBranchNeonAuthNewUserRequest = z.strictObject({
+	email: z.email().min(1).max(256).register(z.globalRegistry, { description: "Email address of the new Neon Auth user to create." }),
+	name: z.string().min(1).max(255).register(z.globalRegistry, { description: "Display name for the new user. Optional. Pair with the required email field when creating a new user." }).optional()
+});
+const zNeonAuthCreateNewUserResponse = z.strictObject({ id: z.string().register(z.globalRegistry, { description: "ID of newly created user" }) });
+const zUpdateNeonAuthUserRoleRequest = z.strictObject({ roles: z.array(z.string()).min(1).register(z.globalRegistry, { description: "Roles to assign to the user in the Neon Auth (Better Auth) directory. `user` and `admin` are the built-in roles; custom role strings are also supported." }) });
+const zUpdateNeonAuthUserRoleResponse = z.strictObject({ id: z.string().register(z.globalRegistry, { description: "ID of the updated user" }) });
+const zNeonAuthAllowLocalhostResponse = z.strictObject({ allow_localhost: z.boolean().register(z.globalRegistry, { description: "Whether to allow localhost connections" }) });
+const zUpdateNeonAuthAllowLocalhostRequest = z.strictObject({ allow_localhost: z.boolean().register(z.globalRegistry, { description: "Whether to allow localhost connections" }) });
+const zNeonAuthOrganizationConfig = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Whether the organization plugin is enabled." }),
+	organization_limit: z.int().gte(1).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Maximum organizations a user can belong to (created or joined). At the limit, the user cannot create or join more." }),
+	membership_limit: z.int().gte(1).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Maximum number of members per organization." }),
+	creator_role: z.enum(["admin", "owner"]).register(z.globalRegistry, { description: "Role of the organization's creator. `owner`: full control, including deleting the org and transferring ownership. `admin`: manage members and settings only." }),
+	send_invitation_email: z.boolean().register(z.globalRegistry, { description: "Whether to send invitation emails when inviting members to an organization." })
+});
+const zNeonAuthOrganizationConfigUpdate = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Controls whether the organization plugin is active for the organization." }).optional(),
+	organization_limit: z.int().gte(1).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Maximum organizations a user can belong to (created or joined). At the limit, the user cannot create or join more." }).optional(),
+	membership_limit: z.int().gte(1).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "Maximum members per organization." }).optional(),
+	creator_role: z.enum(["admin", "owner"]).register(z.globalRegistry, { description: "Role of the organization's creator. `owner`: full control, including deleting the org and transferring ownership. `admin`: manage members and settings only." }).optional(),
+	send_invitation_email: z.boolean().register(z.globalRegistry, { description: "When true, invited users receive an email containing an accept link. Requires that the invited user has a verified email address." }).optional()
+});
+const zNeonAuthMagicLinkConfig = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Whether the magic link plugin is enabled." }),
+	expires_in: z.int().gte(5).lte(1440).register(z.globalRegistry, { description: "Minutes until the magic link expires." }),
+	disable_sign_up: z.boolean().register(z.globalRegistry, { description: "Whether to disable sign-up via magic link." })
+});
+const zNeonAuthMagicLinkConfigUpdate = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Whether to enable the magic link plugin." }).optional(),
+	expires_in: z.int().gte(5).lte(1440).register(z.globalRegistry, { description: "Minutes until the magic link expires." }).optional(),
+	disable_sign_up: z.boolean().register(z.globalRegistry, { description: "When true, sign-up via magic link is disabled." }).optional()
+});
+const zNeonAuthPhoneNumberConfig = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Whether the phone number plugin is enabled." }),
+	otp_expires_in: z.int().gte(60).lte(600).register(z.globalRegistry, { description: "Time in seconds before the OTP expires" }).optional()
+});
+const zNeonAuthPhoneNumberConfigUpdate = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Whether the phone number plugin is enabled." }).optional(),
+	otp_expires_in: z.int().gte(60).lte(600).register(z.globalRegistry, { description: "Time in seconds before the OTP expires" }).optional()
+});
+const zNeonAuthTransferAuthProviderProjectRequest = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID. Returned as `id` from `GET /projects`." }),
+	auth_provider: zNeonAuthSupportedAuthProvider
+});
+const zNeonAuthTransferAuthProviderProjectResponse = z.strictObject({ url: z.string().register(z.globalRegistry, { description: "URL for completing the process of ownership transfer" }) });
+const zNeonAuthWebhookConfig = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Whether the webhook is active." }),
+	webhook_url: z.string().register(z.globalRegistry, { description: "Destination URL that receives webhook event payloads." }).optional(),
+	enabled_events: z.array(z.enum([
+		"user.before_create",
+		"user.created",
+		"send.otp",
+		"send.magic_link",
+		"organization.invitation.created",
+		"organization.invitation.accepted",
+		"phone_number.verified"
+	])).register(z.globalRegistry, { description: "Event types that trigger this webhook. Covers user lifecycle, email/OTP delivery, organization invitations, and phone verification events; see the enum for exact values." }).optional(),
+	timeout_seconds: z.int().gte(1).lte(10).register(z.globalRegistry, { description: "Maximum time, in seconds, to wait for a response from the webhook endpoint." }).optional()
+});
+const zNeonAuthOauthProviderId = z.enum([
+	"google",
+	"github",
+	"microsoft",
+	"vercel"
+]);
+const zNeonAuthOauthProviderType = z.enum(["standard", "shared"]);
+const zNeonAuthOauthProvider = z.strictObject({
+	id: zNeonAuthOauthProviderId,
+	type: zNeonAuthOauthProviderType,
+	client_id: z.string().register(z.globalRegistry, { description: "Public identifier for the OAuth application, issued by the provider when the application is registered." }).optional(),
+	client_secret: z.string().register(z.globalRegistry, { description: "OAuth client secret for the provider." }).optional()
+});
+const zListNeonAuthOauthProvidersResponse = z.strictObject({ providers: z.array(zNeonAuthOauthProvider).register(z.globalRegistry, { description: "OAuth providers configured for Neon Auth on the project." }) });
+const zNeonAuthAddOAuthProviderRequest = z.strictObject({
+	id: zNeonAuthOauthProviderId,
+	client_id: z.string().register(z.globalRegistry, { description: "The client ID issued by the OAuth provider for your application. Used to identify the application during the OAuth flow." }).optional(),
+	client_secret: z.string().register(z.globalRegistry, { description: "OAuth client secret for the provider." }).optional(),
+	microsoft_tenant_id: z.string().register(z.globalRegistry, { description: "Tenant ID for the Microsoft OAuth provider. Only relevant when the OAuth provider is Microsoft; omit or leave blank for other providers." }).optional()
+});
+const zNeonAuthUpdateOAuthProviderRequest = z.strictObject({
+	client_id: z.string().register(z.globalRegistry, { description: "The OAuth client ID registered with the provider. Omit to keep the currently configured value." }).optional(),
+	client_secret: z.string().register(z.globalRegistry, { description: "OAuth client secret for the provider. Omit to leave the existing secret unchanged." }).optional(),
+	microsoft_tenant_id: z.string().register(z.globalRegistry, { description: "The tenant ID scoping the Microsoft OAuth provider. Supply this field when the provider type is microsoft; it has no effect for other provider types." }).optional()
+});
+const zSharedEmailServer = z.strictObject({
+	sender_email: z.string().register(z.globalRegistry, { description: "Email address used as the sender for outgoing messages from this shared email server." }).optional(),
+	sender_name: z.string().register(z.globalRegistry, { description: "Display name shown as the sender in outgoing emails." }).optional()
+});
+const zStandardEmailServer = z.strictObject({
+	host: z.string().register(z.globalRegistry, { description: "Hostname of the email server." }).optional(),
+	port: z.int().register(z.globalRegistry, { description: "TCP port of the SMTP server. Common values: 25 (SMTP), 465 (SMTPS), 587 (submission)." }).optional(),
+	username: z.string().register(z.globalRegistry, { description: "Username for authenticating with the SMTP server." }).optional(),
+	password: z.string().register(z.globalRegistry, { description: "Password for authenticating with the SMTP server." }).optional(),
+	sender_email: z.string().register(z.globalRegistry, { description: "Email address used as the From address on outgoing auth emails." }).optional(),
+	sender_name: z.string().register(z.globalRegistry, { description: "Display name shown as the sender in outgoing emails." }).optional()
+});
+const zStandardEmailServerResponse = z.strictObject({
+	host: z.string().register(z.globalRegistry, { description: "Hostname of the email server." }),
+	port: z.int().register(z.globalRegistry, { description: "TCP port of the SMTP server. Common values: 25 (SMTP), 465 (SMTPS), 587 (submission)." }),
+	username: z.string().register(z.globalRegistry, { description: "Username for authenticating with the SMTP server." }),
+	password: z.string().register(z.globalRegistry, { description: "On GET, returned redacted (empty) for ordinary callers, while callers with project-credential read permission receive the stored password — do not assume this field is empty. Update (PATCH) responses always return it redacted (empty) regardless of permission. Provide a value on update to set or rotate the password." }),
+	sender_email: z.string().register(z.globalRegistry, { description: "Email address used as the From address on outgoing auth emails." }),
+	sender_name: z.string().register(z.globalRegistry, { description: "Display name shown as the sender in outgoing emails." })
+});
+const zNeonAuthEmailServerConfig = z.discriminatedUnion("type", [zStandardEmailServer.extend({ type: z.literal("standard") }), zSharedEmailServer.extend({ type: z.literal("shared") })]);
+const zNeonAuthEmailServerConfigResponse = z.discriminatedUnion("type", [zStandardEmailServerResponse.extend({ type: z.literal("standard") }), zSharedEmailServer.extend({ type: z.literal("shared") })]);
+const zSendNeonAuthTestEmailRequest = z.strictObject({
+	host: z.string().register(z.globalRegistry, { description: "Hostname of the email server." }),
+	port: z.int().register(z.globalRegistry, { description: "TCP port of the SMTP server. Common values: 25 (SMTP), 465 (SMTPS), 587 (submission)." }),
+	username: z.string().register(z.globalRegistry, { description: "Username for authenticating with the SMTP server." }),
+	password: z.string().register(z.globalRegistry, { description: "Password for authenticating with the SMTP server." }),
+	sender_email: z.string().register(z.globalRegistry, { description: "Email address used as the From address on outgoing auth emails." }),
+	sender_name: z.string().register(z.globalRegistry, { description: "Display name shown as the sender in outgoing emails." }),
+	recipient_email: z.email().min(1).max(256).register(z.globalRegistry, { description: "The email address to send the test email to." })
+});
+const zSendNeonAuthTestEmailResponse = z.strictObject({
+	success: z.boolean().register(z.globalRegistry, { description: "Whether the test email was sent successfully." }),
+	error_message: z.string().register(z.globalRegistry, { description: "The error message from the email server." }).optional()
+});
+/**
+* The email verification method to use.
+* - `link`: Sends a verification link via email
+* - `otp`: Sends a one-time password (OTP) via email
+*
+*/
+const zNeonAuthEmailVerificationMethod = z.enum(["link", "otp"]).register(z.globalRegistry, { description: "The email verification method to use.\n- `link`: Sends a verification link via email\n- `otp`: Sends a one-time password (OTP) via email\n" });
+const zNeonAuthEmailAndPasswordConfig = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Whether email and password authentication is enabled" }),
+	email_verification_method: zNeonAuthEmailVerificationMethod,
+	require_email_verification: z.boolean().register(z.globalRegistry, { description: "Whether email verification is required before users can sign in" }),
+	auto_sign_in_after_verification: z.boolean().register(z.globalRegistry, { description: "Whether users are automatically signed in after verifying their email" }),
+	send_verification_email_on_sign_up: z.boolean().register(z.globalRegistry, { description: "Whether to send a verification email when users sign up" }),
+	send_verification_email_on_sign_in: z.boolean().register(z.globalRegistry, { description: "Whether to send a verification email when users sign in" }),
+	disable_sign_up: z.boolean().register(z.globalRegistry, { description: "Whether to disable new user sign ups" })
+});
+/**
+* Aggregated plugin configurations for Neon Auth
+*/
+const zNeonAuthPluginConfigs = z.strictObject({
+	organization: zNeonAuthOrganizationConfig.optional(),
+	magic_link: zNeonAuthMagicLinkConfig.optional(),
+	phone_number: zNeonAuthPhoneNumberConfig.optional(),
+	email_provider: zNeonAuthEmailServerConfigResponse.optional(),
+	email_and_password: zNeonAuthEmailAndPasswordConfig.optional(),
+	oauth_providers: z.array(zNeonAuthOauthProvider).register(z.globalRegistry, { description: "OAuth provider configurations enabled for this auth setup." }).optional(),
+	allow_localhost: z.boolean().register(z.globalRegistry, { description: "Permits authentication requests from localhost origins when true. Intended for local development; disable in production environments." }).optional()
+}).register(z.globalRegistry, { description: "Aggregated plugin configurations for Neon Auth" });
+const zNeonAuthEmailAndPasswordConfigUpdate = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Controls whether email and password authentication is enabled for this project. When omitted from an update request, the current value is unchanged." }).optional(),
+	email_verification_method: zNeonAuthEmailVerificationMethod.optional(),
+	require_email_verification: z.boolean().register(z.globalRegistry, { description: "When true, users must verify their email address before they can sign in. Omitting this field from an update request leaves the current value unchanged." }).optional(),
+	auto_sign_in_after_verification: z.boolean().register(z.globalRegistry, { description: "Whether users are automatically signed in after verifying their email" }).optional(),
+	send_verification_email_on_sign_up: z.boolean().register(z.globalRegistry, { description: "Whether to send a verification email when users sign up." }).optional(),
+	send_verification_email_on_sign_in: z.boolean().register(z.globalRegistry, { description: "Whether to send a verification email when a user with an unverified email signs in." }).optional(),
+	disable_sign_up: z.boolean().register(z.globalRegistry, { description: "Whether to disable new user sign ups. When omitted, the current setting is not changed." }).optional()
+});
+const zNeonAuthIntegration = z.strictObject({
+	auth_provider: zNeonAuthSupportedAuthProvider,
+	auth_provider_project_id: z.string().register(z.globalRegistry, { description: "Project identifier assigned by the auth provider for this integration." }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID. Returned as `id` from `GET /projects/{project_id}/branches`." }),
+	db_name: z.string().register(z.globalRegistry, { description: "Name of the database used by the Neon Auth integration." }),
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp when the Neon Auth integration was created, in RFC 3339 format (UTC)." }),
+	owned_by: zNeonAuthProviderProjectOwnedBy,
+	transfer_status: zNeonAuthProviderProjectTransferStatus.optional(),
+	jwks_url: z.string().register(z.globalRegistry, { description: "URL of the provider's JWKS endpoint used to verify JWTs." }),
+	base_url: z.string().register(z.globalRegistry, { description: "Base URL of the Neon Auth service endpoint for this integration. Injected into the project environment as `NEON_AUTH_BASE_URL`." }).optional(),
+	name: z.string().min(1).max(256).register(z.globalRegistry, { description: "Application name shown in auth emails and communications. Defaults to the project name." }).optional()
+});
+const zListNeonAuthIntegrationsResponse = z.strictObject({ data: z.array(zNeonAuthIntegration).register(z.globalRegistry, { description: "Neon Auth integrations configured for the project." }) });
+const zNeonAuthConfigUpdate = z.strictObject({ name: z.string().min(1).max(256).register(z.globalRegistry, { description: "The application name used in auth emails and communications." }) });
+const zNeonAuthConfigResponse = z.strictObject({ name: z.string().register(z.globalRegistry, { description: "The application name used in auth emails and communications." }) });
+const zErrorCode = z.string();
+const zGeneralError = z.strictObject({
+	request_id: z.string().register(z.globalRegistry, { description: "Unique identifier for the request, useful for debugging.\nYou can set this value manually by including an `X-Request-ID` header in the request. If not provided, the value will be generated automatically.\n" }).optional(),
+	code: zErrorCode,
+	message: z.string().register(z.globalRegistry, { description: "Error message" })
+});
+const zBranchOperations = zBranchResponse.merge(zOperationsResponse);
+const zBranchRecoverResponse = zBranchResponse.merge(zEndpointsOptionalResponse);
+const zEndpointOperations = zEndpointResponse.merge(zOperationsResponse);
+const zDatabaseOperations = zDatabaseResponse.merge(zOperationsResponse);
+const zRoleOperations = zRoleResponse.merge(zOperationsResponse);
+const zJwksCreationOperation = zJwksResponse.merge(zOperationsResponse);
+/**
+* A free-form map of string key-value pairs for attaching metadata to a resource (for example, a git commit reference). Maximum 50 entries.
+*/
+const zAnnotationValueData = z.record(z.string(), z.string()).register(z.globalRegistry, { description: "A free-form map of string key-value pairs for attaching metadata to a resource (for example, a git commit reference). Maximum 50 entries." });
+const zProjectCreateRequest = z.strictObject({ project: z.strictObject({
+	settings: zProjectSettingsData.optional(),
+	name: z.string().min(1).max(256).register(z.globalRegistry, { description: "The project name. If not specified, the name will be identical to the generated project ID" }).optional(),
+	branch: z.strictObject({
+		name: z.string().min(1).max(256).register(z.globalRegistry, { description: "The default branch name. If not specified, the default branch name, `main`, will be used.\n" }).optional(),
+		role_name: z.string().register(z.globalRegistry, { description: "The role name. If not specified, the default role name, `{database_name}_owner`, will be used.\n" }).optional(),
+		database_name: z.string().register(z.globalRegistry, { description: "The database name. If not specified, the default database name, `neondb`, will be used.\n" }).optional(),
+		annotations: zAnnotationValueData.optional()
+	}).register(z.globalRegistry, { description: "Configuration for the initial branch created with the project." }).optional(),
+	autoscaling_limit_min_cu: zComputeUnit.optional(),
+	autoscaling_limit_max_cu: zComputeUnit.optional(),
+	provisioner: zProvisioner.optional(),
+	region_id: z.string().register(z.globalRegistry, { description: "The region identifier. Refer to our [Regions](https://neon.com/docs/introduction/regions) documentation for supported regions. Values are specified in this format: `aws-us-east-1`\n" }).optional(),
+	default_endpoint_settings: zDefaultEndpointSettings.optional(),
+	pg_version: zPgVersion.optional(),
+	store_passwords: z.boolean().register(z.globalRegistry, { description: "Whether or not passwords are stored for roles in the Neon project. Storing passwords facilitates access to Neon features that require authorization.\n" }).optional(),
+	history_retention_seconds: z.int().gte(0).lte(2592e3).register(z.globalRegistry, { description: "History window (point-in-time restore range) for all branches, in seconds. `0` disables it. Default 1 day (Free: 6 hours). Maximum depends on plan: Free 6 hours (21600), Launch 7 days (604800), Scale 30 days (2592000).\n" }).optional(),
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "ID of the organization that will own the project. If omitted when using an organization API key, it is inferred from the key.\n" }).optional()
+}).register(z.globalRegistry, { description: "Configuration for the new project, including name, region, and Postgres compute and storage settings." }) });
+const zAnnotationObjectData = z.strictObject({
+	type: z.string().register(z.globalRegistry, { description: "Kind of resource the annotation is attached to, for example \"branch\" or \"endpoint\"." }),
+	id: z.string().register(z.globalRegistry, { description: "The annotated object's ID." })
+});
+const zAnnotationData = z.strictObject({
+	object: zAnnotationObjectData,
+	value: zAnnotationValueData,
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp when the annotation was created, in RFC 3339 format (UTC)." }).optional(),
+	updated_at: z.iso.datetime().register(z.globalRegistry, { description: "Timestamp of the most recent update to the annotation, in RFC 3339 format (UTC)." }).optional()
+});
+const zAnnotationCreateValueRequest = z.strictObject({ annotation_value: zAnnotationValueData.optional() });
+const zBranchAnonymizedCreateRequest = zAnnotationCreateValueRequest.merge(z.strictObject({
+	branch_create: zBranchCreateRequest.optional(),
+	masking_rules: z.array(zMaskingRule).register(z.globalRegistry, { description: "List of masking rules to apply to the branch.\n" }).optional(),
+	start_anonymization: z.boolean().register(z.globalRegistry, { description: "If true, automatically start anonymization after the branch is created.\nDefaults to false.\n" }).optional()
+}));
+const zAnnotationResponse = z.strictObject({ annotation: zAnnotationData });
+const zAnnotationsMapResponse = z.strictObject({ annotations: z.record(z.string(), zAnnotationData).register(z.globalRegistry, { description: "Map of annotations keyed by resource identifier, where each value contains the annotation data for that resource." }) });
+/**
+* Type of application integration
+*/
+const zApplicationType = z.enum([
+	"vercel",
+	"github",
+	"datadog",
+	"opentelemetry"
+]).register(z.globalRegistry, { description: "Type of application integration" });
+/**
+* A map where key is a project ID and a value is a list of installed applications.
+*
+*/
+const zProjectsApplicationsMapResponse = z.strictObject({ applications: z.record(z.string(), z.array(zApplicationType)).register(z.globalRegistry, { description: "Map of project IDs to their installed applications. Each key is a project ID; each value is an array of application types (for example, `vercel`, `github`)." }) }).register(z.globalRegistry, { description: "A map where key is a project ID and a value is a list of installed applications.\n" });
+/**
+* A map where key is a project ID and a value is a list of installed integrations.
+*
+*/
+const zProjectsIntegrationsMapResponse = z.strictObject({ integrations: z.record(z.string(), z.array(zApplicationType)).register(z.globalRegistry, { description: "Map of project IDs to their associated integration details." }) }).register(z.globalRegistry, { description: "A map where key is a project ID and a value is a list of installed integrations.\n" });
+/**
+* To paginate the response, issue an initial request with `limit` value. Then, add the value returned in the response `.pagination.next` attribute into the request under the `cursor` query parameter to the subsequent request to retrieve next page in pagination. The contents on cursor `next` are opaque, clients are not expected to make any assumptions on the format of the data inside the cursor.
+*/
+const zCursorPagination = z.strictObject({
+	next: z.string().register(z.globalRegistry, { description: "Cursor for the next page of results. Pass it as the `cursor` query parameter on the next request. Absent on the last page." }).optional(),
+	sort_by: z.string().register(z.globalRegistry, { description: "Field by which the results were sorted, echoing the request's sort_by parameter." }).optional(),
+	sort_order: z.string().register(z.globalRegistry, { description: "Sort order active for this page. Pass back as `sort_order` in the next request to maintain consistent ordering. Valid values are `asc` and `desc`." }).optional()
+}).register(z.globalRegistry, { description: "To paginate the response, issue an initial request with `limit` value. Then, add the value returned in the response `.pagination.next` attribute into the request under the `cursor` query parameter to the subsequent request to retrieve next page in pagination. The contents on cursor `next` are opaque, clients are not expected to make any assumptions on the format of the data inside the cursor." });
+const zProjectMembers = z.strictObject({
+	project_members: z.array(zProjectMember),
+	pagination: zCursorPagination.optional()
+});
+const zCursorPaginationResponse = z.strictObject({ pagination: zCursorPagination.optional() });
+const zSnapshot = z.strictObject({
+	id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The snapshot ID." }),
+	name: z.string().register(z.globalRegistry, { description: "Human-readable label for the snapshot." }),
+	lsn: z.string().register(z.globalRegistry, { description: "WAL position (Log Sequence Number) at which the snapshot was captured, in Postgres LSN format (for example, `0/3000000`)." }).optional(),
+	timestamp: z.string().register(z.globalRegistry, { description: "Point in time captured by the snapshot, in RFC 3339 format (UTC)." }).optional(),
+	source_branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "Branch from which this snapshot was created." }).optional(),
+	created_at: z.string().register(z.globalRegistry, { description: "Timestamp when the snapshot was created, in RFC 3339 format (UTC)." }),
+	expires_at: z.string().register(z.globalRegistry, { description: "RFC 3339 timestamp when the snapshot expires and is eligible for deletion. Null if the snapshot does not have an expiry." }).optional(),
+	manual: z.boolean().register(z.globalRegistry, { description: "True if the snapshot was created manually rather than by a schedule." }).optional(),
+	full_size: z.int().register(z.globalRegistry, { description: "Full logical size of the snapshot in bytes at the time it was taken.\n\nWhen absent, the logical size has not been calculated yet and the snapshot is not being charged.\n\nWhen present, a value of 0 means the snapshot is not being charged.\n" }).optional(),
+	diff_size: z.int().register(z.globalRegistry, { description: "Incremental Postgres storage size in bytes since the previous scheduled snapshot, when the snapshot is billed on incremental (diff) usage.\n\nWhen absent, either the incremental size has not been calculated yet and the snapshot is not being charged, or the snapshot is charged at full logical size (in that case `full_size` is set).\n" }).optional()
+});
+const zSnapshotUpdateRequest = z.strictObject({ snapshot: z.strictObject({
+	name: z.string().register(z.globalRegistry, { description: "Human-readable label for the snapshot." }).optional(),
+	expires_at: z.iso.datetime().nullish()
+}).register(z.globalRegistry, { description: "Fields to update on the snapshot. Updatable fields include `name` and `expires_at`." }) });
+const zBackupScheduleItem = z.strictObject({
+	frequency: z.string().register(z.globalRegistry, { description: "How often to take snapshots. Known values: `daily`, `weekly`, `monthly`.\n" }),
+	hour: z.int().gte(0).lte(23).register(z.globalRegistry, { description: "The hour of the day to take the snapshot (if applicable).\n" }).optional(),
+	day: z.int().gte(1).lte(31).register(z.globalRegistry, { description: "The day of the week or month to take the snapshot (if applicable).\n" }).optional(),
+	month: z.int().gte(1).lte(12).register(z.globalRegistry, { description: "The month of the year to take the snapshot (if applicable).\n" }).optional(),
+	retention_seconds: z.int().gte(3600).lte(3024e3).register(z.globalRegistry, { description: "How long to keep a scheduled snapshot (in seconds) before it's automatically deleted.\nThe default is 3024000 seconds (35 days), which is also the maximum.\nManually created snapshots have no maximum retention: set their `expires_at` instead.\n" }).optional()
+});
+const zBackupSchedule = z.strictObject({ schedule: z.array(zBackupScheduleItem).register(z.globalRegistry, { description: "List of schedule entries defining the backup frequency. At least one entry is required." }) });
+const zBranchSchemaJson = z.strictObject({ tables: z.array(z.strictObject({
+	schema: z.string().register(z.globalRegistry, { description: "Postgres schema (namespace) that contains the table, for example `public`." }),
+	name: z.string().register(z.globalRegistry, { description: "Name of the table within the schema." }),
+	columns: z.array(z.strictObject({
+		name: z.string().register(z.globalRegistry, { description: "Name of the column." }),
+		type: z.string().register(z.globalRegistry, { description: "Postgres data type of the column, for example \"integer\" or \"text\"." }),
+		nullable: z.boolean().register(z.globalRegistry, { description: "Whether the column allows NULL values" }).optional(),
+		generated: z.boolean().register(z.globalRegistry, { description: "Whether the column is a generated (computed) column" }).optional()
+	})).register(z.globalRegistry, { description: "Columns belonging to this table, each describing a column's name and attributes." }),
+	constraints: z.array(z.strictObject({
+		type: z.string().register(z.globalRegistry, { description: "Type of constraint. Possible values: `primary_key`, `unique`, `foreign_key`\n" }),
+		columns: z.array(z.string()).min(1).register(z.globalRegistry, { description: "Column names participating in this constraint" }),
+		name: z.string().register(z.globalRegistry, { description: "Optional name of the constraint" }).optional(),
+		referenced_table: z.strictObject({
+			schema: z.string().register(z.globalRegistry, { description: "Schema of the referenced table" }),
+			table: z.string().register(z.globalRegistry, { description: "Name of the referenced table" }),
+			columns: z.array(z.string()).register(z.globalRegistry, { description: "Names of the referenced columns" })
+		}).register(z.globalRegistry, { description: "For foreign keys - the referenced table information" }).optional()
+	})).register(z.globalRegistry, { description: "Table constraints defined in the branch schema, such as primary key, foreign key, unique, and check constraints." }).optional()
+})).register(z.globalRegistry, { description: "Tables present in the branch schema." }) });
+const zBranchSchemaResponse = z.strictObject({
+	sql: z.string().register(z.globalRegistry, { description: "Branch schema expressed as SQL DDL statements." }).optional(),
+	json: zBranchSchemaJson.optional()
+});
+/**
+* Controls anonymous access to objects in the bucket.
+* - `private`: all reads and writes require authenticated requests (default).
+* - `public_read`: anonymous `GetObject`/`HeadObject` requests succeed; listing,
+* writes, and deletes still require authenticated requests.
+*
+*/
+const zBucketAccessLevel = z.enum(["private", "public_read"]).register(z.globalRegistry, { description: "Controls anonymous access to objects in the bucket.\n- `private`: all reads and writes require authenticated requests (default).\n- `public_read`: anonymous `GetObject`/`HeadObject` requests succeed; listing,\n  writes, and deletes still require authenticated requests.\n" });
+const zBucket = z.strictObject({
+	name: z.string().register(z.globalRegistry, { description: "The bucket name (unique within a branch)." }),
+	access_level: zBucketAccessLevel,
+	created_at: z.iso.datetime().register(z.globalRegistry, { description: "When the bucket was created. For a bucket inherited from an\nancestor branch this is the ancestor's creation time (the branch\nfork never re-creates the bucket).\n" })
+});
+const zBucketCreateRequest = z.strictObject({
+	name: z.string().min(1).max(255).register(z.globalRegistry, { description: "The bucket name." }),
+	access_level: z.enum(["private", "public_read"]).register(z.globalRegistry, { description: "Access level for the bucket. Defaults to `private`. Set to `public_read`\nto allow anonymous `GetObject`/`HeadObject` on objects in this bucket.\n" }).optional()
+});
+const zBucketResponse = z.strictObject({ bucket: zBucket });
+const zBucketsListResponse = z.strictObject({ buckets: z.array(zBucket) });
+const zBranchStorage = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Always `true` in 200 responses. Present for forward compatibility: a\nfuture version may add intermediate states; callers should treat `true`\nas \"object storage is usable for this branch right now.\"\n" }),
+	s3_endpoint: z.url().register(z.globalRegistry, { description: "The S3-compatible endpoint URL for this branch." }),
+	region: z.string().register(z.globalRegistry, { description: "The AWS region for this branch's object storage. The platform normalizes\nthe us-east-1 convention server-side: a non-empty region string is\nalways returned in 200 responses (e.g. `\"us-east-1\"` for the S3\ndefault region).\n" }),
+	force_path_style: z.boolean().register(z.globalRegistry, { description: "Whether the S3 client must use path-style addressing\n(bucket-in-path rather than virtual-hosted subdomain).\nAlways true: the wildcard TLS cert covers one level of subdomain\n(*.storage.<suffix>), so the branch ID occupies that label and the\nbucket name must travel in the request path, not as a further\nsubdomain. Callers must set the S3 SDK's ForcePathStyle (or\nequivalent) to true.\n" })
+});
+const zBranchStorageNotEnabled = z.strictObject({
+	code: z.string(),
+	message: z.string(),
+	reason: z.enum([
+		"org_not_entitled",
+		"region_unavailable",
+		"branch_directory_missing",
+		"branch_not_found"
+	]).register(z.globalRegistry, { description: "Machine-readable reason why object storage is unavailable:\n- `org_not_entitled`: the org's `PlatformBranchableStorage` feature flag is off.\n- `region_unavailable`: the project's region has no object storage admin service wired.\n- `branch_directory_missing`: the branch is not registered in the object storage service.\n- `branch_not_found`: the project or branch does not exist, or the caller does not\n  have access to it.\n" })
+});
+/**
+* The Neon service that emitted the log record.
+*/
+const zProjectBranchLogSource = z.enum([
+	"function",
+	"storage",
+	"pg_endpoint"
+]).register(z.globalRegistry, { description: "The Neon service that emitted the log record." });
+/**
+* An OpenTelemetry severity level. A minimum severity includes every
+* higher level in this order: `trace`, `debug`, `info`, `warn`, `error`,
+* `fatal`.
+*
+*/
+const zProjectBranchLogSeverity = z.enum([
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal"
+]).register(z.globalRegistry, { description: "An OpenTelemetry severity level. A minimum severity includes every\nhigher level in this order: `trace`, `debug`, `info`, `warn`, `error`,\n`fatal`.\n" });
+/**
+* A length of time as a count and a unit, for example `30m`, `6h`, or
+* `7d`. Valid units are `ms`, `s`, `m`, `h`, and `d`.
+*
+*/
+const zProjectBranchLogDuration = z.string().regex(/^[0-9]{1,6}(ms|s|m|h|d)$/).register(z.globalRegistry, { description: "A length of time as a count and a unit, for example `30m`, `6h`, or\n`7d`. Valid units are `ms`, `s`, `m`, `h`, and `d`.\n" });
+const zProjectBranchLogsNotAvailable = z.strictObject({
+	code: z.string(),
+	message: z.string(),
+	reason: z.enum(["branch_not_found", "telemetry_not_enabled"]).register(z.globalRegistry, { description: "Machine-readable reason why logs cannot be read:\n- `branch_not_found`: the project or branch does not exist, or the caller does not\n  have access to it.\n- `telemetry_not_enabled`: the branch exists but is not collecting telemetry, so it\n  has no logs to serve.\n" })
+});
+const zProjectBranchLogsInvalidQuery = z.strictObject({
+	code: z.string(),
+	message: z.string(),
+	reason: z.enum([
+		"time_range_too_large",
+		"invalid_time_range",
+		"conflicting_time_range",
+		"invalid_cursor",
+		"unknown_field",
+		"invalid_logql",
+		"conflicting_filters"
+	]).register(z.globalRegistry, { description: "Machine-readable reason why the request was rejected:\n- `time_range_too_large`: the requested window spans more than seven days.\n- `invalid_time_range`: `end_time` is not after `start_time`.\n- `conflicting_time_range`: both `since` and `start_time` were supplied.\n- `invalid_cursor`: the supplied `cursor` is malformed, expired, or was issued for a\n  different query.\n- `unknown_field`: the requested `field_name` is not one of the fields the log fields\n  endpoint reports for this branch.\n- `invalid_logql`: the supplied `logql` expression does not parse, or uses a\n  construct this endpoint does not accept.\n- `conflicting_filters`: `logql` was supplied alongside one or more structured\n  filters. Use one or the other.\n" })
+});
+const zProjectBranchLogsQueryRequest = z.strictObject({
+	since: zProjectBranchLogDuration.optional(),
+	start_time: z.iso.datetime().register(z.globalRegistry, { description: "Inclusive beginning of the query window. Mutually exclusive with\n`since`. Defaults to one hour before `end_time`, or one hour before\nthe current time when both bounds are omitted.\n" }).optional(),
+	end_time: z.iso.datetime().register(z.globalRegistry, { description: "Exclusive end of the query window. Defaults to the current time." }).optional(),
+	limit: z.int().gte(1).lte(1e3).register(z.globalRegistry, { description: "Maximum number of log records to return per page." }).optional(),
+	cursor: z.string().register(z.globalRegistry, { description: "Opaque pagination cursor returned as `next_cursor` by a previous\ncall. Resume the query after the last record of the previous page,\nrepeating the time range and every filter unchanged.\n" }).optional(),
+	sort_order: z.enum(["asc", "desc"]).register(z.globalRegistry, { description: "Order matching records by timestamp. `desc`, the default, returns\nthe newest records first.\n" }).optional(),
+	source: zProjectBranchLogSource.optional(),
+	service_name: z.string().min(1).register(z.globalRegistry, { description: "Match the OpenTelemetry `service.name` resource attribute exactly." }).optional(),
+	scope_name: z.string().min(1).register(z.globalRegistry, { description: "Match the OpenTelemetry instrumentation scope name exactly." }).optional(),
+	minimum_severity: zProjectBranchLogSeverity.optional(),
+	severity_text: z.string().min(1).register(z.globalRegistry, { description: "Match the OpenTelemetry severity text exactly." }).optional(),
+	body_contains: z.string().min(1).register(z.globalRegistry, { description: "Match records whose rendered `message` contains this case-sensitive\nsubstring.\n\nRecords with a structured body are matched against their JSON\nrendering, so the substring meets JSON syntax rather than prose: a\nbare key name such as `operation` matches every record carrying that\nkey, and `http_status: 200` matches none, because the rendering\ncontains `\"http_status\":200` with no space.\n" }).optional(),
+	trace_id: z.string().regex(/^[0-9a-f]{32}$/).register(z.globalRegistry, { description: "Match records associated with this OpenTelemetry trace ID. W3C Trace\nContext defines a trace ID as 32 lowercase hex digits, and that is\nwhat is stored, so an uppercase value is rejected rather than\nsilently matching nothing.\n" }).optional(),
+	logql: z.string().min(1).register(z.globalRegistry, { description: "Escape hatch for selections the structured filters cannot express: a\nraw LogQL expression, evaluated against this branch's log stream.\n\nOnly stream selectors and line filters are accepted — no\naggregations and no parser stages. Supplying this alongside any\nstructured filter is rejected with `conflicting_filters` rather than\nsilently ignoring one of them. `limit`, `sort_order`, and the time\nwindow still apply.\n\nThis field passes the underlying query language through to the\ncaller, so unlike the rest of this contract it may change as that\nbackend changes. Prefer the structured filters where they suffice.\n" }).optional()
+});
+const zProjectBranchLogRecord = z.strictObject({
+	timestamp: z.iso.datetime().register(z.globalRegistry, { description: "The OpenTelemetry record timestamp in UTC." }),
+	message: z.string().register(z.globalRegistry, { description: "The OpenTelemetry log body rendered as text. A body that is already a\nstring is returned verbatim. Any other OpenTelemetry `AnyValue` body\n— notably the structured key/value body that `storage` records always\ncarry — is rendered as compact JSON with its keys sorted\nalphabetically, for example\n`{\"bytes\":1024,\"operation\":\"GET\",\"object_key\":\"a/b.png\"}`.\n" }),
+	source: zProjectBranchLogSource.optional(),
+	entity_id: z.string().register(z.globalRegistry, { description: "The Neon identifier of the service instance that emitted the record." }).optional(),
+	service_name: z.string().register(z.globalRegistry, { description: "The OpenTelemetry `service.name` resource attribute." }).optional(),
+	scope_name: z.string().register(z.globalRegistry, { description: "The OpenTelemetry instrumentation scope name." }).optional(),
+	severity_number: z.int().gte(0).lte(24).register(z.globalRegistry, { description: "The numeric OpenTelemetry severity." }).optional(),
+	severity_text: z.string().register(z.globalRegistry, { description: "The original OpenTelemetry severity text." }).optional(),
+	trace_id: z.string().register(z.globalRegistry, { description: "The OpenTelemetry trace ID, when the record belongs to a trace." }).optional(),
+	span_id: z.string().register(z.globalRegistry, { description: "The OpenTelemetry span ID, when the record belongs to a span." }).optional(),
+	attributes: z.record(z.string(), z.unknown()).register(z.globalRegistry, { description: "Customer-defined OpenTelemetry log and resource attributes." })
+});
+const zProjectBranchLogsQueryResponse = z.strictObject({
+	logs: z.array(zProjectBranchLogRecord),
+	next_cursor: z.string().register(z.globalRegistry, { description: "Pagination cursor to pass as `cursor` on the next request. Empty\nwhen the response is not truncated.\n" }).optional(),
+	is_truncated: z.boolean().register(z.globalRegistry, { description: "True when more records matched than were returned." })
+});
+const zProjectBranchLogFieldsResponse = z.strictObject({ fields: z.array(z.string()).register(z.globalRegistry, { description: "Log field names observed on this branch, each usable as `field_name`\non the log field-values endpoint. Computed per branch rather than\nfixed by this specification, so clients should not assume a\nparticular set.\n" }) });
+const zProjectBranchLogFieldValuesResponse = z.strictObject({
+	values: z.array(z.string()),
+	is_truncated: z.boolean().register(z.globalRegistry, { description: "True when more distinct values exist than were returned, because\neither the requested `limit` or the server's own scan cap was\nreached. A caller that filters on a partial list is choosing from an\narbitrary subset, so narrow `since` or `source` and ask again when\nthis is `true`.\n" })
+});
+const zBranchAiGateway = z.strictObject({
+	enabled: z.boolean().register(z.globalRegistry, { description: "Always `true` in 200 responses. Present for forward compatibility,\nmirroring BranchStorage.enabled.\n" }),
+	base_url: z.url().register(z.globalRegistry, { description: "The AI-gateway endpoint root for this branch — an OpenAI-compatible\nbase URL. No dialect path is included; clients append the route\n(e.g. `/ai-gateway/openai/v1/responses`) themselves.\n" })
+});
+const zBranchAiGatewayNotEnabled = z.strictObject({
+	code: z.string(),
+	message: z.string(),
+	reason: z.enum(["ai_gateway_unavailable", "branch_not_found"]).register(z.globalRegistry, { description: "Machine-readable reason why the AI gateway is unavailable:\n- `ai_gateway_unavailable`: the project's region/cell has no AI gateway configured.\n- `branch_not_found`: the project or branch does not exist, or the caller does not\n  have access to it.\n" })
+});
+const zBucketObject = z.strictObject({
+	key: z.string().register(z.globalRegistry, { description: "The full object key." }),
+	size: z.int().register(z.globalRegistry, { description: "The object size in bytes." }),
+	last_modified: z.iso.datetime().register(z.globalRegistry, { description: "The time the object was last modified." }),
+	etag: z.string().register(z.globalRegistry, { description: "The object's entity tag (content hash)." })
+});
+const zBucketObjectsListResponse = z.strictObject({
+	folders: z.array(z.string()).register(z.globalRegistry, { description: "Common prefixes (folder names) collapsed under the requested\n`delimiter`. Empty when no `delimiter` was supplied.\n" }),
+	objects: z.array(zBucketObject).register(z.globalRegistry, { description: "Objects whose keys did not collapse into a folder." }),
+	prefix: z.string().register(z.globalRegistry, { description: "The prefix that was applied to this listing (echoed back)." }),
+	next_cursor: z.string().register(z.globalRegistry, { description: "Pagination cursor to pass as `cursor` on the next request. Empty\nwhen the listing is not truncated.\n" }).optional(),
+	is_truncated: z.boolean().register(z.globalRegistry, { description: "True when more results exist beyond this page." })
+});
+const zBucketObjectsDeletePrefixResponse = z.strictObject({ deleted: z.int().register(z.globalRegistry, { description: "The number of objects soft-deleted under the prefix. 0 when no live\nobject matched the prefix on this branch.\n" }) });
+/**
+* Options for the presigned URL. The `operation` selects upload (`PUT`)
+* or download (`GET`); the remaining fields are optional.
+*
+*/
+const zPresignRequest = z.strictObject({
+	operation: z.enum(["upload", "download"]).register(z.globalRegistry, { description: "The transfer direction. `upload` returns a presigned `PUT` URL;\n`download` returns a presigned `GET` URL.\n" }),
+	content_type: z.string().register(z.globalRegistry, { description: "The `Content-Type` to bind into the signed request. Only meaningful\nfor `upload`: when set, the caller MUST send the same `Content-Type`\nheader on the `PUT`, and the value is echoed back in the response\n`headers`. Ignored for `download`.\n" }).optional(),
+	expires_in_seconds: z.int().gte(1).lte(604800).register(z.globalRegistry, { description: "How long the presigned URL stays valid, in seconds. Defaults to 900\n(15 minutes); capped at 604800 (7 days).\n" }).optional()
+}).register(z.globalRegistry, { description: "Options for the presigned URL. The `operation` selects upload (`PUT`)\nor download (`GET`); the remaining fields are optional.\n" });
+const zPresignResponse = z.strictObject({
+	url: z.string().register(z.globalRegistry, { description: "The presigned URL. Transfer the object bytes by issuing\n`method url` with the returned `headers`.\n" }),
+	method: z.string().register(z.globalRegistry, { description: "The HTTP method to use against `url`: `PUT` for an upload,\n`GET` for a download.\n" }),
+	headers: z.record(z.string(), z.string()).register(z.globalRegistry, { description: "Headers the caller MUST send verbatim on the request (e.g.\n`Content-Type` when it was signed on an upload). May be empty.\n" }),
+	expires_at: z.iso.datetime().register(z.globalRegistry, { description: "When the presigned URL stops being valid." })
+});
+/**
+* A single capability a credential may exercise. A credential is granted
+* a set of these; it may only perform actions explicitly listed in its
+* scopes.
+*
+*/
+const zCredentialScope = z.enum([
+	"storage:read",
+	"storage:write",
+	"ai_gateway:invoke",
+	"functions:invoke"
+]).register(z.globalRegistry, { description: "A single capability a credential may exercise. A credential is granted\na set of these; it may only perform actions explicitly listed in its\nscopes.\n" });
+const zCreateCredentialRequest = z.strictObject({
+	name: z.string().max(256).register(z.globalRegistry, { description: "Free-form customer label for the credential." }).optional(),
+	scopes: z.array(zCredentialScope).min(1).max(16),
+	principal_type: z.enum(["user"]).register(z.globalRegistry, { description: "Principal type for the credential. Only `user` is customer-managed\nand accepted here. `function` and `system` credentials are\nplatform-internal (e.g. function-serve auto-mint, presign signer)\nand are never issued through the customer-facing API.\n" })
+});
+const zCreateCredentialResponse = z.strictObject({
+	token_id: z.string().register(z.globalRegistry, { description: "Opaque credential id (e.g. nak_live_<32hex>)." }),
+	token_id_short: z.string().register(z.globalRegistry, { description: "First 12 hex chars of token_id; safe to log." }),
+	name: z.string().register(z.globalRegistry, { description: "Customer-supplied label, echoed back from the request. Absent when not provided." }).optional(),
+	api_token: z.string().register(z.globalRegistry, { description: "Bearer token; returned exactly once." }),
+	s3_secret_access_key: z.string().register(z.globalRegistry, { description: "nsk_live_<64 hex>; the AWS_SECRET_ACCESS_KEY, returned exactly once." }),
+	scopes: z.array(zCredentialScope),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/),
+	created_at: z.iso.datetime(),
+	expires_at: z.iso.datetime().register(z.globalRegistry, { description: "When the credential expires; absent means never expires.\n" }).optional()
+});
+const zCredentialMeta = z.strictObject({
+	token_id: z.string().register(z.globalRegistry, { description: "Opaque credential id (e.g. nak_live_<32hex>)." }),
+	token_id_short: z.string(),
+	name: z.string().register(z.globalRegistry, { description: "Customer-supplied label; absent when not provided at issuance." }).optional(),
+	scopes: z.array(zCredentialScope),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).optional(),
+	principal_type: z.string(),
+	function_id: z.string().optional(),
+	created_at: z.iso.datetime(),
+	last_used_at: z.iso.datetime().optional(),
+	revoked_at: z.iso.datetime().optional(),
+	expires_at: z.iso.datetime().register(z.globalRegistry, { description: "When the credential expires; absent means never expires. The\nverifier refuses to authenticate after `expires_at <= now()`.\n" }).optional()
+});
+const zListCredentialsResponse = z.strictObject({ credentials: z.array(zCredentialMeta) });
+const zNeonFunctionDeployment = z.strictObject({
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).register(z.globalRegistry, { description: "The deployment id, which is the platform version number (monotonic per function)." }),
+	status: z.enum([
+		"pending",
+		"building",
+		"completed",
+		"failed"
+	]).register(z.globalRegistry, { description: "Build lifecycle status of the deployment." }),
+	memory_mib: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	runtime: z.string(),
+	created_at: z.string(),
+	environment: z.array(z.string()).register(z.globalRegistry, { description: "The NAMES of the deployment's environment variables, sorted.\nValues are encrypted at rest and are never returned — they are\nwrite-only. To change a value, deploy the variable with the new\nvalue; to remove a variable, deploy it with an empty value.\n" }).optional(),
+	error: z.string().register(z.globalRegistry, { description: "Human-readable reason the deployment build failed. Present only\nwhen `status` is `failed`.\n" }).optional()
+});
+const zNeonFunction = z.strictObject({
+	id: z.string().register(z.globalRegistry, { description: "Opaque, stable function identifier." }),
+	slug: z.string().register(z.globalRegistry, { description: "Branch-unique, lowercase DNS-label. Forms the invocation URL's host together with the branch id. Immutable." }),
+	name: z.string().register(z.globalRegistry, { description: "Free-form display name." }),
+	invocation_url: z.string().register(z.globalRegistry, { description: "URL at which the function is invoked. The host carries `<branch_id>-<slug>` as its first DNS label under a Neon-managed functions domain, and the URL ends with a trailing slash so paths concatenate onto it. Empty string when the function has no servable invoke host (e.g. a deployment without an invocation front-door)." }),
+	current_deployment: zNeonFunctionDeployment.optional(),
+	active_deployment: zNeonFunctionDeployment.optional(),
+	created_at: z.string()
+});
+const zNeonFunctionResponse = z.strictObject({ function: zNeonFunction });
+const zNeonFunctionsListResponse = z.strictObject({ functions: z.array(zNeonFunction) });
+const zNeonFunctionUpdateRequest = z.strictObject({ name: z.string().min(1).max(256).nullable() });
+const zNeonFunctionDeploymentResponse = z.strictObject({ deployment: zNeonFunctionDeployment });
+const zFunctionDeployRequest = z.strictObject({
+	zip: z.string().register(z.globalRegistry, { description: "Optional ZIP archive of the function source code. Omit to reuse the\nlatest version's bundle (a config-only change). Required for the\nfirst deployment of a function.\n" }).optional(),
+	runtime: z.enum(["nodejs24"]).optional(),
+	environment: z.string().register(z.globalRegistry, { description: "Optional JSON object (a string-to-string map) of environment\nvariables for the deployment, e.g. {\"KEY\":\"VALUE\"}. Carried as a\nJSON-encoded string because multipart form data does not support\ntyped object parts.\n\nValues are write-only: they are encrypted at rest, and responses\ncarry only the variable names (the `environment` array), never the\nvalues.\n" }).optional()
+});
+/**
+* A cursor to use in pagination. A cursor defines your place in the data list. Include `response.pagination.next` in subsequent API calls to fetch next page of the list.
+*/
+const zCursorParam = z.string().register(z.globalRegistry, { description: "A cursor to use in pagination. A cursor defines your place in the data list. Include `response.pagination.next` in subsequent API calls to fetch next page of the list." });
+/**
+* The maximum number of records to be returned in the response
+*/
+const zLimitParam = z.int().gte(1).lte(1e4).register(z.globalRegistry, { description: "The maximum number of records to be returned in the response" });
+/**
+* Defines the sorting order of entities.
+*/
+const zSortOrderParam = z.enum(["asc", "desc"]).register(z.globalRegistry, { description: "Defines the sorting order of entities." });
+/**
+* Specify an explicit timeout in milliseconds to limit response delay.
+* After timing out, the incomplete list of project data fetched so far will be returned.
+* Projects still being fetched when the timeout occurred are listed in the "unavailable" attribute of the response.
+* If not specified, an implicit implementation defined timeout is chosen with the same behaviour as above
+*
+*/
+const zTimeoutParam = z.int().gte(100).lte(3e4).register(z.globalRegistry, { description: "Specify an explicit timeout in milliseconds to limit response delay.\nAfter timing out, the incomplete list of project data fetched so far will be returned.\nProjects still being fetched when the timeout occurred are listed in the \"unavailable\" attribute of the response.\nIf not specified, an implicit implementation defined timeout is chosen with the same behaviour as above\n" });
+const zGetProjectAdvisorSecurityIssuesPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "Neon project ID" }) });
+const zGetProjectAdvisorSecurityIssuesQuery = z.strictObject({
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "Branch ID to analyze. If not specified, the project's default branch is used." }).optional(),
+	database_name: z.string().register(z.globalRegistry, { description: "Database name to analyze. Required if branch has multiple databases." }).optional(),
+	category: zAdvisorCategory.optional(),
+	min_severity: z.enum([
+		"INFO",
+		"WARN",
+		"ERROR"
+	]).register(z.globalRegistry, { description: "Minimum severity level to include. For example, WARN returns WARN and ERROR issues, excluding INFO." }).optional()
+});
+const zCreateApiKeyBody = zApiKeyCreateRequest;
+const zRevokeApiKeyPath = z.strictObject({ key_id: z.int().register(z.globalRegistry, { description: "The API key ID" }) });
+const zGetProjectOperationPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	operation_id: z.uuid().register(z.globalRegistry, { description: "The operation ID" })
+});
+const zListProjectsQuery = z.strictObject({
+	cursor: z.string().register(z.globalRegistry, { description: "Specify the cursor value from the previous response to retrieve the next batch of projects." }).optional(),
+	limit: z.int().gte(1).lte(400).register(z.globalRegistry, { description: "Specify a value from 1 to 400 to limit number of projects in the response." }).optional(),
+	search: z.string().register(z.globalRegistry, { description: "Search by project `name` or `id`. You can specify partial `name` or `id` values to filter results." }).optional(),
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "Search for projects by `org_id`." }).optional(),
+	timeout: z.int().gte(100).lte(3e4).register(z.globalRegistry, { description: "Specify an explicit timeout in milliseconds to limit response delay.\nAfter timing out, the incomplete list of project data fetched so far will be returned.\nProjects still being fetched when the timeout occurred are listed in the \"unavailable\" attribute of the response.\nIf not specified, an implicit implementation defined timeout is chosen with the same behaviour as above\n" }).optional(),
+	recoverable: z.boolean().register(z.globalRegistry, { description: "Show only deleted projects within the recovery window.\n" }).optional()
+});
+const zCreateProjectBody = zProjectCreateRequest;
+const zListSharedProjectsQuery = z.strictObject({
+	cursor: z.string().register(z.globalRegistry, { description: "Specify the cursor value from the previous response to get the next batch of projects." }).optional(),
+	limit: z.int().gte(1).lte(400).register(z.globalRegistry, { description: "Specify a value from 1 to 400 to limit number of projects in the response." }).optional(),
+	search: z.string().register(z.globalRegistry, { description: "Search query by name or id." }).optional(),
+	timeout: z.int().gte(100).lte(3e4).register(z.globalRegistry, { description: "Specify an explicit timeout in milliseconds to limit response delay.\nAfter timing out, the incomplete list of project data fetched so far will be returned.\nProjects still being fetched when the timeout occurred are listed in the \"unavailable\" attribute of the response.\nIf not specified, an implicit implementation defined timeout is chosen with the same behaviour as above\n" }).optional()
+});
+const zDeleteProjectPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zGetProjectPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zUpdateProjectBody = zProjectUpdateRequest;
+const zUpdateProjectPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zRecoverProjectPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zListProjectOperationsPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zListProjectOperationsQuery = z.strictObject({
+	cursor: z.string().register(z.globalRegistry, { description: "Specify the cursor value from the previous response to get the next batch of operations" }).optional(),
+	limit: z.int().gte(1).lte(1e3).register(z.globalRegistry, { description: "Specify a value from 1 to 1000 to limit number of operations in the response" }).optional()
+});
+const zListProjectPermissionsPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/) });
+const zGrantPermissionToProjectBody = zGrantPermissionToProjectRequest;
+const zGrantPermissionToProjectPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/) });
+const zListProjectMembersPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/) });
+const zListProjectMembersQuery = z.strictObject({
+	cursor: z.string().register(z.globalRegistry, { description: "A cursor to use in pagination. A cursor defines your place in the data list. Include `response.pagination.next` in subsequent API calls to fetch next page of the list." }).optional(),
+	limit: z.int().gte(1).lte(500).register(z.globalRegistry, { description: "The maximum number of members to return in the response" }).optional()
+});
+const zRemoveProjectMemberRolePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/),
+	member_id: z.uuid()
+});
+const zRemoveProjectMemberRoleQuery = z.strictObject({ confirm_self_lockout: z.boolean().optional() });
+const zSetProjectMemberRoleBody = zSetProjectMemberRoleRequest;
+const zSetProjectMemberRolePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/),
+	member_id: z.uuid()
+});
+const zSetProjectMemberRoleQuery = z.strictObject({ confirm_self_demotion: z.boolean().optional() });
+const zRevokePermissionFromProjectPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/),
+	permission_id: z.string()
+});
+const zGetAvailablePreloadLibrariesPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/) });
+const zCreateProjectTransferRequestBody = z.strictObject({ ttl_seconds: z.int().register(z.globalRegistry, { description: "Number of seconds the transfer request stays valid before it expires. Defaults to 86400 (24 hours).\n" }).optional() });
+const zCreateProjectTransferRequestPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zAcceptProjectTransferRequestBody = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID to transfer the project to. If not provided, the project will be\ntransferred to the current user or organization account.\n" }).optional() });
+const zAcceptProjectTransferRequestPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	request_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project transfer request ID" })
+});
+const zGetProjectJwksPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zAddProjectJwksBody = zAddProjectJwksRequest;
+const zAddProjectJwksPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zDeleteProjectJwksPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	jwks_id: z.string().register(z.globalRegistry, { description: "The JWKS ID" })
+});
+const zDeleteProjectBranchDataApiPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	database_name: z.string().register(z.globalRegistry, { description: "The database name" })
+});
+const zGetProjectBranchDataApiPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	database_name: z.string().register(z.globalRegistry, { description: "The database name" })
+});
+const zUpdateProjectBranchDataApiBody = zDataApiUpdateRequest;
+const zUpdateProjectBranchDataApiPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	database_name: z.string().register(z.globalRegistry, { description: "The database name" })
+});
+const zCreateProjectBranchDataApiBody = zDataApiCreateRequest;
+const zCreateProjectBranchDataApiPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	database_name: z.string().register(z.globalRegistry, { description: "The database name" })
+});
+const zCreateNeonAuthIntegrationBody = zNeonAuthCreateIntegrationRequest;
+const zDisableNeonAuthBody = z.strictObject({ delete_data: z.boolean().register(z.globalRegistry, { description: "If true, deletes the `neon_auth` schema from the database" }).optional() });
+const zDisableNeonAuthPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zGetNeonAuthPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zCreateNeonAuthBody = zEnableNeonAuthIntegrationRequest;
+const zCreateNeonAuthPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zDeleteNeonAuthDomainFromRedirectUriWhitelistBody = zNeonAuthDeleteDomainFromRedirectUriWhitelistRequest;
+const zDeleteNeonAuthDomainFromRedirectUriWhitelistPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zListNeonAuthRedirectUriWhitelistDomainsPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zAddNeonAuthDomainToRedirectUriWhitelistBody = zNeonAuthAddDomainToRedirectUriWhitelistRequest;
+const zAddNeonAuthDomainToRedirectUriWhitelistPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zDeleteBranchNeonAuthTrustedDomainBody = zNeonAuthDeleteDomainFromRedirectUriWhitelistRequest;
+const zDeleteBranchNeonAuthTrustedDomainPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zListBranchNeonAuthTrustedDomainsPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zAddBranchNeonAuthTrustedDomainBody = zNeonAuthAddDomainToRedirectUriWhitelistRequest;
+const zAddBranchNeonAuthTrustedDomainPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zCreateNeonAuthProviderSdkKeysBody = zNeonAuthCreateAuthProviderSdkKeysRequest;
+const zCreateNeonAuthNewUserBody = zNeonAuthCreateNewUserRequest;
+const zCreateBranchNeonAuthNewUserBody = zCreateBranchNeonAuthNewUserRequest;
+const zCreateBranchNeonAuthNewUserPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zDeleteBranchNeonAuthUserPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	auth_user_id: z.string().register(z.globalRegistry, { description: "The Neon user ID" })
+});
+const zUpdateNeonAuthUserRoleBody = zUpdateNeonAuthUserRoleRequest;
+const zUpdateNeonAuthUserRolePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	auth_user_id: z.string().register(z.globalRegistry, { description: "The Neon user ID" })
+});
+const zDeleteNeonAuthUserPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	auth_user_id: z.string().register(z.globalRegistry, { description: "The Neon user ID" })
+});
+const zTransferNeonAuthProviderProjectBody = zNeonAuthTransferAuthProviderProjectRequest;
+const zListNeonAuthIntegrationsPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zListNeonAuthOauthProvidersPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zAddNeonAuthOauthProviderBody = zNeonAuthAddOAuthProviderRequest;
+const zAddNeonAuthOauthProviderPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zListBranchNeonAuthOauthProvidersPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zAddBranchNeonAuthOauthProviderBody = zNeonAuthAddOAuthProviderRequest;
+const zAddBranchNeonAuthOauthProviderPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zDeleteNeonAuthOauthProviderPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	oauth_provider_id: zNeonAuthOauthProviderId
+});
+const zUpdateNeonAuthOauthProviderBody = zNeonAuthUpdateOAuthProviderRequest;
+const zUpdateNeonAuthOauthProviderPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	oauth_provider_id: zNeonAuthOauthProviderId
+});
+const zDeleteBranchNeonAuthOauthProviderPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	oauth_provider_id: zNeonAuthOauthProviderId
+});
+const zUpdateBranchNeonAuthOauthProviderBody = zNeonAuthUpdateOAuthProviderRequest;
+const zUpdateBranchNeonAuthOauthProviderPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	oauth_provider_id: zNeonAuthOauthProviderId
+});
+const zGetNeonAuthEmailServerPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zUpdateNeonAuthEmailServerBody = zNeonAuthEmailServerConfig;
+const zUpdateNeonAuthEmailServerPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zSendNeonAuthTestEmailBody = zSendNeonAuthTestEmailRequest;
+const zSendNeonAuthTestEmailPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zGetNeonAuthEmailAndPasswordConfigPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zUpdateNeonAuthEmailAndPasswordConfigBody = zNeonAuthEmailAndPasswordConfigUpdate;
+const zUpdateNeonAuthEmailAndPasswordConfigPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zGetNeonAuthEmailProviderPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zUpdateNeonAuthEmailProviderBody = zNeonAuthEmailServerConfig;
+const zUpdateNeonAuthEmailProviderPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zDeleteNeonAuthIntegrationBody = z.strictObject({ delete_data: z.boolean().register(z.globalRegistry, { description: "If true, deletes the `neon_auth` schema from the database" }).optional() });
+const zDeleteNeonAuthIntegrationPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	auth_provider: zNeonAuthSupportedAuthProvider
+});
+const zGetConnectionUriPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zGetConnectionUriQuery = z.strictObject({
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID. Defaults to your project's default `branch_id` if not specified." }).optional(),
+	endpoint_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The endpoint ID. Defaults to the read-write `endpoint_id` associated with the `branch_id` if not specified." }).optional(),
+	database_name: z.string().register(z.globalRegistry, { description: "The database name" }),
+	role_name: z.string().register(z.globalRegistry, { description: "The role name" }),
+	pooled: z.boolean().register(z.globalRegistry, { description: "Adds the `-pooler` option to the connection URI when set to `true`, creating a pooled connection URI." }).optional()
+});
+const zGetNeonAuthAllowLocalhostPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zUpdateNeonAuthAllowLocalhostBody = zUpdateNeonAuthAllowLocalhostRequest;
+const zUpdateNeonAuthAllowLocalhostPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zGetNeonAuthPluginConfigsPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zUpdateNeonAuthOrganizationPluginBody = zNeonAuthOrganizationConfigUpdate;
+const zUpdateNeonAuthOrganizationPluginPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zUpdateNeonAuthConfigBody = zNeonAuthConfigUpdate;
+const zUpdateNeonAuthConfigPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zUpdateNeonAuthMagicLinkPluginBody = zNeonAuthMagicLinkConfigUpdate;
+const zUpdateNeonAuthMagicLinkPluginPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zGetNeonAuthPhoneNumberPluginPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zUpdateNeonAuthPhoneNumberPluginBody = zNeonAuthPhoneNumberConfigUpdate;
+const zUpdateNeonAuthPhoneNumberPluginPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zGetNeonAuthWebhookConfigPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zUpdateNeonAuthWebhookConfigBody = zNeonAuthWebhookConfig;
+const zUpdateNeonAuthWebhookConfigPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zListProjectBranchesPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zListProjectBranchesQuery = z.strictObject({
+	search: z.string().register(z.globalRegistry, { description: "Search by branch `name` or `id`. You can specify partial `name` or `id` values to filter results." }).optional(),
+	sort_by: z.enum([
+		"name",
+		"created_at",
+		"updated_at"
+	]).register(z.globalRegistry, { description: "Sort the branches by sort_field. If not provided, branches will be sorted by updated_at descending order" }).optional(),
+	cursor: z.string().register(z.globalRegistry, { description: "A cursor to use in pagination. A cursor defines your place in the data list. Include `response.pagination.next` in subsequent API calls to fetch next page of the list." }).optional(),
+	sort_order: z.enum(["asc", "desc"]).register(z.globalRegistry, { description: "Defines the sorting order of entities." }).optional(),
+	limit: z.int().gte(1).lte(1e4).register(z.globalRegistry, { description: "The maximum number of records to be returned in the response" }).optional(),
+	include_deleted: z.boolean().register(z.globalRegistry, { description: "If true, return recoverable deleted branches too (soft-deleted within the recovery window).\nIf false or not provided, return only active (non-deleted) branches.\n\nThis parameter is part of the Branch Recovery feature, which is in preview and not available to all users.\n" }).optional()
+});
+const zCreateProjectBranchBody = zBranchCreateRequest.merge(zAnnotationCreateValueRequest);
+const zCreateProjectBranchPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zCreateProjectBranchAnonymizedBody = zBranchAnonymizedCreateRequest;
+const zCreateProjectBranchAnonymizedPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zCountProjectBranchesPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zCountProjectBranchesQuery = z.strictObject({ search: z.string().register(z.globalRegistry, { description: "Count branches matching the `name` in search query" }).optional() });
+const zDeleteProjectBranchPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zDeleteProjectBranchQuery = z.strictObject({ hard_delete: z.boolean().register(z.globalRegistry, { description: "If true, the branch is permanently deleted immediately without a recovery window.\nIf false (default), the branch can be recovered within 7 days via the recover endpoint.\n\nThis parameter is part of the Branch Recovery feature, which is in preview and not available to all users.\n" }).optional() });
+const zGetProjectBranchPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zUpdateProjectBranchBody = zBranchUpdateRequest;
+const zUpdateProjectBranchPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zRestoreProjectBranchBody = zBranchRestoreRequest;
+const zRestoreProjectBranchPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zGetProjectBranchSchemaPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zGetProjectBranchSchemaQuery = z.strictObject({
+	db_name: z.string().register(z.globalRegistry, { description: "Name of the database for which the schema is retrieved" }),
+	lsn: z.string().register(z.globalRegistry, { description: "The Log Sequence Number (LSN) for which the schema is retrieved\n" }).optional(),
+	timestamp: z.iso.datetime().register(z.globalRegistry, { description: "The point in time for which the schema is retrieved\n" }).optional(),
+	format: z.string().register(z.globalRegistry, { description: "The format of the schema to retrieve. Possible values:\n- `sql` (default)\n- `json`\n" }).optional()
+});
+const zGetProjectBranchSchemaComparisonPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zGetProjectBranchSchemaComparisonQuery = z.strictObject({
+	base_branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID to compare the schema with" }).optional(),
+	db_name: z.string().register(z.globalRegistry, { description: "Name of the database for which the schema is retrieved" }),
+	lsn: z.string().register(z.globalRegistry, { description: "The Log Sequence Number (LSN) for which the schema is retrieved\n" }).optional(),
+	timestamp: z.iso.datetime().register(z.globalRegistry, { description: "The point in time for which the schema is retrieved\n" }).optional(),
+	base_lsn: z.string().register(z.globalRegistry, { description: "The Log Sequence Number (LSN) for the base branch schema\n" }).optional(),
+	base_timestamp: z.iso.datetime().register(z.globalRegistry, { description: "The point in time for the base branch schema\n" }).optional()
+});
+const zGetMaskingRulesPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zUpdateMaskingRulesBody = zMaskingRulesUpdateRequest;
+const zUpdateMaskingRulesPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zGetAnonymizedBranchStatusPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zStartAnonymizationPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zSetDefaultProjectBranchPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zFinalizeRestoreBranchBody = z.strictObject({ name: z.string().register(z.globalRegistry, { description: "Name for the replaced branch. If omitted, a unique name is generated." }).optional() });
+const zFinalizeRestoreBranchPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zListProjectBranchEndpointsPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zListProjectBranchDatabasesPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zCreateProjectBranchDatabaseBody = zDatabaseCreateRequest;
+const zCreateProjectBranchDatabasePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zDeleteProjectBranchDatabasePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" }),
+	database_name: z.string().register(z.globalRegistry, { description: "The database name" })
+});
+const zGetProjectBranchDatabasePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" }),
+	database_name: z.string().register(z.globalRegistry, { description: "The database name" })
+});
+const zUpdateProjectBranchDatabaseBody = zDatabaseUpdateRequest;
+const zUpdateProjectBranchDatabasePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" }),
+	database_name: z.string().register(z.globalRegistry, { description: "The database name" })
+});
+const zListProjectBranchRolesPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zCreateProjectBranchRoleBody = zRoleCreateRequest;
+const zCreateProjectBranchRolePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zDeleteProjectBranchRolePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" }),
+	role_name: z.string().register(z.globalRegistry, { description: "The role name" })
+});
+const zGetProjectBranchRolePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" }),
+	role_name: z.string().register(z.globalRegistry, { description: "The role name" })
+});
+const zGetProjectBranchRolePasswordPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" }),
+	role_name: z.string().register(z.globalRegistry, { description: "The role name" })
+});
+const zResetProjectBranchRolePasswordPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" }),
+	role_name: z.string().register(z.globalRegistry, { description: "The role name" })
+});
+const zListProjectVpcEndpointsPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zDeleteProjectVpcEndpointPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	vpc_endpoint_id: z.string().register(z.globalRegistry, { description: "The VPC endpoint ID" })
+});
+const zAssignProjectVpcEndpointBody = zVpcEndpointAssignment;
+const zAssignProjectVpcEndpointPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	vpc_endpoint_id: z.string().register(z.globalRegistry, { description: "The VPC endpoint ID" })
+});
+const zListProjectEndpointsPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zCreateProjectEndpointBody = zEndpointCreateRequest;
+const zCreateProjectEndpointPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zDeleteProjectEndpointPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	endpoint_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The endpoint ID" })
+});
+const zGetProjectEndpointPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	endpoint_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The endpoint ID" })
+});
+const zUpdateProjectEndpointBody = zEndpointUpdateRequest;
+const zUpdateProjectEndpointPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	endpoint_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The endpoint ID" })
+});
+const zStartProjectEndpointPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	endpoint_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The endpoint ID" })
+});
+const zSuspendProjectEndpointPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	endpoint_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The endpoint ID" })
+});
+const zRestartProjectEndpointPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	endpoint_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The endpoint ID" })
+});
+const zGetConsumptionHistoryPerProjectQuery = z.strictObject({
+	cursor: z.string().register(z.globalRegistry, { description: "Specify the cursor value from the previous response to get the next batch of projects." }).optional(),
+	limit: z.int().gte(1).lte(100).register(z.globalRegistry, { description: "Specify a value from 1 to 100 to limit number of projects in the response." }).optional(),
+	project_ids: z.array(z.string().regex(/^([a-z0-9-]{1,60}(,[a-z0-9-]{1,60}){0,99})?$/)).min(0).max(100).register(z.globalRegistry, { description: "Specify a list of project IDs to filter the response.\nIf omitted, the response will contain all projects.\nA list of project IDs can be specified as an array of parameter values or as a comma-separated list in a single parameter value.\n- As an array of parameter values: `project_ids=cold-poetry-09157238%20&project_ids=quiet-snow-71788278`\n- As a comma-separated list in a single parameter value: `project_ids=cold-poetry-09157238,quiet-snow-71788278`\n" }).optional(),
+	from: z.iso.datetime().register(z.globalRegistry, { description: "Specify the start `date-time` for the consumption period.\nThe `date-time` value is rounded according to the specified `granularity`.\nFor example, `2024-03-15T15:30:00Z` for `daily` granularity will be rounded to `2024-03-15T00:00:00Z`.\nThe specified `date-time` value must respect the specified `granularity`:\n- For `hourly`, consumption metrics are limited to the last 168 hours.\n- For `daily`, consumption metrics are limited to the last 60 days.\n- For `monthly`, consumption metrics are limited to the last year.\n\nThe consumption history is available starting from `March 1, 2024, at 00:00:00 UTC`.\n" }),
+	to: z.iso.datetime().register(z.globalRegistry, { description: "Specify the end `date-time` for the consumption period.\nThe `date-time` value is rounded according to the specified granularity.\nFor example, `2024-03-15T15:30:00Z` for `daily` granularity will be rounded to `2024-03-15T00:00:00Z`.\nThe specified `date-time` value must respect the specified `granularity`:\n- For `hourly`, consumption metrics are limited to the last 168 hours.\n- For `daily`, consumption metrics are limited to the last 60 days.\n- For `monthly`, consumption metrics are limited to the last year.\n" }),
+	granularity: zConsumptionHistoryGranularity,
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "Specify the organization for which the project consumption metrics should be returned.\nIf this parameter is not provided, the endpoint will return the metrics for the\nauthenticated user's projects.\n" }).optional(),
+	include_v1_metrics: z.boolean().register(z.globalRegistry, { description: "The field is deprecated. Please use `metrics` instead.\nIf `metrics` is specified, this field is ignored.\nInclude metrics utilized in previous pricing models.\n- **data_storage_bytes_hour**: The sum of the maximum observed storage values for each hour,\n  which never decreases.\n" }).optional(),
+	metrics: zConsumptionHistoryQueryMetrics.optional()
+});
+const zGetConsumptionHistoryPerProjectV2Query = z.strictObject({
+	cursor: z.string().register(z.globalRegistry, { description: "Cursor from the previous response (`pagination.cursor`). Pass it to fetch the next page\nof projects. Pages are ordered by project creation order (newest first).\n" }).optional(),
+	limit: z.int().gte(1).lte(100).register(z.globalRegistry, { description: "Maximum number of projects per page. Allowed range: 1 to 100. Default: 10.\n" }).optional(),
+	project_ids: z.array(z.string().regex(/^([a-z0-9-]{1,60}(,[a-z0-9-]{1,60}){0,99})?$/)).min(0).max(100).register(z.globalRegistry, { description: "Optional project IDs to filter the response (up to 100). If omitted, projects in the\norganization are included across pages (use `cursor` and `limit`).\n\nPass multiple IDs as repeated query parameters or a comma-separated list:\n- `project_ids=cold-poetry-09157238&project_ids=quiet-snow-71788278`\n- `project_ids=cold-poetry-09157238,quiet-snow-71788278`\n" }).optional(),
+	from: z.iso.datetime().register(z.globalRegistry, { description: "Specify the start `date-time` for the consumption period.\nThe `date-time` value is rounded according to the specified `granularity`.\nFor example, `2024-03-15T15:30:00Z` for `daily` granularity will be rounded to `2024-03-15T00:00:00Z`.\nThe specified `date-time` value must respect the specified `granularity`:\n- For `hourly`, consumption metrics are limited to the last 168 hours.\n- For `daily`, consumption metrics are limited to the last 60 days.\n- For `monthly`, consumption metrics are limited to the last year.\n\nThe earliest allowed `from` value is `March 1, 2024, at 00:00:00 UTC`.\nMetrics are returned from when the account upgraded to an eligible plan, which may be\nlater than that date.\n" }),
+	to: z.iso.datetime().register(z.globalRegistry, { description: "Specify the end `date-time` for the consumption period.\nThe `date-time` value is rounded according to the specified `granularity`.\nFor example, `2024-03-15T15:30:00Z` for `daily` granularity will be rounded to `2024-03-15T00:00:00Z`.\nThe specified `date-time` value must respect the specified `granularity`:\n- For `hourly`, consumption metrics are limited to the last 168 hours.\n- For `daily`, consumption metrics are limited to the last 60 days.\n- For `monthly`, consumption metrics are limited to the last year.\n" }),
+	granularity: zConsumptionHistoryGranularity,
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "Organization ID. Metrics are returned for projects in this organization.\n" }),
+	metrics: zConsumptionHistoryQueryMetrics
+});
+const zGetConsumptionHistoryPerBranchV2Query = z.strictObject({
+	cursor: z.string().register(z.globalRegistry, { description: "Cursor from the previous response (`pagination.cursor`). Pass it to fetch the next page\nof branches. Pages are ordered by project ID, then branch ID.\n" }).optional(),
+	limit: z.int().gte(1).lte(1e3).register(z.globalRegistry, { description: "Maximum number of branches per page. Allowed range: 1 to 1000. Default: 100.\n" }).optional(),
+	project_ids: z.array(z.string().regex(/^([a-z0-9-]{1,60}(,[a-z0-9-]{1,60}){0,99})?$/)).min(1).max(100).register(z.globalRegistry, { description: "Project IDs to include (required, 1 to 100). Returns metrics for branches in these projects.\n\nPass multiple IDs as repeated query parameters or a comma-separated list:\n- `project_ids=cold-poetry-09157238&project_ids=quiet-snow-71788278`\n- `project_ids=cold-poetry-09157238,quiet-snow-71788278`\n" }),
+	branch_ids: z.array(z.string().regex(/^([a-z0-9-]{1,60}(,[a-z0-9-]{1,60}){0,99})?$/)).min(0).max(100).register(z.globalRegistry, { description: "Optional branch IDs to filter the response (up to 100). If omitted, all branches in the\nlisted projects are included.\n\nPass multiple IDs as repeated query parameters or a comma-separated list:\n- `branch_ids=br-aged-salad-637688&branch_ids=br-sweet-breeze-497520`\n- `branch_ids=br-aged-salad-637688,br-sweet-breeze-497520`\n" }).optional(),
+	from: z.iso.datetime().register(z.globalRegistry, { description: "Specify the start `date-time` for the consumption period.\nThe `date-time` value is rounded according to the specified `granularity`.\nFor example, `2024-03-15T15:30:00Z` for `daily` granularity will be rounded to `2024-03-15T00:00:00Z`.\nThe specified `date-time` value must respect the specified `granularity`:\n- For `hourly`, consumption metrics are limited to the last 168 hours.\n- For `daily`, consumption metrics are limited to the last 60 days.\n- For `monthly`, consumption metrics are limited to the last year.\n\nBranch-level metrics are returned from when the account first ingests branch-level\nconsumption data. Periods before that time contain no branch metrics.\n" }),
+	to: z.iso.datetime().register(z.globalRegistry, { description: "Specify the end `date-time` for the consumption period.\nThe `date-time` value is rounded according to the specified `granularity`.\nFor example, `2024-03-15T15:30:00Z` for `daily` granularity will be rounded to `2024-03-15T00:00:00Z`.\nThe specified `date-time` value must respect the specified `granularity`:\n- For `hourly`, consumption metrics are limited to the last 168 hours.\n- For `daily`, consumption metrics are limited to the last 60 days.\n- For `monthly`, consumption metrics are limited to the last year.\n" }),
+	granularity: zConsumptionHistoryGranularity,
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "Organization ID. Metrics are returned for projects in this organization.\n" }),
+	metrics: zConsumptionHistoryQueryMetrics
+});
+const zGetOrganizationPath = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }) });
+const zListOrgApiKeysPath = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }) });
+const zCreateOrgApiKeyBody = zOrgApiKeyCreateRequest;
+const zCreateOrgApiKeyPath = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }) });
+const zRevokeOrgApiKeyPath = z.strictObject({
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }),
+	key_id: z.int().register(z.globalRegistry, { description: "The API key ID" })
+});
+const zDeleteOrganizationSpendingLimitPath = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }) });
+const zGetOrganizationSpendingLimitPath = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }) });
+const zSetOrganizationSpendingLimitBody = zSpendingLimitUpdateRequest;
+const zSetOrganizationSpendingLimitPath = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }) });
+const zGetOrganizationMembersPath = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }) });
+const zGetOrganizationMembersQuery = z.strictObject({
+	sort_by: z.enum([
+		"email",
+		"role",
+		"joined_at"
+	]).register(z.globalRegistry, { description: "Sort the members by the specified field. Defaults to `joined_at`." }).optional(),
+	cursor: z.string().register(z.globalRegistry, { description: "A cursor to use in pagination. A cursor defines your place in the data list. Include `response.pagination.next` in subsequent API calls to fetch next page of the list." }).optional(),
+	sort_order: z.enum(["asc", "desc"]).register(z.globalRegistry, { description: "Defines the sorting order of entities." }).optional(),
+	limit: z.int().gte(1).lte(500).register(z.globalRegistry, { description: "The maximum number of members to return in the response" }).optional()
+});
+const zRemoveOrganizationMemberPath = z.strictObject({
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }),
+	member_id: z.uuid().register(z.globalRegistry, { description: "The Neon organization member ID" })
+});
+const zGetOrganizationMemberPath = z.strictObject({
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }),
+	member_id: z.uuid().register(z.globalRegistry, { description: "The Neon organization member ID" })
+});
+const zUpdateOrganizationMemberBody = zOrganizationMemberUpdateRequest;
+const zUpdateOrganizationMemberPath = z.strictObject({
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }),
+	member_id: z.uuid().register(z.globalRegistry, { description: "The Neon organization member ID" })
+});
+const zGetOrganizationInvitationsPath = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }) });
+const zCreateOrganizationInvitationsBody = zOrganizationInvitesCreateRequest;
+const zCreateOrganizationInvitationsPath = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }) });
+const zTransferProjectsFromOrgToOrgBody = zTransferProjectsToOrganizationRequest;
+const zTransferProjectsFromOrgToOrgPath = z.strictObject({ source_org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID (source org, which currently owns the project)" }) });
+const zListOrganizationVpcEndpointsAllRegionsPath = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }) });
+const zListOrganizationVpcEndpointsPath = z.strictObject({
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }),
+	region_id: z.string().register(z.globalRegistry, { description: "The Neon region ID" })
+});
+const zDeleteOrganizationVpcEndpointPath = z.strictObject({
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }),
+	region_id: z.string().register(z.globalRegistry, { description: "The Neon region ID.\nAzure regions are currently not supported.\n" }),
+	vpc_endpoint_id: z.string().register(z.globalRegistry, { description: "The VPC endpoint ID" })
+});
+const zGetOrganizationVpcEndpointDetailsPath = z.strictObject({
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }),
+	region_id: z.string().register(z.globalRegistry, { description: "The Neon region ID.\nAzure regions are currently not supported.\n" }),
+	vpc_endpoint_id: z.string().register(z.globalRegistry, { description: "The VPC endpoint ID" })
+});
+const zAssignOrganizationVpcEndpointBody = zVpcEndpointAssignment;
+const zAssignOrganizationVpcEndpointPath = z.strictObject({
+	org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon organization ID" }),
+	region_id: z.string().register(z.globalRegistry, { description: "The Neon region ID.\nAzure regions are currently not supported.\n" }),
+	vpc_endpoint_id: z.string().register(z.globalRegistry, { description: "The VPC endpoint ID" })
+});
+const zGetActiveRegionsQuery = z.strictObject({ org_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "Organization ID. When provided, returns only regions available to this organization.\nRecommended for accurate region availability.\n" }).optional() });
+const zTransferProjectsFromUserToOrgBody = zTransferProjectsToOrganizationRequest;
+const zCreateSnapshotPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zCreateSnapshotQuery = z.strictObject({
+	lsn: z.string().register(z.globalRegistry, { description: "The target Log Sequence Number (LSN) to take the snapshot from.\nMust fall within the restore window. Cannot be used with `timestamp`\n" }).optional(),
+	timestamp: z.string().register(z.globalRegistry, { description: "The target timestamp for the snapshot. Must fall within the restore window. RFC 3339 format. Cannot be used with `lsn`.\n" }).optional(),
+	name: z.string().register(z.globalRegistry, { description: "A name for the snapshot." }).optional(),
+	expires_at: z.string().register(z.globalRegistry, { description: "The time at which the snapshot will be automatically deleted. RFC 3339 format.\n" }).optional()
+});
+const zListSnapshotsPath = z.strictObject({ project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }) });
+const zDeleteSnapshotPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	snapshot_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The snapshot ID" })
+});
+const zUpdateSnapshotBody = zSnapshotUpdateRequest;
+const zUpdateSnapshotPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	snapshot_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The snapshot ID" })
+});
+const zRestoreSnapshotBody = z.strictObject({
+	name: z.string().register(z.globalRegistry, { description: "A name for the newly restored branch. If not provided, the server generates a unique name for the branch automatically.\n" }).optional(),
+	target_branch_id: z.string().register(z.globalRegistry, { description: "ID of the branch to restore the snapshot into. Defaults to the snapshot's source branch (`snapshot.source_branch_id`); fails if that cannot be determined.\n" }).optional(),
+	finalize_restore: z.boolean().register(z.globalRegistry, { description: "Set to `true` to finalize the restore operation immediately.\nThis will complete the restore and move any associated computes to the new branch,\nsimilar to the `finalizeRestoreBranch` operation.\nDefaults to `false` to allow previewing the restored snapshot data first.\n" }).optional()
+});
+const zRestoreSnapshotPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	snapshot_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The snapshot ID" })
+});
+const zRestoreSnapshotQuery = z.strictObject({ name: z.string().register(z.globalRegistry, { description: "Deprecated. Use the `name` field in the request body instead. Removal scheduled for November 29, 2025.\nA name for the newly restored branch. If omitted, a default name will be generated.\n" }).optional() });
+const zGetSnapshotSchedulePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zSetSnapshotScheduleBody = zBackupSchedule;
+const zSetSnapshotSchedulePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The branch ID" })
+});
+const zListProjectBranchBucketsPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zCreateProjectBranchBucketBody = zBucketCreateRequest;
+const zCreateProjectBranchBucketPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zDeleteProjectBranchBucketPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	bucket_name: z.string().min(1).max(255).register(z.globalRegistry, { description: "The bucket name" })
+});
+const zGetProjectBranchStoragePath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zGetProjectBranchAiGatewayPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zQueryProjectBranchLogsBody = zProjectBranchLogsQueryRequest;
+const zQueryProjectBranchLogsPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zListProjectBranchLogFieldsPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zListProjectBranchLogFieldValuesPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	field_name: z.string().min(1).register(z.globalRegistry, { description: "The log field whose distinct values should be returned. Must be one of\nthe names returned by the log fields endpoint for this branch.\n" })
+});
+const zListProjectBranchLogFieldValuesQuery = z.strictObject({
+	since: zProjectBranchLogDuration.optional(),
+	start_time: z.iso.datetime().register(z.globalRegistry, { description: "Inclusive beginning of the lookup window. Mutually exclusive with\n`since`.\n" }).optional(),
+	end_time: z.iso.datetime().register(z.globalRegistry, { description: "Exclusive end of the lookup window. Defaults to the current time." }).optional(),
+	source: zProjectBranchLogSource.optional(),
+	limit: z.int().gte(1).lte(1e3).register(z.globalRegistry, { description: "Maximum number of distinct values to return. The response sets\n`is_truncated` when this bound, or the server's own scan cap, cut the\nlist short.\n" }).optional()
+});
+const zListProjectBranchBucketObjectsPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	bucket_name: z.string().min(1).max(255).register(z.globalRegistry, { description: "The bucket name" })
+});
+const zListProjectBranchBucketObjectsQuery = z.strictObject({
+	prefix: z.string().register(z.globalRegistry, { description: "Only list objects whose key starts with this prefix." }).optional(),
+	delimiter: z.string().register(z.globalRegistry, { description: "Collapse keys sharing a common prefix up to the first occurrence of\nthis delimiter (typically `/`) into the `folders` array.\n" }).optional(),
+	cursor: z.string().register(z.globalRegistry, { description: "Opaque pagination cursor returned as `next_cursor` by a previous\ncall. Resume listing after the last item of the previous page.\n" }).optional(),
+	limit: z.int().gte(1).lte(1e3).register(z.globalRegistry, { description: "Maximum number of items (objects + folders) to return." }).optional()
+});
+const zDeleteProjectBranchBucketObjectPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	bucket_name: z.string().min(1).max(255).register(z.globalRegistry, { description: "The bucket name" }),
+	object_key: z.string().min(1).max(1024).register(z.globalRegistry, { description: "The object key. Keys may contain `/`; the `/` characters of nested\nkeys must be percent-encoded (`%2F`) in the path segment.\n" })
+});
+const zGetProjectBranchBucketObjectPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	bucket_name: z.string().min(1).max(255).register(z.globalRegistry, { description: "The bucket name" }),
+	object_key: z.string().min(1).max(1024).register(z.globalRegistry, { description: "The object key. Keys may contain `/`; the `/` characters of nested\nkeys must be percent-encoded (`%2F`) in the path segment.\n" })
+});
+const zDeleteProjectBranchBucketObjectsByPrefixPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	bucket_name: z.string().min(1).max(255).register(z.globalRegistry, { description: "The bucket name" })
+});
+const zDeleteProjectBranchBucketObjectsByPrefixQuery = z.strictObject({ prefix: z.string().min(1).max(1024).register(z.globalRegistry, { description: "The key prefix (folder) to delete. Must be non-empty and end with\n`/`. Every object on this branch whose key starts with this prefix\nis soft-deleted.\n" }) });
+const zPresignProjectBranchBucketObjectBody = zPresignRequest;
+const zPresignProjectBranchBucketObjectPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	bucket_name: z.string().min(1).max(255).register(z.globalRegistry, { description: "The bucket name" }),
+	object_key: z.string().min(1).max(1024).register(z.globalRegistry, { description: "The object key. Keys may contain `/`; the `/` characters of nested\nkeys must be percent-encoded (`%2F`) in the path segment.\n" })
+});
+const zListCredentialsPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zCreateCredentialBody = zCreateCredentialRequest;
+const zCreateCredentialPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zRevokeCredentialPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	token_id: z.string().register(z.globalRegistry, { description: "The opaque credential id (e.g. nak_live_<32hex>)." })
+});
+const zListProjectBranchFunctionsPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" })
+});
+const zListProjectBranchFunctionsQuery = z.strictObject({
+	cursor: z.string().register(z.globalRegistry, { description: "A cursor to use in pagination. A cursor defines your place in the data list. Include `response.pagination.next` in subsequent API calls to fetch next page of the list." }).optional(),
+	limit: z.int().gte(1).lte(1e3).register(z.globalRegistry, { description: "Specify a value from 1 to 1000 to limit number of functions in the response" }).optional()
+});
+const zDeleteProjectBranchFunctionPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	slug: z.string().regex(/^[a-z0-9]{1,20}$/).register(z.globalRegistry, { description: "The function slug" })
+});
+const zGetProjectBranchFunctionPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	slug: z.string().regex(/^[a-z0-9]{1,20}$/).register(z.globalRegistry, { description: "The function slug" })
+});
+const zUpdateProjectBranchFunctionBody = zNeonFunctionUpdateRequest;
+const zUpdateProjectBranchFunctionPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	slug: z.string().regex(/^[a-z0-9]{1,20}$/).register(z.globalRegistry, { description: "The function slug" })
+});
+const zCreateProjectBranchFunctionDeploymentBody = zFunctionDeployRequest;
+const zCreateProjectBranchFunctionDeploymentPath = z.strictObject({
+	project_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon project ID" }),
+	branch_id: z.string().regex(/^[a-z0-9-]{1,60}$/).register(z.globalRegistry, { description: "The Neon branch ID" }),
+	slug: z.string().regex(/^[a-z0-9]{1,20}$/).register(z.globalRegistry, { description: "The function slug" })
+});
+//#endregion
+export { zAcceptProjectTransferRequestBody, zAcceptProjectTransferRequestPath, zAcceptProjectTransferRequestSatisfiesPlanError, zActiveRegionsResponse, zAddBranchNeonAuthOauthProviderBody, zAddBranchNeonAuthOauthProviderPath, zAddBranchNeonAuthTrustedDomainBody, zAddBranchNeonAuthTrustedDomainPath, zAddNeonAuthDomainToRedirectUriWhitelistBody, zAddNeonAuthDomainToRedirectUriWhitelistPath, zAddNeonAuthOauthProviderBody, zAddNeonAuthOauthProviderPath, zAddProjectJwksBody, zAddProjectJwksPath, zAddProjectJwksRequest, zAdvisorCategory, zAdvisorIssue, zAllowedIps, zAnnotationCreateValueRequest, zAnnotationData, zAnnotationObjectData, zAnnotationResponse, zAnnotationValueData, zAnnotationsMapResponse, zAnonymizationRunMetadata, zAnonymizedBranchStatusResponse, zApiKeyCreateRequest, zApiKeyCreateResponse, zApiKeyCreatorData, zApiKeyRevokeResponse, zApiKeysListResponseItem, zApplicationType, zAssignOrganizationVpcEndpointBody, zAssignOrganizationVpcEndpointPath, zAssignProjectVpcEndpointBody, zAssignProjectVpcEndpointPath, zAuthDetailsResponse, zAvailablePreloadLibraries, zAvailablePreloadLibrary, zBackupSchedule, zBackupScheduleItem, zBillingAccount, zBillingAccountState, zBillingPaymentMethod, zBillingSubscriptionType, zBranch, zBranchAiGateway, zBranchAiGatewayNotEnabled, zBranchAnonymizedCreateRequest, zBranchCreateRequest, zBranchCreateRequestEndpointOptions, zBranchOperations, zBranchRecoverResponse, zBranchRecoveryInfo, zBranchResponse, zBranchRestoreRequest, zBranchRestoreStatus, zBranchRestrictedAction, zBranchSchemaCompareResponse, zBranchSchemaJson, zBranchSchemaResponse, zBranchState, zBranchStorage, zBranchStorageNotEnabled, zBranchUpdateRequest, zBranchesCountResponse, zBranchesResponse, zBucket, zBucketAccessLevel, zBucketCreateRequest, zBucketObject, zBucketObjectsDeletePrefixResponse, zBucketObjectsListResponse, zBucketResponse, zBucketsListResponse, zComputeUnit, zConnectionDetails, zConnectionParameters, zConnectionUriResponse, zConnectionUrisOptionalResponse, zConnectionUrisResponse, zConsumptionHistoryGranularity, zConsumptionHistoryPerBranchV2, zConsumptionHistoryPerBranchV2Response, zConsumptionHistoryPerPeriod, zConsumptionHistoryPerPeriodV2, zConsumptionHistoryPerProject, zConsumptionHistoryPerProjectResponse, zConsumptionHistoryPerProjectV2, zConsumptionHistoryPerProjectV2Response, zConsumptionHistoryPerTimeframe, zConsumptionHistoryPerTimeframeV2, zConsumptionHistoryQueryMetrics, zConsumptionMetricValue, zCountProjectBranchesPath, zCountProjectBranchesQuery, zCreateApiKeyBody, zCreateBranchNeonAuthNewUserBody, zCreateBranchNeonAuthNewUserPath, zCreateBranchNeonAuthNewUserRequest, zCreateCredentialBody, zCreateCredentialPath, zCreateCredentialRequest, zCreateCredentialResponse, zCreateNeonAuthBody, zCreateNeonAuthIntegrationBody, zCreateNeonAuthNewUserBody, zCreateNeonAuthPath, zCreateNeonAuthProviderSdkKeysBody, zCreateOrgApiKeyBody, zCreateOrgApiKeyPath, zCreateOrganizationInvitationsBody, zCreateOrganizationInvitationsPath, zCreateProjectBody, zCreateProjectBranchAnonymizedBody, zCreateProjectBranchAnonymizedPath, zCreateProjectBranchBody, zCreateProjectBranchBucketBody, zCreateProjectBranchBucketPath, zCreateProjectBranchDataApiBody, zCreateProjectBranchDataApiPath, zCreateProjectBranchDatabaseBody, zCreateProjectBranchDatabasePath, zCreateProjectBranchFunctionDeploymentBody, zCreateProjectBranchFunctionDeploymentPath, zCreateProjectBranchPath, zCreateProjectBranchRoleBody, zCreateProjectBranchRolePath, zCreateProjectEndpointBody, zCreateProjectEndpointPath, zCreateProjectTransferRequestBody, zCreateProjectTransferRequestPath, zCreateSnapshotPath, zCreateSnapshotQuery, zCredentialMeta, zCredentialScope, zCurrentUserAuthAccount, zCurrentUserInfoResponse, zCursorPagination, zCursorPaginationResponse, zCursorParam, zDataApiCreateRequest, zDataApiCreateResponse, zDataApiReponse, zDataApiSettings, zDataApiUpdateRequest, zDatabase, zDatabaseCreateRequest, zDatabaseOperations, zDatabaseResponse, zDatabaseUpdateRequest, zDatabasesResponse, zDefaultEndpointSettings, zDeleteBranchNeonAuthOauthProviderPath, zDeleteBranchNeonAuthTrustedDomainBody, zDeleteBranchNeonAuthTrustedDomainPath, zDeleteBranchNeonAuthUserPath, zDeleteNeonAuthDomainFromRedirectUriWhitelistBody, zDeleteNeonAuthDomainFromRedirectUriWhitelistPath, zDeleteNeonAuthIntegrationBody, zDeleteNeonAuthIntegrationPath, zDeleteNeonAuthOauthProviderPath, zDeleteNeonAuthUserPath, zDeleteOrganizationSpendingLimitPath, zDeleteOrganizationVpcEndpointPath, zDeleteProjectBranchBucketObjectPath, zDeleteProjectBranchBucketObjectsByPrefixPath, zDeleteProjectBranchBucketObjectsByPrefixQuery, zDeleteProjectBranchBucketPath, zDeleteProjectBranchDataApiPath, zDeleteProjectBranchDatabasePath, zDeleteProjectBranchFunctionPath, zDeleteProjectBranchPath, zDeleteProjectBranchQuery, zDeleteProjectBranchRolePath, zDeleteProjectEndpointPath, zDeleteProjectJwksPath, zDeleteProjectPath, zDeleteProjectVpcEndpointPath, zDeleteSnapshotPath, zDisableNeonAuthBody, zDisableNeonAuthPath, zEmptyResponse, zEnableNeonAuthIntegrationRequest, zEndpoint, zEndpointCreateRequest, zEndpointOperations, zEndpointPoolerMode, zEndpointResponse, zEndpointSettingsData, zEndpointState, zEndpointType, zEndpointUpdateRequest, zEndpointsOptionalResponse, zEndpointsResponse, zErrorCode, zFinalizeRestoreBranchBody, zFinalizeRestoreBranchPath, zFunctionDeployRequest, zGeneralError, zGetActiveRegionsQuery, zGetAnonymizedBranchStatusPath, zGetAvailablePreloadLibrariesPath, zGetConnectionUriPath, zGetConnectionUriQuery, zGetConsumptionHistoryPerBranchV2Query, zGetConsumptionHistoryPerProjectQuery, zGetConsumptionHistoryPerProjectV2Query, zGetMaskingRulesPath, zGetNeonAuthAllowLocalhostPath, zGetNeonAuthEmailAndPasswordConfigPath, zGetNeonAuthEmailProviderPath, zGetNeonAuthEmailServerPath, zGetNeonAuthPath, zGetNeonAuthPhoneNumberPluginPath, zGetNeonAuthPluginConfigsPath, zGetNeonAuthWebhookConfigPath, zGetOrganizationInvitationsPath, zGetOrganizationMemberPath, zGetOrganizationMembersPath, zGetOrganizationMembersQuery, zGetOrganizationPath, zGetOrganizationSpendingLimitPath, zGetOrganizationVpcEndpointDetailsPath, zGetProjectAdvisorSecurityIssuesPath, zGetProjectAdvisorSecurityIssuesQuery, zGetProjectBranchAiGatewayPath, zGetProjectBranchBucketObjectPath, zGetProjectBranchDataApiPath, zGetProjectBranchDatabasePath, zGetProjectBranchFunctionPath, zGetProjectBranchPath, zGetProjectBranchRolePasswordPath, zGetProjectBranchRolePath, zGetProjectBranchSchemaComparisonPath, zGetProjectBranchSchemaComparisonQuery, zGetProjectBranchSchemaPath, zGetProjectBranchSchemaQuery, zGetProjectBranchStoragePath, zGetProjectEndpointPath, zGetProjectJwksPath, zGetProjectOperationPath, zGetProjectPath, zGetSnapshotSchedulePath, zGrantPermissionToProjectBody, zGrantPermissionToProjectPath, zGrantPermissionToProjectRequest, zIdentityProviderId, zInvitation, zJwks, zJwksCreationOperation, zJwksResponse, zLimitParam, zLimitsUnsatisfiedResponse, zListBranchNeonAuthOauthProvidersPath, zListBranchNeonAuthTrustedDomainsPath, zListCredentialsPath, zListCredentialsResponse, zListNeonAuthIntegrationsPath, zListNeonAuthIntegrationsResponse, zListNeonAuthOauthProvidersPath, zListNeonAuthOauthProvidersResponse, zListNeonAuthRedirectUriWhitelistDomainsPath, zListOrgApiKeysPath, zListOrganizationVpcEndpointsAllRegionsPath, zListOrganizationVpcEndpointsPath, zListProjectBranchBucketObjectsPath, zListProjectBranchBucketObjectsQuery, zListProjectBranchBucketsPath, zListProjectBranchDatabasesPath, zListProjectBranchEndpointsPath, zListProjectBranchFunctionsPath, zListProjectBranchFunctionsQuery, zListProjectBranchLogFieldValuesPath, zListProjectBranchLogFieldValuesQuery, zListProjectBranchLogFieldsPath, zListProjectBranchRolesPath, zListProjectBranchesPath, zListProjectBranchesQuery, zListProjectEndpointsPath, zListProjectMembersPath, zListProjectMembersQuery, zListProjectOperationsPath, zListProjectOperationsQuery, zListProjectPermissionsPath, zListProjectVpcEndpointsPath, zListProjectsQuery, zListSharedProjectsQuery, zListSnapshotsPath, zMaintenanceWindow, zMaskingRule, zMaskingRulesResponse, zMaskingRulesUpdateRequest, zMember, zMemberRole, zMemberUserInfo, zMemberWithUser, zNeonAuthAddDomainToRedirectUriWhitelistRequest, zNeonAuthAddOAuthProviderRequest, zNeonAuthAllowLocalhostResponse, zNeonAuthConfigResponse, zNeonAuthConfigUpdate, zNeonAuthCreateAuthProviderSdkKeysRequest, zNeonAuthCreateIntegrationRequest, zNeonAuthCreateIntegrationResponse, zNeonAuthCreateNewUserRequest, zNeonAuthCreateNewUserResponse, zNeonAuthDeleteDomainFromRedirectUriWhitelistItem, zNeonAuthDeleteDomainFromRedirectUriWhitelistRequest, zNeonAuthEmailAndPasswordConfig, zNeonAuthEmailAndPasswordConfigUpdate, zNeonAuthEmailServerConfig, zNeonAuthEmailServerConfigResponse, zNeonAuthEmailVerificationMethod, zNeonAuthIntegration, zNeonAuthMagicLinkConfig, zNeonAuthMagicLinkConfigUpdate, zNeonAuthOauthProvider, zNeonAuthOauthProviderId, zNeonAuthOauthProviderType, zNeonAuthOrganizationConfig, zNeonAuthOrganizationConfigUpdate, zNeonAuthPhoneNumberConfig, zNeonAuthPhoneNumberConfigUpdate, zNeonAuthPluginConfigs, zNeonAuthProviderProjectOwnedBy, zNeonAuthProviderProjectTransferStatus, zNeonAuthRedirectUriWhitelistDomain, zNeonAuthRedirectUriWhitelistResponse, zNeonAuthSupportedAuthProvider, zNeonAuthTransferAuthProviderProjectRequest, zNeonAuthTransferAuthProviderProjectResponse, zNeonAuthUpdateOAuthProviderRequest, zNeonAuthWebhookConfig, zNeonFunction, zNeonFunctionDeployment, zNeonFunctionDeploymentResponse, zNeonFunctionResponse, zNeonFunctionUpdateRequest, zNeonFunctionsListResponse, zOperation, zOperationAction, zOperationResponse, zOperationStatus, zOperationsResponse, zOrgApiKeyCreateRequest, zOrgApiKeyCreateResponse, zOrgApiKeyRevokeResponse, zOrgApiKeysListResponseItem, zOrganization, zOrganizationInvitationsResponse, zOrganizationInviteCreateRequest, zOrganizationInvitesCreateRequest, zOrganizationMemberUpdateRequest, zOrganizationMembersResponse, zOrganizationsResponse, zPagination, zPaginationResponse, zPaymentSource, zPaymentSourceBankCard, zPgSettingsData, zPgVersion, zPgbouncerSettingsData, zPlanDetails, zPlanVersion, zPreloadLibraries, zPresignProjectBranchBucketObjectBody, zPresignProjectBranchBucketObjectPath, zPresignRequest, zPresignResponse, zProject, zProjectAuditLogLevel, zProjectBranchLogDuration, zProjectBranchLogFieldValuesResponse, zProjectBranchLogFieldsResponse, zProjectBranchLogRecord, zProjectBranchLogSeverity, zProjectBranchLogSource, zProjectBranchLogsInvalidQuery, zProjectBranchLogsNotAvailable, zProjectBranchLogsQueryRequest, zProjectBranchLogsQueryResponse, zProjectCreateRequest, zProjectJwksResponse, zProjectListItem, zProjectMember, zProjectMemberGrantSource, zProjectMemberOrgRole, zProjectMemberRoleResponse, zProjectMembers, zProjectOwnerData, zProjectPermission, zProjectPermissionLevel, zProjectPermissions, zProjectQuota, zProjectRecoverResponse, zProjectResponse, zProjectRole, zProjectSettingsData, zProjectTransferRequestResponse, zProjectUpdateRequest, zProjectsApplicationsMapResponse, zProjectsIntegrationsMapResponse, zProjectsResponse, zProjectsWithIntegrationResponse, zProvisioner, zQueryProjectBranchLogsBody, zQueryProjectBranchLogsPath, zRecoverProjectPath, zRegionResponse, zRemoveOrganizationMemberPath, zRemoveProjectMemberRolePath, zRemoveProjectMemberRoleQuery, zResetProjectBranchRolePasswordPath, zRestartProjectEndpointPath, zRestoreProjectBranchBody, zRestoreProjectBranchPath, zRestoreSnapshotBody, zRestoreSnapshotPath, zRestoreSnapshotQuery, zRevokeApiKeyPath, zRevokeCredentialPath, zRevokeOrgApiKeyPath, zRevokePermissionFromProjectPath, zRole, zRoleCreateRequest, zRoleOperations, zRolePasswordResponse, zRoleResponse, zRolesResponse, zSendNeonAuthTestEmailBody, zSendNeonAuthTestEmailPath, zSendNeonAuthTestEmailRequest, zSendNeonAuthTestEmailResponse, zSetDefaultProjectBranchPath, zSetOrganizationSpendingLimitBody, zSetOrganizationSpendingLimitPath, zSetProjectMemberRoleBody, zSetProjectMemberRolePath, zSetProjectMemberRoleQuery, zSetProjectMemberRoleRequest, zSetSnapshotScheduleBody, zSetSnapshotSchedulePath, zSharedEmailServer, zSnapshot, zSnapshotUpdateRequest, zSortOrderParam, zSpendingLimitResponse, zSpendingLimitUpdateRequest, zStandardEmailServer, zStandardEmailServerResponse, zStartAnonymizationPath, zStartProjectEndpointPath, zSuspendProjectEndpointPath, zSuspendTimeoutSeconds, zTimeoutParam, zTransferNeonAuthProviderProjectBody, zTransferProjectsFromOrgToOrgBody, zTransferProjectsFromOrgToOrgPath, zTransferProjectsFromUserToOrgBody, zTransferProjectsToOrganizationRequest, zUpdateBranchNeonAuthOauthProviderBody, zUpdateBranchNeonAuthOauthProviderPath, zUpdateMaskingRulesBody, zUpdateMaskingRulesPath, zUpdateNeonAuthAllowLocalhostBody, zUpdateNeonAuthAllowLocalhostPath, zUpdateNeonAuthAllowLocalhostRequest, zUpdateNeonAuthConfigBody, zUpdateNeonAuthConfigPath, zUpdateNeonAuthEmailAndPasswordConfigBody, zUpdateNeonAuthEmailAndPasswordConfigPath, zUpdateNeonAuthEmailProviderBody, zUpdateNeonAuthEmailProviderPath, zUpdateNeonAuthEmailServerBody, zUpdateNeonAuthEmailServerPath, zUpdateNeonAuthMagicLinkPluginBody, zUpdateNeonAuthMagicLinkPluginPath, zUpdateNeonAuthOauthProviderBody, zUpdateNeonAuthOauthProviderPath, zUpdateNeonAuthOrganizationPluginBody, zUpdateNeonAuthOrganizationPluginPath, zUpdateNeonAuthPhoneNumberPluginBody, zUpdateNeonAuthPhoneNumberPluginPath, zUpdateNeonAuthUserRoleBody, zUpdateNeonAuthUserRolePath, zUpdateNeonAuthUserRoleRequest, zUpdateNeonAuthUserRoleResponse, zUpdateNeonAuthWebhookConfigBody, zUpdateNeonAuthWebhookConfigPath, zUpdateOrganizationMemberBody, zUpdateOrganizationMemberPath, zUpdateProjectBody, zUpdateProjectBranchBody, zUpdateProjectBranchDataApiBody, zUpdateProjectBranchDataApiPath, zUpdateProjectBranchDatabaseBody, zUpdateProjectBranchDatabasePath, zUpdateProjectBranchFunctionBody, zUpdateProjectBranchFunctionPath, zUpdateProjectBranchPath, zUpdateProjectEndpointBody, zUpdateProjectEndpointPath, zUpdateProjectPath, zUpdateSnapshotBody, zUpdateSnapshotPath, zVpcEndpoint, zVpcEndpointAssignment, zVpcEndpointDetails, zVpcEndpointWithRegion, zVpcEndpointsResponse, zVpcEndpointsWithRegionResponse };