@rnsk/toolkits 0.0.8 → 0.0.10

package/dist/toolkits/neon/tools/dataapi.js

@@ -0,0 +1,111 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { neon, setNested } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const neonCreateBranchesDataApi = tool({
+    description: "Creates a new instance of Neon Data API in the specified branch. The Data API provides a RESTful interface to query your Postgres database using HTTP requests. Use this action when you need to expose database access via REST API endpoints with JWT-based authentication.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        jwksUrl: z.string().optional().describe("The URL that lists the JWKS (JSON Web Key Set) for external authentication. Required when auth_provider is 'external'."),
+        settings: z.record(z.any()).optional().describe("Configuration settings for the Neon Data API"),
+        branchId: z.string().describe("The branch ID where the Data API will be created (e.g., 'br-muddy-pond-ahkofech'). Obtain via NEON_GET_BRANCHES_FOR_PROJECT action."),
+        projectId: z.string().describe("The Neon project ID (e.g., 'proud-meadow-87189985'). Obtain via NEON_RETRIEVE_PROJECTS_LIST action."),
+        jwtAudience: z.string().optional().describe("JWT audience claim to validate. WARNING: tokens without audience claim will still be accepted."),
+        authProvider: z.enum(["neon_auth", "external"]).optional().describe("Authentication provider options for Neon Data API"),
+        databaseName: z.string().describe("The database name for the Data API (e.g., 'neondb'). Must be an existing database in the branch."),
+        providerName: z.string().optional().describe("The name of the authentication provider (e.g., 'Clerk', 'Stytch', 'Auth0'). Used for documentation purposes."),
+        skipAuthSchema: z.boolean().optional().describe("Skip creating the auth schema and RLS functions. Default: false"),
+        addDefaultGrants: z.boolean().optional().describe("Grant all permissions to the tables in the public schema to authenticated users. Default: false"),
+    }),
+    execute: async ({ neonApiKey, jwksUrl, settings, branchId, projectId, jwtAudience, authProvider, databaseName, providerName, skipAuthSchema, addDefaultGrants }) => {
+        const queryParams = undefined;
+        const body = {};
+        if (jwksUrl !== undefined)
+            setNested(body, 'jwks_url', jwksUrl);
+        if (settings !== undefined)
+            setNested(body, 'settings', settings);
+        if (jwtAudience !== undefined)
+            setNested(body, 'jwt_audience', jwtAudience);
+        if (authProvider !== undefined)
+            setNested(body, 'auth_provider', authProvider);
+        if (providerName !== undefined)
+            setNested(body, 'provider_name', providerName);
+        if (skipAuthSchema !== undefined)
+            setNested(body, 'skip_auth_schema', skipAuthSchema);
+        if (addDefaultGrants !== undefined)
+            setNested(body, 'add_default_grants', addDefaultGrants);
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/branches/${encodeURIComponent(branchId)}/data-api/${encodeURIComponent(databaseName)}`, method: 'POST', query: queryParams, body });
+    },
+});
+export const neonDeleteBranchDataApi = tool({
+    description: "Deletes the Neon Data API for a specified branch and database. Use this when you need to remove Data API access for a specific database within a branch.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        branchId: z.string().describe("The branch ID. Format: 'br-' prefix followed by alphanumeric characters (e.g., 'br-rough-voice-ah2lazzk'). Obtain from list branches endpoint."),
+        projectId: z.string().describe("The Neon project ID. Format: {adjective}-{noun}-{number} (e.g., 'proud-meadow-87189985'). Obtain from list projects endpoint."),
+        databaseName: z.string().describe("The database name for which to delete the Neon Data API. This is the database name as it appears in PostgreSQL (e.g., 'neondb')."),
+    }),
+    execute: async ({ neonApiKey, branchId, projectId, databaseName }) => {
+        const queryParams = undefined;
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/branches/${encodeURIComponent(branchId)}/data-api/${encodeURIComponent(databaseName)}`, method: 'DELETE', query: queryParams });
+    },
+});
+export const neonGetBranchesDataApi = tool({
+    description: "Retrieves the Neon Data API information for a specific branch and database. Use when you need to access the Data API URL, deployment status, or configuration settings for a particular database within a branch.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        branchId: z.string().describe("The Neon branch ID"),
+        projectId: z.string().describe("The Neon project ID"),
+        databaseName: z.string().describe("The database name"),
+    }),
+    execute: async ({ neonApiKey, branchId, projectId, databaseName }) => {
+        const queryParams = undefined;
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/branches/${encodeURIComponent(branchId)}/data-api/${encodeURIComponent(databaseName)}`, method: 'GET', query: queryParams });
+    },
+});
+export const neonUpdateBranchesDataApi = tool({
+    description: "Updates the Neon Data API configuration for the specified branch. Use when you need to modify Data API settings such as aggregates, anonymous role, search paths, schemas, JWT settings, or CORS configuration. The schema cache is always refreshed as part of this operation.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        branchId: z.string().describe("The Neon branch ID (e.g., 'br-gentle-lab-af8riisw')"),
+        projectId: z.string().describe("The Neon project ID (e.g., 'small-recipe-63664710')"),
+        databaseName: z.string().describe("The database name (e.g., 'neondb')"),
+        settingsDbSchemas: z.array(z.string()).optional().describe("List of schemas to expose via the API. Default: [\"public\"]"),
+        settingsDbMaxRows: z.number().int().optional().describe("Maximum number of rows that can be returned in a single request"),
+        settingsOpenapiMode: z.string().optional().describe("OpenAPI specification mode (ignore-privileges, disabled). Default: 'disabled'"),
+        settingsDbAnonRole: z.string().optional().describe("Database role to use for anonymous requests. Default: 'anonymous'"),
+        settingsJwtRoleClaimKey: z.string().optional().describe("JWT claim key to use for role extraction. Default: \".\\\"role\\\"\""),
+        settingsDbAggregatesEnabled: z.boolean().optional().describe("Enable aggregates feature. Default: true"),
+        settingsDbExtraSearchPath: z.string().optional().describe("Extra schemas to add to the search path"),
+        settingsServerTimingEnabled: z.boolean().optional().describe("Enable server timing headers"),
+        settingsJwtCacheMaxLifetime: z.number().int().optional().describe("Maximum lifetime for JWT cache in seconds"),
+        settingsServerCorsAllowedOrigins: z.string().optional().describe("CORS allowed origins"),
+    }),
+    execute: async ({ neonApiKey, branchId, projectId, databaseName, settingsDbSchemas, settingsDbMaxRows, settingsOpenapiMode, settingsDbAnonRole, settingsJwtRoleClaimKey, settingsDbAggregatesEnabled, settingsDbExtraSearchPath, settingsServerTimingEnabled, settingsJwtCacheMaxLifetime, settingsServerCorsAllowedOrigins }) => {
+        const queryParams = undefined;
+        const body = {};
+        if (settingsDbSchemas !== undefined)
+            setNested(body, 'settings.db_schemas', settingsDbSchemas);
+        if (settingsDbMaxRows !== undefined)
+            setNested(body, 'settings.db_max_rows', settingsDbMaxRows);
+        if (settingsOpenapiMode !== undefined)
+            setNested(body, 'settings.openapi_mode', settingsOpenapiMode);
+        if (settingsDbAnonRole !== undefined)
+            setNested(body, 'settings.db_anon_role', settingsDbAnonRole);
+        if (settingsJwtRoleClaimKey !== undefined)
+            setNested(body, 'settings.jwt_role_claim_key', settingsJwtRoleClaimKey);
+        if (settingsDbAggregatesEnabled !== undefined)
+            setNested(body, 'settings.db_aggregates_enabled', settingsDbAggregatesEnabled);
+        if (settingsDbExtraSearchPath !== undefined)
+            setNested(body, 'settings.db_extra_search_path', settingsDbExtraSearchPath);
+        if (settingsServerTimingEnabled !== undefined)
+            setNested(body, 'settings.server_timing_enabled', settingsServerTimingEnabled);
+        if (settingsJwtCacheMaxLifetime !== undefined)
+            setNested(body, 'settings.jwt_cache_max_lifetime', settingsJwtCacheMaxLifetime);
+        if (settingsServerCorsAllowedOrigins !== undefined)
+            setNested(body, 'settings.server_cors_allowed_origins', settingsServerCorsAllowedOrigins);
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/branches/${encodeURIComponent(branchId)}/data-api/${encodeURIComponent(databaseName)}`, method: 'PATCH', query: queryParams, body });
+    },
+});
+//# sourceMappingURL=dataapi.js.map

