@distilled.cloud/neon 0.0.0-john

package/src/client.ts

@@ -0,0 +1,59 @@
+/**
+ * Neon API Client.
+ *
+ * Wraps the shared REST client from sdk-core with Neon-specific
+ * error matching and credential handling.
+ */
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import { makeAPI } from "@distilled.cloud/core/client";
+import { HTTP_STATUS_MAP, UnknownNeonError, NeonParseError } from "./errors.ts";
+
+// Re-export for backwards compatibility (tests import UnknownNeonError from client)
+export { UnknownNeonError } from "./errors.ts";
+import { Credentials } from "./credentials.ts";
+
+// API Error Response Schema
+const ApiErrorResponse = Schema.Struct({
+  code: Schema.optional(Schema.String),
+  message: Schema.String,
+});
+
+/**
+ * Match a Neon API error response to the appropriate error class based on HTTP status.
+ */
+const matchError = (
+  status: number,
+  errorBody: unknown,
+): Effect.Effect<never, unknown> => {
+  try {
+    const parsed = Schema.decodeUnknownSync(ApiErrorResponse)(errorBody);
+    const ErrorClass = (HTTP_STATUS_MAP as any)[status];
+    if (ErrorClass) {
+      return Effect.fail(new ErrorClass({ message: parsed.message ?? "" }));
+    }
+    return Effect.fail(
+      new UnknownNeonError({
+        code: parsed.code,
+        message: parsed.message,
+        body: errorBody,
+      }),
+    );
+  } catch {
+    return Effect.fail(new UnknownNeonError({ body: errorBody }));
+  }
+};
+
+/**
+ * Neon API client.
+ */
+export const API = makeAPI({
+  credentials: Credentials as any,
+  getBaseUrl: (creds: any) => creds.apiBaseUrl,
+  getAuthHeaders: (creds: any) => ({
+    Authorization: `Bearer ${Redacted.value(creds.apiKey)}`,
+  }),
+  matchError,
+  ParseError: NeonParseError as any,
+});

package/src/credentials.ts

@@ -0,0 +1,31 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as ServiceMap from "effect/ServiceMap";
+import { ConfigError } from "@distilled.cloud/core/errors";
+
+export const DEFAULT_API_BASE_URL = "https://console.neon.tech/api/v2";
+
+export interface Config {
+  readonly apiKey: Redacted.Redacted<string>;
+  readonly apiBaseUrl: string;
+}
+
+export class Credentials extends ServiceMap.Service<Credentials, Config>()(
+  "NeonCredentials",
+) {}
+
+export const CredentialsFromEnv = Layer.effect(
+  Credentials,
+  Effect.gen(function* () {
+    const apiKey = process.env.NEON_API_KEY;
+
+    if (!apiKey) {
+      return yield* new ConfigError({
+        message: "NEON_API_KEY environment variable is required",
+      });
+    }
+
+    return { apiKey: Redacted.make(apiKey), apiBaseUrl: DEFAULT_API_BASE_URL };
+  }),
+);

package/src/errors.ts

@@ -0,0 +1,47 @@
+/**
+ * Neon-specific error types.
+ *
+ * Re-exports common HTTP errors from sdk-core and adds Neon-specific
+ * error matching and API error types.
+ */
+export {
+  BadGateway,
+  BadRequest,
+  Conflict,
+  ConfigError,
+  Forbidden,
+  GatewayTimeout,
+  InternalServerError,
+  Locked,
+  NotFound,
+  ServiceUnavailable,
+  TooManyRequests,
+  Unauthorized,
+  UnprocessableEntity,
+  HTTP_STATUS_MAP,
+  DEFAULT_ERRORS,
+  API_ERRORS,
+} from "@distilled.cloud/core/errors";
+export type { DefaultErrors } from "@distilled.cloud/core/errors";
+
+import * as Schema from "effect/Schema";
+import * as Category from "@distilled.cloud/core/category";
+
+// Unknown Neon error - returned when an error code is not recognized
+export class UnknownNeonError extends Schema.TaggedErrorClass<UnknownNeonError>()(
+  "UnknownNeonError",
+  {
+    code: Schema.optional(Schema.String),
+    message: Schema.optional(Schema.String),
+    body: Schema.Unknown,
+  },
+).pipe(Category.withServerError) {}
+
+// Schema parse error wrapper
+export class NeonParseError extends Schema.TaggedErrorClass<NeonParseError>()(
+  "NeonParseError",
+  {
+    body: Schema.Unknown,
+    cause: Schema.Unknown,
+  },
+).pipe(Category.withParseError) {}

