@distilled.cloud/neon 0.0.0 → 0.2.0-alpha

package/lib/traits.js

@@ -0,0 +1,5 @@
+/**
+ * Re-export the shared traits system from sdk-core.
+ */
+export * from "@distilled.cloud/core/traits";
+//# sourceMappingURL=traits.js.map

package/lib/traits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traits.js","sourceRoot":"","sources":["../src/traits.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,8BAA8B,CAAC"}

package/package.json

@@ -1,13 +1,88 @@
 {
   "name": "@distilled.cloud/neon",
-  "version": "0.0.0",
-  "module": "index.ts",
+  "version": "0.2.0-alpha",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alchemy-run/distilled",
+    "directory": "packages/neon"
+  },
   "type": "module",
-  "private": false,
+  "sideEffects": false,
+  "module": "src/index.ts",
+  "files": [
+    "lib",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./lib/index.js"
+    },
+    "./Category": {
+      "types": "./lib/category.d.ts",
+      "bun": "./src/category.ts",
+      "default": "./lib/category.js"
+    },
+    "./Client": {
+      "types": "./lib/client.d.ts",
+      "bun": "./src/client.ts",
+      "default": "./lib/client.js"
+    },
+    "./Credentials": {
+      "types": "./lib/credentials.d.ts",
+      "bun": "./src/credentials.ts",
+      "default": "./lib/credentials.js"
+    },
+    "./Errors": {
+      "types": "./lib/errors.d.ts",
+      "bun": "./src/errors.ts",
+      "default": "./lib/errors.js"
+    },
+    "./Operations": {
+      "types": "./lib/operations/index.d.ts",
+      "bun": "./src/operations/index.ts",
+      "default": "./lib/operations/index.js"
+    },
+    "./Retry": {
+      "types": "./lib/retry.d.ts",
+      "bun": "./src/retry.ts",
+      "default": "./lib/retry.js"
+    },
+    "./Sensitive": {
+      "types": "./lib/sensitive.d.ts",
+      "bun": "./src/sensitive.ts",
+      "default": "./lib/sensitive.js"
+    },
+    "./Traits": {
+      "types": "./lib/traits.d.ts",
+      "bun": "./src/traits.ts",
+      "default": "./lib/traits.js"
+    }
+  },
+  "scripts": {
+    "typecheck": "tsgo",
+    "build": "tsgo -b",
+    "fmt": "oxfmt --write src",
+    "lint": "oxlint --fix src",
+    "check": "tsgo && oxlint src && oxfmt --check src",
+    "test": "bunx vitest run test",
+    "publish:npm": "bun run build && bun publish --access public",
+    "generate": "bun run scripts/generate.ts && oxfmt --write src && oxlint --fix src",
+    "specs:fetch": "git submodule update --force --init --recursive specs/distilled-spec-neon && git -C specs/distilled-spec-neon checkout -- .",
+    "specs:update": "git -C specs/distilled-spec-neon fetch && git -C specs/distilled-spec-neon checkout main && git -C specs/distilled-spec-neon pull"
+  },
+  "dependencies": {
+    "@distilled.cloud/core": "0.2.0",
+    "effect": "4.0.0-beta.25"
+  },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "^1.3.0",
+    "@types/node": "^25.3.5",
+    "dotenv": "^16.5.0",
+    "vitest": "^3.2.3"
   },
   "peerDependencies": {
-    "typescript": "^5"
+    "effect": "4.0.0-beta.25"
   }
 }

package/src/category.ts

@@ -0,0 +1,4 @@
+/**
+ * Re-export the shared category system from sdk-core.
+ */
+export * from "@distilled.cloud/core/category";

package/src/client.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 Schema from "effect/Schema";
+import { makeAPI } from "@distilled.cloud/core/client";
+import { HTTP_STATUS_MAP, NeonApiError, NeonParseError } from "./errors.ts";
+
+// Re-export for backwards compatibility (tests import NeonApiError from client)
+export { NeonApiError } 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 NeonApiError({
+        code: parsed.code,
+        message: parsed.message,
+        body: errorBody,
+      }),
+    );
+  } catch {
+    return Effect.fail(new NeonApiError({ body: errorBody }));
+  }
+};
+
+/**
+ * Neon API client.
+ */
+export const API = makeAPI({
+  credentials: Credentials as any,
+  getBaseUrl: (creds: any) => creds.apiBaseUrl,
+  getAuthHeaders: (creds: any) => ({
+    Authorization: `Bearer ${creds.apiKey}`,
+  }),
+  matchError,
+  ParseError: NeonParseError as any,
+});

package/src/credentials.ts

@@ -0,0 +1,30 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+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: 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, apiBaseUrl: DEFAULT_API_BASE_URL };
+  }),
+);

package/src/errors.ts

@@ -0,0 +1,45 @@
+/**
+ * Neon-specific error types.
+ *
+ * Re-exports common HTTP errors from sdk-core and adds Neon-specific
+ * error matching and API error types.
+ */
+export {
+  BadRequest,
+  Conflict,
+  ConfigError,
+  Forbidden,
+  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";
+
+// Generic API Error - uncategorized fallback
+export class NeonApiError extends Schema.TaggedErrorClass<NeonApiError>()(
+  "NeonApiError",
+  {
+    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,
+}));