package/dist/toolkits/neon/tools/endpoints.d.ts

@@ -0,0 +1,59 @@
+export declare const neonCreateComputeEndpoint: import("ai").Tool<{
+    projectId: string;
+    neonApiKey?: string | undefined;
+    endpointType?: "read_only" | "read_write" | undefined;
+    endpointDisabled?: boolean | undefined;
+    endpointBranchId?: string | undefined;
+    endpointRegionId?: string | undefined;
+    endpointProvisioner?: string | undefined;
+    endpointPoolerMode?: "transaction" | undefined;
+    endpointPoolerEnabled?: boolean | undefined;
+    endpointPasswordlessAccess?: boolean | undefined;
+    endpointSettingsPgSettings?: Record<string, any> | undefined;
+    endpointSuspendTimeoutSeconds?: number | undefined;
+    endpointAutoscalingLimitMaxCu?: number | undefined;
+    endpointAutoscalingLimitMinCu?: number | undefined;
+    endpointSettingsPgbouncerSettings?: Record<string, any> | undefined;
+}, any>;
+export declare const neonDeleteProjectEndpoint: import("ai").Tool<{
+    projectId: string;
+    endpointId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonRestartProjectEndpoint: import("ai").Tool<{
+    projectId: string;
+    endpointId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonRetrieveProjectEndpointDetails: import("ai").Tool<{
+    projectId: string;
+    endpointId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonStartEndpointForProject: import("ai").Tool<{
+    projectId: string;
+    endpointId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonSuspendProjectEndpointById: import("ai").Tool<{
+    projectId: string;
+    endpointId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonUpdateProjectComputeEndpointSettings: import("ai").Tool<{
+    projectId: string;
+    endpointId: string;
+    neonApiKey?: string | undefined;
+    endpointDisabled?: boolean | undefined;
+    endpointBranchId?: string | undefined;
+    endpointProvisioner?: string | undefined;
+    endpointPoolerMode?: "transaction" | undefined;
+    endpointPoolerEnabled?: boolean | undefined;
+    endpointPasswordlessAccess?: boolean | undefined;
+    endpointSettingsPgSettings?: Record<string, any> | undefined;
+    endpointSuspendTimeoutSeconds?: number | undefined;
+    endpointAutoscalingLimitMaxCu?: number | undefined;
+    endpointAutoscalingLimitMinCu?: number | undefined;
+    endpointSettingsPgbouncerSettings?: Record<string, any> | undefined;
+}, any>;
+//# sourceMappingURL=endpoints.d.ts.map

package/dist/toolkits/neon/tools/endpoints.js

@@ -0,0 +1,163 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { neon, setNested } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const neonCreateComputeEndpoint = tool({
+    description: "Creates a new compute endpoint for a specified branch within a Neon project. This endpoint allows for detailed configuration of database resources, including read/write capabilities, regional placement, autoscaling limits, and connection pooling settings. It's primarily used when setting up new database instances or modifying existing database configurations to meet specific performance, scaling, or operational requirements. The endpoint provides fine-grained control over compute resources, enabling optimized database operations for various use cases from development to production environments.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        projectId: z.string().describe("The Neon project ID"),
+        endpointType: z.enum(["read_only", "read_write"]).optional().describe("The compute endpoint type. Either 'read_write' or 'read_only'. "),
+        endpointDisabled: z.boolean().optional().describe("Whether to restrict connections to the compute endpoint. Enabling this option schedules a suspend compute operation. A disabled compute endpoint cannot be enabled by a connection or console action. However, the compute endpoint is periodically enabled by check_availability operations.  "),
+        endpointBranchId: z.string().optional().describe("The ID of the branch the compute endpoint will be associated with "),
+        endpointRegionId: z.string().optional().describe("The region where the compute endpoint will be created. Only the project\"s 'region_id' is permitted.  "),
+        endpointProvisioner: z.string().optional().describe("The Neon compute provisioner. Specify the 'k8s-neonvm' provisioner to create a compute endpoint that supports Autoscaling. Provisioner can be one of the following values: * k8s-pod * k8s-neonvm Clients must expect, that any string value that is not documented in the description above should be treated as a error. UNKNOWN value if safe to treat as an error too.  "),
+        endpointPoolerMode: z.enum(["transaction"]).optional().describe("The connection pooler mode. Neon supports PgBouncer in 'transaction' mode only.  "),
+        endpointPoolerEnabled: z.boolean().optional().describe("Whether to enable connection pooling for the compute endpoint "),
+        endpointPasswordlessAccess: z.boolean().optional().describe("NOT YET IMPLEMENTED. Whether to permit passwordless access to the compute endpoint.  "),
+        endpointSettingsPgSettings: z.record(z.any()).optional().describe("A raw representation of Postgres settings"),
+        endpointSuspendTimeoutSeconds: z.number().int().optional().describe("Duration of inactivity in seconds after which the compute endpoint is automatically suspended. The value '0' means use the global default. 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 [Auto-suspend configuration](https://neon.tech/docs/manage/endpoints#auto-suspend-configuration).  "),
+        endpointAutoscalingLimitMaxCu: z.number().int().optional().describe("Autoscaling Limit Max Cu"),
+        endpointAutoscalingLimitMinCu: z.number().int().optional().describe("Autoscaling Limit Min Cu"),
+        endpointSettingsPgbouncerSettings: z.record(z.any()).optional().describe("A raw representation of PgBouncer settings"),
+    }),
+    execute: async ({ neonApiKey, projectId, endpointType, endpointDisabled, endpointBranchId, endpointRegionId, endpointProvisioner, endpointPoolerMode, endpointPoolerEnabled, endpointPasswordlessAccess, endpointSettingsPgSettings, endpointSuspendTimeoutSeconds, endpointAutoscalingLimitMaxCu, endpointAutoscalingLimitMinCu, endpointSettingsPgbouncerSettings }) => {
+        const queryParams = undefined;
+        const body = {};
+        if (endpointType !== undefined)
+            setNested(body, 'endpoint.type', endpointType);
+        if (endpointDisabled !== undefined)
+            setNested(body, 'endpoint.disabled', endpointDisabled);
+        if (endpointBranchId !== undefined)
+            setNested(body, 'endpoint.branch_id', endpointBranchId);
+        if (endpointRegionId !== undefined)
+            setNested(body, 'endpoint.region_id', endpointRegionId);
+        if (endpointProvisioner !== undefined)
+            setNested(body, 'endpoint.provisioner', endpointProvisioner);
+        if (endpointPoolerMode !== undefined)
+            setNested(body, 'endpoint.pooler_mode', endpointPoolerMode);
+        if (endpointPoolerEnabled !== undefined)
+            setNested(body, 'endpoint.pooler_enabled', endpointPoolerEnabled);
+        if (endpointPasswordlessAccess !== undefined)
+            setNested(body, 'endpoint.passwordless_access', endpointPasswordlessAccess);
+        if (endpointSettingsPgSettings !== undefined)
+            setNested(body, 'endpoint.settings.pg_settings', endpointSettingsPgSettings);
+        if (endpointSuspendTimeoutSeconds !== undefined)
+            setNested(body, 'endpoint.suspend_timeout_seconds', endpointSuspendTimeoutSeconds);
+        if (endpointAutoscalingLimitMaxCu !== undefined)
+            setNested(body, 'endpoint.autoscaling_limit_max_cu', endpointAutoscalingLimitMaxCu);
+        if (endpointAutoscalingLimitMinCu !== undefined)
+            setNested(body, 'endpoint.autoscaling_limit_min_cu', endpointAutoscalingLimitMinCu);
+        if (endpointSettingsPgbouncerSettings !== undefined)
+            setNested(body, 'endpoint.settings.pgbouncer_settings', endpointSettingsPgbouncerSettings);
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/endpoints`, method: 'POST', query: queryParams, body });
+    },
+});
+export const neonDeleteProjectEndpoint = tool({
+    description: "Deletes a specific endpoint within a Neon project. This operation permanently removes the endpoint and all associated resources, such as configurations and access points. Use this endpoint when you need to decommission or clean up unused endpoints in your project. It's important to note that this action is irreversible, so ensure you have backed up any necessary data or configurations before proceeding. This endpoint should be used with caution, as it will immediately terminate access to the specified endpoint and may impact any systems or applications relying on it.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        projectId: z.string().describe("The Neon project ID. Format: {adjective}-{noun}-{number} (e.g., 'dry-smoke-26258271'). Obtain from NEON_RETRIEVE_PROJECTS_LIST."),
+        endpointId: z.string().describe("The compute endpoint ID to delete. Format: ep-{name}-{id} (e.g., 'ep-flat-mud-af9isowb'). Obtain from NEON_GET_PROJECT_ENDPOINT_INFORMATION."),
+    }),
+    execute: async ({ neonApiKey, projectId, endpointId }) => {
+        const queryParams = undefined;
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/endpoints/${encodeURIComponent(endpointId)}`, method: 'DELETE', query: queryParams });
+    },
+});
+export const neonRestartProjectEndpoint = tool({
+    description: "Restarts a Neon compute endpoint (Postgres instance) within a project. The restart operation suspends and then starts the compute endpoint, which is useful for: - Applying configuration changes - Clearing cached data or connections - Troubleshooting connection or performance issues - Recovering from error states The operation triggers two sequential actions: 'suspend_compute' followed by 'start_compute'. During restart, the endpoint will be briefly unavailable. The response includes the updated endpoint details and the operations triggered. Note: If the endpoint is in a 'locked' state (HTTP 423) due to an ongoing operation, wait for it to complete before retrying. If the endpoint is 'idle', it will be started directly without suspension.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        projectId: z.string().describe("The Neon project ID (e.g., 'dry-smoke-26258271'). Can be obtained from list projects API."),
+        endpointId: z.string().describe("The Neon compute endpoint ID to restart (e.g., 'ep-patient-morning-afvkyj5f'). Can be obtained from list project endpoints API."),
+    }),
+    execute: async ({ neonApiKey, projectId, endpointId }) => {
+        const queryParams = undefined;
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/endpoints/${encodeURIComponent(endpointId)}/restart`, method: 'POST', query: queryParams });
+    },
+});
+export const neonRetrieveProjectEndpointDetails = tool({
+    description: "Retrieves detailed information about a specific compute endpoint within a Neon serverless PostgreSQL project. Compute endpoints are the connection points for your Neon databases. Use this action to get information about a specific endpoint including its hostname for connections, autoscaling settings, current state (active/idle/suspended), connection pooling config, and PostgreSQL settings. This is useful for getting the connection hostname, checking endpoint health, verifying compute resources, or troubleshooting connection issues. The endpoint_id can be obtained from the list endpoints action. Note: This is a read-only operation.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        projectId: z.string().describe("The unique identifier for a Neon project (e.g., 'dry-smoke-26258271'). Can be obtained from the projects list endpoint or project details."),
+        endpointId: z.string().describe("The unique identifier of the compute endpoint (e.g., 'ep-empty-bush-af3x7l26'). Endpoint IDs start with 'ep-' prefix. Can be obtained from the list endpoints action."),
+    }),
+    execute: async ({ neonApiKey, projectId, endpointId }) => {
+        const queryParams = undefined;
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/endpoints/${encodeURIComponent(endpointId)}`, method: 'GET', query: queryParams });
+    },
+});
+export const neonStartEndpointForProject = tool({
+    description: "Starts a suspended or idle compute endpoint for a Neon PostgreSQL project. Neon compute endpoints automatically suspend after a period of inactivity to save resources. Use this action to wake up a suspended endpoint and make it available for database connections. The endpoint will transition from 'idle' or 'suspended' state to 'active'. If the endpoint is already active, the call is idempotent and returns the current endpoint state with no operations. The response includes the endpoint details and any triggered operations. Note: Endpoint startup typically takes a few seconds.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        projectId: z.string().describe("The unique Neon project identifier (e.g., 'dry-smoke-26258271'). Can be obtained from the projects list endpoint."),
+        endpointId: z.string().describe("The unique compute endpoint identifier (e.g., 'ep-patient-morning-afvkyj5f'). Can be obtained from the project endpoints list."),
+    }),
+    execute: async ({ neonApiKey, projectId, endpointId }) => {
+        const queryParams = undefined;
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/endpoints/${encodeURIComponent(endpointId)}/start`, method: 'POST', query: queryParams });
+    },
+});
+export const neonSuspendProjectEndpointById = tool({
+    description: "Suspends a specific endpoint within a project in the Neon B2B SaaS integration platform. This operation temporarily disables the endpoint, preventing it from processing further requests until it is resumed. Use this endpoint when you need to conserve resources, perform maintenance, or temporarily halt operations for a particular integration point. The suspension is reversible, allowing you to resume the endpoint's functionality when needed. This tool is particularly useful for managing resource utilization and costs in your Neon project by allowing fine-grained control over individual endpoints.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        projectId: z.string().describe("The Neon project ID"),
+        endpointId: z.string().describe("The endpoint ID"),
+    }),
+    execute: async ({ neonApiKey, projectId, endpointId }) => {
+        const queryParams = undefined;
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/endpoints/${encodeURIComponent(endpointId)}/suspend`, method: 'POST', query: queryParams });
+    },
+});
+export const neonUpdateProjectComputeEndpointSettings = tool({
+    description: "Updates the configuration of a specific compute endpoint within a Neon project. This endpoint allows fine-tuning of various settings such as autoscaling limits, provisioner type, connection pooling, and auto-suspend behavior. It's particularly useful for optimizing performance, resource allocation, and cost management of your Neon compute endpoints. The endpoint should be used when you need to modify the behavior or resources of an existing compute endpoint to better suit your application's needs or to implement changes in your infrastructure strategy. Note that some parameters are deprecated, and care should be taken to use the most current features and settings.",
+    inputSchema: z.object({
+        neonApiKey: tokenField,
+        projectId: z.string().describe("The Neon project ID"),
+        endpointId: z.string().describe("The endpoint ID"),
+        endpointDisabled: z.boolean().optional().describe("Whether to restrict connections to the compute endpoint. Enabling this option schedules a suspend compute operation. A disabled compute endpoint cannot be enabled by a connection or console action. However, the compute endpoint is periodically enabled by check_availability operations.  "),
+        endpointBranchId: z.string().optional().describe("DEPRECATED: This field will be removed in a future release. The destination branch ID. The destination branch must not have an exsiting read-write endpoint.  "),
+        endpointProvisioner: z.string().optional().describe("The Neon compute provisioner. Specify the 'k8s-neonvm' provisioner to create a compute endpoint that supports Autoscaling. Provisioner can be one of the following values: * k8s-pod * k8s-neonvm Clients must expect, that any string value that is not documented in the description above should be treated as a error. UNKNOWN value if safe to treat as an error too.  "),
+        endpointPoolerMode: z.enum(["transaction"]).optional().describe("The connection pooler mode. Neon supports PgBouncer in 'transaction' mode only.  "),
+        endpointPoolerEnabled: z.boolean().optional().describe("Whether to enable connection pooling for the compute endpoint "),
+        endpointPasswordlessAccess: z.boolean().optional().describe("NOT YET IMPLEMENTED. Whether to permit passwordless access to the compute endpoint.  "),
+        endpointSettingsPgSettings: z.record(z.any()).optional().describe("A raw representation of Postgres settings"),
+        endpointSuspendTimeoutSeconds: z.number().int().optional().describe("Duration of inactivity in seconds after which the compute endpoint is automatically suspended. The value '0' means use the global default. 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 [Auto-suspend configuration](https://neon.tech/docs/manage/endpoints#auto-suspend-configuration).  "),
+        endpointAutoscalingLimitMaxCu: z.number().int().optional().describe("Autoscaling Limit Max Cu"),
+        endpointAutoscalingLimitMinCu: z.number().int().optional().describe("Autoscaling Limit Min Cu"),
+        endpointSettingsPgbouncerSettings: z.record(z.any()).optional().describe("A raw representation of PgBouncer settings"),
+    }),
+    execute: async ({ neonApiKey, projectId, endpointId, endpointDisabled, endpointBranchId, endpointProvisioner, endpointPoolerMode, endpointPoolerEnabled, endpointPasswordlessAccess, endpointSettingsPgSettings, endpointSuspendTimeoutSeconds, endpointAutoscalingLimitMaxCu, endpointAutoscalingLimitMinCu, endpointSettingsPgbouncerSettings }) => {
+        const queryParams = undefined;
+        const body = {};
+        if (endpointDisabled !== undefined)
+            setNested(body, 'endpoint.disabled', endpointDisabled);
+        if (endpointBranchId !== undefined)
+            setNested(body, 'endpoint.branch_id', endpointBranchId);
+        if (endpointProvisioner !== undefined)
+            setNested(body, 'endpoint.provisioner', endpointProvisioner);
+        if (endpointPoolerMode !== undefined)
+            setNested(body, 'endpoint.pooler_mode', endpointPoolerMode);
+        if (endpointPoolerEnabled !== undefined)
+            setNested(body, 'endpoint.pooler_enabled', endpointPoolerEnabled);
+        if (endpointPasswordlessAccess !== undefined)
+            setNested(body, 'endpoint.passwordless_access', endpointPasswordlessAccess);
+        if (endpointSettingsPgSettings !== undefined)
+            setNested(body, 'endpoint.settings.pg_settings', endpointSettingsPgSettings);
+        if (endpointSuspendTimeoutSeconds !== undefined)
+            setNested(body, 'endpoint.suspend_timeout_seconds', endpointSuspendTimeoutSeconds);
+        if (endpointAutoscalingLimitMaxCu !== undefined)
+            setNested(body, 'endpoint.autoscaling_limit_max_cu', endpointAutoscalingLimitMaxCu);
+        if (endpointAutoscalingLimitMinCu !== undefined)
+            setNested(body, 'endpoint.autoscaling_limit_min_cu', endpointAutoscalingLimitMinCu);
+        if (endpointSettingsPgbouncerSettings !== undefined)
+            setNested(body, 'endpoint.settings.pgbouncer_settings', endpointSettingsPgbouncerSettings);
+        return neon(neonApiKey, { path: `/projects/${encodeURIComponent(projectId)}/endpoints/${encodeURIComponent(endpointId)}`, method: 'PATCH', query: queryParams, body });
+    },
+});
+//# sourceMappingURL=endpoints.js.map