package/src/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Neon SDK for Effect
+ *
+ * @example
+ * ```ts
+ * import * as Neon from "@distilled.cloud/neon";
+ * ```
+ */
+export * from "./credentials.ts";
+export * as Category from "./category.ts";
+export * as T from "./traits.ts";
+export * as Retry from "./retry.ts";
+export { API } from "./client.ts";
+export * from "./errors.ts";
+export { SensitiveString, SensitiveNullableString } from "./sensitive.ts";

package/src/operations/acceptProjectTransferRequest.ts

@@ -0,0 +1,40 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const AcceptProjectTransferRequestInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    project_id: Schema.String.pipe(T.PathParam()),
+    request_id: Schema.String.pipe(T.PathParam()),
+    org_id: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      path: "/projects/{project_id}/transfer_requests/{request_id}",
+    }),
+  );
+export type AcceptProjectTransferRequestInput =
+  typeof AcceptProjectTransferRequestInput.Type;
+
+// Output Schema
+export const AcceptProjectTransferRequestOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type AcceptProjectTransferRequestOutput =
+  typeof AcceptProjectTransferRequestOutput.Type;
+
+// The operation
+/**
+ * Accept a project transfer request
+ *
+ * Accepts a transfer request for the specified project, transferring it to the specified organization
+ * or user. If org_id is not passed, the project will be transferred to the current user or organization account.
+ *
+ * @param project_id - The Neon project ID
+ * @param request_id - The Neon project transfer request ID
+ */
+export const acceptProjectTransferRequest =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: AcceptProjectTransferRequestInput,
+    outputSchema: AcceptProjectTransferRequestOutput,
+  }));

package/src/operations/addBranchNeonAuthOauthProvider.ts

@@ -0,0 +1,47 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const AddBranchNeonAuthOauthProviderInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    project_id: Schema.String.pipe(T.PathParam()),
+    branch_id: Schema.String.pipe(T.PathParam()),
+    id: Schema.Literals(["google", "github", "microsoft", "vercel"]),
+    client_id: Schema.optional(Schema.String),
+    client_secret: Schema.optional(Schema.String),
+    microsoft_tenant_id: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/projects/{project_id}/branches/{branch_id}/auth/oauth_providers",
+    }),
+  );
+export type AddBranchNeonAuthOauthProviderInput =
+  typeof AddBranchNeonAuthOauthProviderInput.Type;
+
+// Output Schema
+export const AddBranchNeonAuthOauthProviderOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.Literals(["google", "github", "microsoft", "vercel"]),
+    type: Schema.Literals(["standard", "shared"]),
+    client_id: Schema.optional(Schema.String),
+    client_secret: Schema.optional(Schema.String),
+  });
+export type AddBranchNeonAuthOauthProviderOutput =
+  typeof AddBranchNeonAuthOauthProviderOutput.Type;
+
+// The operation
+/**
+ * Add a OAuth provider
+ *
+ * Adds a OAuth provider to the specified project.
+ *
+ * @param project_id - The Neon project ID
+ * @param branch_id - The Neon branch ID
+ */
+export const addBranchNeonAuthOauthProvider =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: AddBranchNeonAuthOauthProviderInput,
+    outputSchema: AddBranchNeonAuthOauthProviderOutput,
+  }));

package/src/operations/addBranchNeonAuthTrustedDomain.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const AddBranchNeonAuthTrustedDomainInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    project_id: Schema.String.pipe(T.PathParam()),
+    branch_id: Schema.String.pipe(T.PathParam()),
+    domain: Schema.String,
+    auth_provider: Schema.Literals([
+      "mock",
+      "stack",
+      "stack_v2",
+      "better_auth",
+    ]),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/projects/{project_id}/branches/{branch_id}/auth/domains",
+    }),
+  );
+export type AddBranchNeonAuthTrustedDomainInput =
+  typeof AddBranchNeonAuthTrustedDomainInput.Type;
+
+// Output Schema
+export const AddBranchNeonAuthTrustedDomainOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type AddBranchNeonAuthTrustedDomainOutput =
+  typeof AddBranchNeonAuthTrustedDomainOutput.Type;
+
+// The operation
+/**
+ * Add domain to redirect_uri whitelist
+ *
+ * Adds a domain to the redirect_uri whitelist for the specified project.
+ *
+ * @param project_id - The Neon project ID
+ * @param branch_id - The Neon branch ID
+ */
+export const addBranchNeonAuthTrustedDomain =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: AddBranchNeonAuthTrustedDomainInput,
+    outputSchema: AddBranchNeonAuthTrustedDomainOutput,
+  }));

package/src/operations/addProjectJWKS.ts

@@ -0,0 +1,104 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const AddProjectJWKSInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  project_id: Schema.String.pipe(T.PathParam()),
+  jwks_url: Schema.String,
+  provider_name: Schema.String,
+  branch_id: Schema.optional(Schema.String),
+  jwt_audience: Schema.optional(Schema.String),
+  role_names: Schema.optional(Schema.Array(Schema.String)),
+  skip_role_creation: Schema.optional(Schema.Boolean),
+}).pipe(T.Http({ method: "POST", path: "/projects/{project_id}/jwks" }));
+export type AddProjectJWKSInput = typeof AddProjectJWKSInput.Type;
+
+// Output Schema
+export const AddProjectJWKSOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  jwks: Schema.Struct({
+    id: Schema.String,
+    project_id: Schema.String,
+    branch_id: Schema.optional(Schema.String),
+    jwks_url: Schema.String,
+    provider_name: Schema.String,
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    jwt_audience: Schema.optional(Schema.String),
+    role_names: Schema.optional(Schema.Array(Schema.String)),
+  }),
+  operations: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+      project_id: Schema.String,
+      branch_id: Schema.optional(Schema.String),
+      endpoint_id: Schema.optional(Schema.String),
+      action: Schema.Literals([
+        "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_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",
+        "prewarm_replica",
+        "promote_replica",
+        "set_storage_non_dirty",
+        "swap_binding_id",
+      ]),
+      status: Schema.Literals([
+        "scheduling",
+        "running",
+        "finished",
+        "failed",
+        "error",
+        "cancelling",
+        "cancelled",
+        "skipped",
+      ]),
+      error: Schema.optional(Schema.String),
+      failures_count: Schema.Number,
+      retry_at: Schema.optional(Schema.String),
+      created_at: Schema.String,
+      updated_at: Schema.String,
+      total_duration_ms: Schema.Number,
+    }),
+  ),
+});
+export type AddProjectJWKSOutput = typeof AddProjectJWKSOutput.Type;
+
+// The operation
+/**
+ * Add JWKS URL
+ *
+ * Add a new JWKS URL to a project, such that it can be used for verifying JWTs used as the authentication mechanism for the specified project.
+ * The URL must be a valid HTTPS URL that returns a JSON Web Key Set.
+ * The `provider_name` field allows you to specify which authentication provider you're using (e.g., Clerk, Auth0, AWS Cognito, etc.).
+ * The `branch_id` can be used to specify on which branches the JWKS URL will be accepted. If not specified, then it will work on any branch.
+ * The `role_names` can be used to specify for which roles the JWKS URL will be accepted. If not specified, then default roles will be used (authenticator, authenticated and anonymous).
+ * The `jwt_audience` can be used to specify which "aud" values should be accepted by Neon in the JWTs that are used for authentication.
+ *
+ * @param project_id - The Neon project ID
+ */
+export const addProjectJWKS = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: AddProjectJWKSInput,
+  outputSchema: AddProjectJWKSOutput,
+}));

package/src/operations/assignOrganizationVPCEndpoint.ts

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const AssignOrganizationVPCEndpointInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    org_id: Schema.String.pipe(T.PathParam()),
+    region_id: Schema.String.pipe(T.PathParam()),
+    vpc_endpoint_id: Schema.String.pipe(T.PathParam()),
+    label: Schema.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/organizations/{org_id}/vpc/region/{region_id}/vpc_endpoints/{vpc_endpoint_id}",
+    }),
+  );
+export type AssignOrganizationVPCEndpointInput =
+  typeof AssignOrganizationVPCEndpointInput.Type;
+
+// Output Schema
+export const AssignOrganizationVPCEndpointOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type AssignOrganizationVPCEndpointOutput =
+  typeof AssignOrganizationVPCEndpointOutput.Type;
+
+// The operation
+/**
+ * Assign or update VPC endpoint
+ *
+ * Assigns a VPC endpoint to a Neon organization or updates its existing assignment.
+ *
+ * @param org_id - The Neon organization ID
+ * @param region_id - The Neon region ID.
+Azure regions are currently not supported.
+
+ * @param vpc_endpoint_id - The VPC endpoint ID
+ */
+export const assignOrganizationVPCEndpoint =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: AssignOrganizationVPCEndpointInput,
+    outputSchema: AssignOrganizationVPCEndpointOutput,
+  }));

package/src/operations/assignProjectVPCEndpoint.ts

@@ -0,0 +1,44 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const AssignProjectVPCEndpointInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    project_id: Schema.String.pipe(T.PathParam()),
+    vpc_endpoint_id: Schema.String.pipe(T.PathParam()),
+    label: Schema.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/projects/{project_id}/vpc_endpoints/{vpc_endpoint_id}",
+    }),
+  );
+export type AssignProjectVPCEndpointInput =
+  typeof AssignProjectVPCEndpointInput.Type;
+
+// Output Schema
+export const AssignProjectVPCEndpointOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type AssignProjectVPCEndpointOutput =
+  typeof AssignProjectVPCEndpointOutput.Type;
+
+// The operation
+/**
+ * Set VPC endpoint restriction
+ *
+ * Sets or updates a VPC endpoint restriction for a Neon project.
+ * When a VPC endpoint restriction is set, the project only accepts connections
+ * from the specified VPC.
+ * A VPC endpoint can be set as a restriction only after it is assigned to the
+ * parent organization of the Neon project.
+ *
+ * @param project_id - The Neon project ID
+ * @param vpc_endpoint_id - The VPC endpoint ID
+ */
+export const assignProjectVPCEndpoint = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: AssignProjectVPCEndpointInput,
+    outputSchema: AssignProjectVPCEndpointOutput,
+  }),
+);

package/src/operations/countProjectBranches.ts

@@ -0,0 +1,37 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CountProjectBranchesInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    project_id: Schema.String.pipe(T.PathParam()),
+    search: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({ method: "GET", path: "/projects/{project_id}/branches/count" }),
+  );
+export type CountProjectBranchesInput = typeof CountProjectBranchesInput.Type;
+
+// Output Schema
+export const CountProjectBranchesOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    count: Schema.Number,
+  });
+export type CountProjectBranchesOutput = typeof CountProjectBranchesOutput.Type;
+
+// The operation
+/**
+ * Retrieve number of branches
+ *
+ * Retrieves the total number of branches in the specified project.
+ * You can obtain a `project_id` by listing the projects for your Neon account.
+ *
+ * @param project_id - The Neon project ID
+ * @param search - Count branches matching the `name` in search query
+ */
+export const countProjectBranches = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CountProjectBranchesInput,
+    outputSchema: CountProjectBranchesOutput,
+  }),
+);

package/src/operations/createApiKey.ts

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateApiKeyInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  key_name: Schema.String,
+}).pipe(T.Http({ method: "POST", path: "/api_keys" }));
+export type CreateApiKeyInput = typeof CreateApiKeyInput.Type;
+
+// Output Schema
+export const CreateApiKeyOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.Number,
+  key: Schema.String,
+  name: Schema.String,
+  created_at: Schema.String,
+  created_by: Schema.String,
+});
+export type CreateApiKeyOutput = typeof CreateApiKeyOutput.Type;
+
+// The operation
+/**
+ * Create API key
+ *
+ * Creates an API key.
+ * The `key_name` is a user-specified name for the key.
+ * This method returns an `id` and `key`. The `key` is a randomly generated, 64-bit token required to access the Neon API.
+ * API keys can also be managed in the Neon Console.
+ * See [Manage API keys](https://neon.tech/docs/manage/api-keys/).
+ */
+export const createApiKey = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: CreateApiKeyInput,
+  outputSchema: CreateApiKeyOutput,
+}));

package/src/operations/createBranchNeonAuthNewUser.ts

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateBranchNeonAuthNewUserInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    project_id: Schema.String.pipe(T.PathParam()),
+    branch_id: Schema.String.pipe(T.PathParam()),
+    email: Schema.String,
+    name: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/projects/{project_id}/branches/{branch_id}/auth/users",
+    }),
+  );
+export type CreateBranchNeonAuthNewUserInput =
+  typeof CreateBranchNeonAuthNewUserInput.Type;
+
+// Output Schema
+export const CreateBranchNeonAuthNewUserOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+  });
+export type CreateBranchNeonAuthNewUserOutput =
+  typeof CreateBranchNeonAuthNewUserOutput.Type;
+
+// The operation
+/**
+ * Create new auth user
+ *
+ * Creates a new user in Neon Auth.
+ *
+ * @param project_id - The Neon project ID
+ * @param branch_id - The Neon branch ID
+ */
+export const createBranchNeonAuthNewUser = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateBranchNeonAuthNewUserInput,
+    outputSchema: CreateBranchNeonAuthNewUserOutput,
+  }),
+);

package/src/operations/createNeonAuth.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateNeonAuthInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  project_id: Schema.String.pipe(T.PathParam()),
+  branch_id: Schema.String.pipe(T.PathParam()),
+  auth_provider: Schema.Literals(["mock", "stack", "stack_v2", "better_auth"]),
+  database_name: Schema.optional(Schema.String),
+}).pipe(
+  T.Http({
+    method: "POST",
+    path: "/projects/{project_id}/branches/{branch_id}/auth",
+  }),
+);
+export type CreateNeonAuthInput = typeof CreateNeonAuthInput.Type;
+
+// Output Schema
+export const CreateNeonAuthOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  auth_provider: Schema.Literals(["mock", "stack", "stack_v2", "better_auth"]),
+  auth_provider_project_id: Schema.String,
+  pub_client_key: Schema.String,
+  secret_server_key: Schema.String,
+  jwks_url: Schema.String,
+  schema_name: Schema.String,
+  table_name: Schema.String,
+  base_url: Schema.optional(Schema.String),
+});
+export type CreateNeonAuthOutput = typeof CreateNeonAuthOutput.Type;
+
+// The operation
+/**
+ * Enable Neon Auth for the branch
+ *
+ * Enables Neon Auth integrationfor the branch.
+ * You can obtain the `project_id` and `branch_id` by listing the projects and branches for your Neon account.
+ *
+ * @param project_id - The Neon project ID
+ * @param branch_id - The Neon branch ID
+ */
+export const createNeonAuth = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: CreateNeonAuthInput,
+  outputSchema: CreateNeonAuthOutput,
+}));