@distilled.cloud/fly-io 0.30.3 → 1.0.0-rc.10

package/src/services/mpg.ts

@@ -0,0 +1,1188 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import type * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  FlyApiProtocol,
+  type FlyIoOpError,
+  type FlyIoOpContext,
+} from "../protocol.ts";
+import { Conflict, Forbidden, NotFound } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { FlyIoOpError, FlyIoOpContext };
+
+export interface CreateAttachmentRequest {
+  id: string;
+  app_name: string;
+}
+export const CreateAttachmentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    app_name: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/api/v1/postgresv2/{id}/attachments",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateAttachmentRequest",
+}) as any as S.Schema<CreateAttachmentRequest>;
+
+export interface CreateAttachmentResponseData {
+  id?: number;
+  app_id?: number;
+  managed_service_id?: number;
+  attached_at?: string;
+}
+export const CreateAttachmentResponseData = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.Number),
+    app_id: S.optional(S.Number),
+    managed_service_id: S.optional(S.Number),
+    attached_at: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "CreateAttachmentResponseData",
+}) as any as S.Schema<CreateAttachmentResponseData>;
+
+export interface CreateAttachmentResponse {
+  data?: CreateAttachmentResponseData;
+}
+export const CreateAttachmentResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(CreateAttachmentResponseData),
+  }),
+).annotate({
+  identifier: "CreateAttachmentResponse",
+}) as any as S.Schema<CreateAttachmentResponse>;
+
+export interface CreateBackupRequest {
+  id: string;
+  type?: string;
+}
+export const CreateBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    type: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/api/v1/postgresv2/{id}/backups",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateBackupRequest",
+}) as any as S.Schema<CreateBackupRequest>;
+
+export interface CreateBackupResponse {}
+export const CreateBackupResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateBackupResponse",
+}) as any as S.Schema<CreateBackupResponse>;
+
+export interface CreateClusterRequest {
+  org_slug: string;
+  name: string;
+  region: string;
+  plan: string;
+  pg_major_version?: string;
+  storage_in_gb?: number;
+  postgis_enabled?: boolean;
+}
+export const CreateClusterRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org_slug: S.String.pipe(T.Label()),
+    name: S.String,
+    region: S.String,
+    plan: S.String,
+    pg_major_version: S.optional(S.String),
+    storage_in_gb: S.optional(S.Number),
+    postgis_enabled: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/api/v1/organizations/{org_slug}/postgresv2",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateClusterRequest",
+}) as any as S.Schema<CreateClusterRequest>;
+
+export interface Organization {
+  id?: string;
+  name?: string;
+  slug?: string;
+  raw_slug?: string;
+}
+export const Organization = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+    slug: S.optional(S.String),
+    raw_slug: S.optional(S.String),
+  }),
+).annotate({ identifier: "Organization" }) as any as S.Schema<Organization>;
+
+export type IpAssignments = { [key: string]: string | undefined };
+export const IpAssignments = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<IpAssignments>;
+
+export interface AttachedApp {
+  name?: string;
+  id?: string;
+}
+export const AttachedApp = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    id: S.optional(S.String),
+  }),
+).annotate({ identifier: "AttachedApp" }) as any as S.Schema<AttachedApp>;
+
+export type ManagedClusterAttachedAppsList = Array<AttachedApp>;
+export const ManagedClusterAttachedAppsList = /*@__PURE__*/ S.Array(
+  AttachedApp,
+) as any as S.Schema<ManagedClusterAttachedAppsList>;
+
+export interface ManagedCluster {
+  id?: string;
+  name?: string;
+  status?: string;
+  engine?: string;
+  plan?: string;
+  region?: string;
+  organization?: Organization;
+  mpgd_cluster_id?: string;
+  disk?: number;
+  replicas?: number;
+  ip_assignments?: IpAssignments;
+  attached_apps?: ManagedClusterAttachedAppsList;
+  postgis_enabled?: boolean;
+  environment?: string;
+}
+export const ManagedCluster = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+    status: S.optional(S.String),
+    engine: S.optional(S.String),
+    plan: S.optional(S.String),
+    region: S.optional(S.String),
+    organization: S.optional(Organization),
+    mpgd_cluster_id: S.optional(S.String),
+    disk: S.optional(S.Number),
+    replicas: S.optional(S.Number),
+    ip_assignments: S.optional(IpAssignments),
+    attached_apps: S.optional(ManagedClusterAttachedAppsList),
+    postgis_enabled: S.optional(S.Boolean),
+    environment: S.optional(S.String),
+  }),
+).annotate({ identifier: "ManagedCluster" }) as any as S.Schema<ManagedCluster>;
+
+export type CreateClusterResponseErrorsMap = {
+  [key: string]: unknown | undefined;
+};
+export const CreateClusterResponseErrorsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.Unknown,
+) as any as S.Schema<CreateClusterResponseErrorsMap>;
+
+export interface CreateClusterResponse {
+  ok?: boolean;
+  data?: ManagedCluster;
+  errors?: CreateClusterResponseErrorsMap;
+}
+export const CreateClusterResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ok: S.optional(S.Boolean),
+    data: S.optional(ManagedCluster),
+    errors: S.optional(CreateClusterResponseErrorsMap),
+  }),
+).annotate({
+  identifier: "CreateClusterResponse",
+}) as any as S.Schema<CreateClusterResponse>;
+
+export interface CreateDatabaseRequest {
+  id: string;
+  name: string;
+}
+export const CreateDatabaseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    name: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/api/v1/postgresv2/{id}/databases",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateDatabaseRequest",
+}) as any as S.Schema<CreateDatabaseRequest>;
+
+export interface CreateDatabaseResponse {}
+export const CreateDatabaseResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateDatabaseResponse",
+}) as any as S.Schema<CreateDatabaseResponse>;
+
+export type CreateUserRequestRole = "schema_admin" | "writer" | "reader";
+export const CreateUserRequestRole = S.String;
+
+export interface CreateUserRequest {
+  id: string;
+  username: string;
+  role: CreateUserRequestRole | (string & {});
+}
+export const CreateUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    username: S.String,
+    role: CreateUserRequestRole,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/api/v1/postgresv2/{id}/users", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateUserRequest",
+}) as any as S.Schema<CreateUserRequest>;
+
+export interface User {
+  name?: string;
+  username?: string;
+  role?: string;
+}
+export const User = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    username: S.optional(S.String),
+    role: S.optional(S.String),
+  }),
+).annotate({ identifier: "User" }) as any as S.Schema<User>;
+
+export interface CreateUserResponse {
+  data?: User;
+}
+export const CreateUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(User),
+  }),
+).annotate({
+  identifier: "CreateUserResponse",
+}) as any as S.Schema<CreateUserResponse>;
+
+export interface DeleteAttachmentRequest {
+  id: string;
+  app_name: string;
+}
+export const DeleteAttachmentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    app_name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/api/v1/postgresv2/{id}/attachments/{app_name}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteAttachmentRequest",
+}) as any as S.Schema<DeleteAttachmentRequest>;
+
+export interface DeleteAttachmentResponseData {
+  message?: string;
+}
+export const DeleteAttachmentResponseData = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    message: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DeleteAttachmentResponseData",
+}) as any as S.Schema<DeleteAttachmentResponseData>;
+
+export interface DeleteAttachmentResponse {
+  data?: DeleteAttachmentResponseData;
+}
+export const DeleteAttachmentResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(DeleteAttachmentResponseData),
+  }),
+).annotate({
+  identifier: "DeleteAttachmentResponse",
+}) as any as S.Schema<DeleteAttachmentResponse>;
+
+export interface DeleteUserRequest {
+  id: string;
+  username: string;
+}
+export const DeleteUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/api/v1/postgresv2/{id}/users/{username}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteUserRequest",
+}) as any as S.Schema<DeleteUserRequest>;
+
+export interface DeleteUserResponse {}
+export const DeleteUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteUserResponse",
+}) as any as S.Schema<DeleteUserResponse>;
+
+export interface DestroyClusterRequest {
+  org_slug: string;
+  id: string;
+}
+export const DestroyClusterRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org_slug: S.String.pipe(T.Label()),
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/api/v1/organizations/{org_slug}/postgresv2/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DestroyClusterRequest",
+}) as any as S.Schema<DestroyClusterRequest>;
+
+export interface DestroyClusterResponse {}
+export const DestroyClusterResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DestroyClusterResponse",
+}) as any as S.Schema<DestroyClusterResponse>;
+
+export interface DisableExtensionRequest {
+  id: string;
+  database: string;
+  name: string;
+  force?: boolean;
+}
+export const DisableExtensionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    database: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+    force: S.optional(S.Boolean.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/api/v1/postgresv2/{id}/databases/{database}/extensions/{name}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DisableExtensionRequest",
+}) as any as S.Schema<DisableExtensionRequest>;
+
+export interface DisableExtensionResponse {}
+export const DisableExtensionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DisableExtensionResponse",
+}) as any as S.Schema<DisableExtensionResponse>;
+
+export interface EnableExtensionRequest {
+  id: string;
+  database: string;
+  name: string;
+  schema?: string;
+  create_schema_if_needed?: boolean;
+}
+export const EnableExtensionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    database: S.String.pipe(T.Label()),
+    name: S.String,
+    schema: S.optional(S.String),
+    create_schema_if_needed: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/api/v1/postgresv2/{id}/databases/{database}/extensions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "EnableExtensionRequest",
+}) as any as S.Schema<EnableExtensionRequest>;
+
+export interface EnableExtensionResponse {}
+export const EnableExtensionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EnableExtensionResponse",
+}) as any as S.Schema<EnableExtensionResponse>;
+
+export interface GetClusterRequest {
+  org_slug: string;
+  id: string;
+}
+export const GetClusterRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org_slug: S.String.pipe(T.Label()),
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/api/v1/organizations/{org_slug}/postgresv2/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetClusterRequest",
+}) as any as S.Schema<GetClusterRequest>;
+
+export interface ClusterCredentials {
+  status?: string;
+  user?: string;
+  password?: string | Redacted.Redacted<string>;
+  dbname?: string;
+  pgbouncer_uri?: string | Redacted.Redacted<string>;
+}
+export const ClusterCredentials = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    status: S.optional(S.String),
+    user: S.optional(S.String),
+    password: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    dbname: S.optional(S.String),
+    pgbouncer_uri: S.optional(S.String.pipe(T.SensitiveValue({}))),
+  }),
+).annotate({
+  identifier: "ClusterCredentials",
+}) as any as S.Schema<ClusterCredentials>;
+
+export interface GetClusterResponse {
+  data?: ManagedCluster;
+  credentials?: ClusterCredentials;
+}
+export const GetClusterResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(ManagedCluster),
+    credentials: S.optional(ClusterCredentials),
+  }),
+).annotate({
+  identifier: "GetClusterResponse",
+}) as any as S.Schema<GetClusterResponse>;
+
+export interface GetClusterByIdRequest {
+  id: string;
+}
+export const GetClusterByIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/api/v1/postgresv2/{id}", code: 200 })),
+).annotate({
+  identifier: "GetClusterByIdRequest",
+}) as any as S.Schema<GetClusterByIdRequest>;
+
+export interface GetUserCredentialsRequest {
+  id: string;
+  username: string;
+}
+export const GetUserCredentialsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/api/v1/postgresv2/{id}/users/{username}/credentials",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetUserCredentialsRequest",
+}) as any as S.Schema<GetUserCredentialsRequest>;
+
+export interface GetUserCredentialsResponseData {
+  username?: string;
+  user?: string;
+  password?: string | Redacted.Redacted<string>;
+}
+export const GetUserCredentialsResponseData = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.optional(S.String),
+    user: S.optional(S.String),
+    password: S.optional(S.String.pipe(T.SensitiveValue({}))),
+  }),
+).annotate({
+  identifier: "GetUserCredentialsResponseData",
+}) as any as S.Schema<GetUserCredentialsResponseData>;
+
+export interface GetUserCredentialsResponse {
+  data?: GetUserCredentialsResponseData;
+}
+export const GetUserCredentialsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(GetUserCredentialsResponseData),
+  }),
+).annotate({
+  identifier: "GetUserCredentialsResponse",
+}) as any as S.Schema<GetUserCredentialsResponse>;
+
+export interface ListBackupsRequest {
+  id: string;
+}
+export const ListBackupsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/api/v1/postgresv2/{id}/backups",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListBackupsRequest",
+}) as any as S.Schema<ListBackupsRequest>;
+
+export interface ClusterBackup {
+  id?: string;
+  status?: string;
+  type?: string;
+  start?: string;
+  stop?: string;
+}
+export const ClusterBackup = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    status: S.optional(S.String),
+    type: S.optional(S.String),
+    start: S.optional(S.String),
+    stop: S.optional(S.String),
+  }),
+).annotate({ identifier: "ClusterBackup" }) as any as S.Schema<ClusterBackup>;
+
+export type ListBackupsResponseDataList = Array<ClusterBackup>;
+export const ListBackupsResponseDataList = /*@__PURE__*/ S.Array(
+  ClusterBackup,
+) as any as S.Schema<ListBackupsResponseDataList>;
+
+export interface ListBackupsResponse {
+  data?: ListBackupsResponseDataList;
+}
+export const ListBackupsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(ListBackupsResponseDataList),
+  }),
+).annotate({
+  identifier: "ListBackupsResponse",
+}) as any as S.Schema<ListBackupsResponse>;
+
+export interface ListClustersRequest {
+  org_slug: string;
+}
+export const ListClustersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org_slug: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/api/v1/organizations/{org_slug}/postgresv2",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListClustersRequest",
+}) as any as S.Schema<ListClustersRequest>;
+
+export type ListClustersResponseDataList = Array<ManagedCluster>;
+export const ListClustersResponseDataList = /*@__PURE__*/ S.Array(
+  ManagedCluster,
+) as any as S.Schema<ListClustersResponseDataList>;
+
+export interface ListClustersResponse {
+  data?: ListClustersResponseDataList;
+}
+export const ListClustersResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(ListClustersResponseDataList),
+  }),
+).annotate({
+  identifier: "ListClustersResponse",
+}) as any as S.Schema<ListClustersResponse>;
+
+export interface ListDatabasesRequest {
+  id: string;
+}
+export const ListDatabasesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/api/v1/postgresv2/{id}/databases",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListDatabasesRequest",
+}) as any as S.Schema<ListDatabasesRequest>;
+
+export interface Database {
+  name?: string;
+}
+export const Database = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+  }),
+).annotate({ identifier: "Database" }) as any as S.Schema<Database>;
+
+export type ListDatabasesResponseDataList = Array<Database>;
+export const ListDatabasesResponseDataList = /*@__PURE__*/ S.Array(
+  Database,
+) as any as S.Schema<ListDatabasesResponseDataList>;
+
+export interface ListDatabasesResponse {
+  data?: ListDatabasesResponseDataList;
+}
+export const ListDatabasesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(ListDatabasesResponseDataList),
+  }),
+).annotate({
+  identifier: "ListDatabasesResponse",
+}) as any as S.Schema<ListDatabasesResponse>;
+
+export interface ListExtensionsRequest {
+  id: string;
+  database: string;
+}
+export const ListExtensionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    database: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/api/v1/postgresv2/{id}/databases/{database}/extensions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListExtensionsRequest",
+}) as any as S.Schema<ListExtensionsRequest>;
+
+export interface InstalledExtension {
+  version?: string;
+  schema?: string;
+}
+export const InstalledExtension = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    version: S.optional(S.String),
+    schema: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "InstalledExtension",
+}) as any as S.Schema<InstalledExtension>;
+
+export interface Extension {
+  name?: string;
+  description?: string;
+  docs_url?: string;
+  default_version?: string;
+  is_system?: boolean;
+  installed?: InstalledExtension;
+}
+export const Extension = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    description: S.optional(S.String),
+    docs_url: S.optional(S.String),
+    default_version: S.optional(S.String),
+    is_system: S.optional(S.Boolean),
+    installed: S.optional(InstalledExtension),
+  }),
+).annotate({ identifier: "Extension" }) as any as S.Schema<Extension>;
+
+export type ListExtensionsResponseDataList = Array<Extension>;
+export const ListExtensionsResponseDataList = /*@__PURE__*/ S.Array(
+  Extension,
+) as any as S.Schema<ListExtensionsResponseDataList>;
+
+export interface ListExtensionsResponse {
+  data?: ListExtensionsResponseDataList;
+}
+export const ListExtensionsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(ListExtensionsResponseDataList),
+  }),
+).annotate({
+  identifier: "ListExtensionsResponse",
+}) as any as S.Schema<ListExtensionsResponse>;
+
+export interface ListRegionsRequest {
+  org_slug: string;
+}
+export const ListRegionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org_slug: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/api/v1/organizations/{org_slug}/postgresv2/regions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListRegionsRequest",
+}) as any as S.Schema<ListRegionsRequest>;
+
+export interface Region {
+  code?: string;
+  available?: boolean;
+}
+export const Region = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    code: S.optional(S.String),
+    available: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "Region" }) as any as S.Schema<Region>;
+
+export type ListRegionsResponseDataList = Array<Region>;
+export const ListRegionsResponseDataList = /*@__PURE__*/ S.Array(
+  Region,
+) as any as S.Schema<ListRegionsResponseDataList>;
+
+export interface ListRegionsResponse {
+  data?: ListRegionsResponseDataList;
+}
+export const ListRegionsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(ListRegionsResponseDataList),
+  }),
+).annotate({
+  identifier: "ListRegionsResponse",
+}) as any as S.Schema<ListRegionsResponse>;
+
+export interface ListUsersRequest {
+  id: string;
+}
+export const ListUsersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/api/v1/postgresv2/{id}/users", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListUsersRequest",
+}) as any as S.Schema<ListUsersRequest>;
+
+export type ListUsersResponseDataList = Array<User>;
+export const ListUsersResponseDataList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<ListUsersResponseDataList>;
+
+export interface ListUsersResponse {
+  data?: ListUsersResponseDataList;
+}
+export const ListUsersResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(ListUsersResponseDataList),
+  }),
+).annotate({
+  identifier: "ListUsersResponse",
+}) as any as S.Schema<ListUsersResponse>;
+
+export interface RestoreBackupRequest {
+  id: string;
+  backup_id?: string;
+  name?: string;
+  pitr_time?: string;
+}
+export const RestoreBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    backup_id: S.optional(S.String),
+    name: S.optional(S.String),
+    pitr_time: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/api/v1/postgresv2/{id}/restore",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RestoreBackupRequest",
+}) as any as S.Schema<RestoreBackupRequest>;
+
+export interface RestoreBackupResponse {
+  data?: ManagedCluster;
+}
+export const RestoreBackupResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(ManagedCluster),
+  }),
+).annotate({
+  identifier: "RestoreBackupResponse",
+}) as any as S.Schema<RestoreBackupResponse>;
+
+export type UpdateUserRoleRequestRole = "schema_admin" | "writer" | "reader";
+export const UpdateUserRoleRequestRole = S.String;
+
+export interface UpdateUserRoleRequest {
+  id: string;
+  username: string;
+  role: UpdateUserRoleRequestRole | (string & {});
+}
+export const UpdateUserRoleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+    role: UpdateUserRoleRequestRole,
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/api/v1/postgresv2/{id}/users/{username}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateUserRoleRequest",
+}) as any as S.Schema<UpdateUserRoleRequest>;
+
+export interface UpdateUserRoleResponse {}
+export const UpdateUserRoleResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UpdateUserRoleResponse",
+}) as any as S.Schema<UpdateUserRoleResponse>;
+
+export type CreateAttachmentError = NotFound | Conflict | FlyIoOpError;
+/** Attach a cluster to a Machines app */
+export const createAttachment: API.OperationMethod<
+  CreateAttachmentRequest,
+  CreateAttachmentResponse,
+  CreateAttachmentError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateAttachmentRequest,
+  output: CreateAttachmentResponse,
+  errors: [NotFound, Conflict],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateBackupError = NotFound | FlyIoOpError;
+/** Create a backup */
+export const createBackup: API.OperationMethod<
+  CreateBackupRequest,
+  CreateBackupResponse,
+  CreateBackupError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateBackupRequest,
+  output: CreateBackupResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateClusterError = Forbidden | NotFound | Conflict | FlyIoOpError;
+/** Create an MPG v2 cluster */
+export const createCluster: API.OperationMethod<
+  CreateClusterRequest,
+  CreateClusterResponse,
+  CreateClusterError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateClusterRequest,
+  output: CreateClusterResponse,
+  errors: [Forbidden, NotFound, Conflict],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateDatabaseError = NotFound | Conflict | FlyIoOpError;
+/** Create a database */
+export const createDatabase: API.OperationMethod<
+  CreateDatabaseRequest,
+  CreateDatabaseResponse,
+  CreateDatabaseError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateDatabaseRequest,
+  output: CreateDatabaseResponse,
+  errors: [NotFound, Conflict],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateUserError = NotFound | Conflict | FlyIoOpError;
+/** Create a user with a role */
+export const createUser: API.OperationMethod<
+  CreateUserRequest,
+  CreateUserResponse,
+  CreateUserError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateUserRequest,
+  output: CreateUserResponse,
+  errors: [NotFound, Conflict],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteAttachmentError = NotFound | FlyIoOpError;
+/** Detach a cluster from a Machines app */
+export const deleteAttachment: API.OperationMethod<
+  DeleteAttachmentRequest,
+  DeleteAttachmentResponse,
+  DeleteAttachmentError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAttachmentRequest,
+  output: DeleteAttachmentResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteUserError = NotFound | FlyIoOpError;
+/** Delete a user */
+export const deleteUser: API.OperationMethod<
+  DeleteUserRequest,
+  DeleteUserResponse,
+  DeleteUserError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteUserRequest,
+  output: DeleteUserResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DestroyClusterError = NotFound | FlyIoOpError;
+/** Destroy an MPG v2 cluster (async — poll 404) */
+export const destroyCluster: API.OperationMethod<
+  DestroyClusterRequest,
+  DestroyClusterResponse,
+  DestroyClusterError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DestroyClusterRequest,
+  output: DestroyClusterResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DisableExtensionError = NotFound | FlyIoOpError;
+/** Disable an extension */
+export const disableExtension: API.OperationMethod<
+  DisableExtensionRequest,
+  DisableExtensionResponse,
+  DisableExtensionError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DisableExtensionRequest,
+  output: DisableExtensionResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EnableExtensionError = NotFound | Conflict | FlyIoOpError;
+/** Enable an extension */
+export const enableExtension: API.OperationMethod<
+  EnableExtensionRequest,
+  EnableExtensionResponse,
+  EnableExtensionError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EnableExtensionRequest,
+  output: EnableExtensionResponse,
+  errors: [NotFound, Conflict],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetClusterError = NotFound | FlyIoOpError;
+/** Get an MPG v2 cluster by org and id */
+export const getCluster: API.OperationMethod<
+  GetClusterRequest,
+  GetClusterResponse,
+  GetClusterError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetClusterRequest,
+  output: GetClusterResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetClusterByIdError = NotFound | FlyIoOpError;
+/** Get an MPG v2 cluster by id */
+export const getClusterById: API.OperationMethod<
+  GetClusterByIdRequest,
+  GetClusterResponse,
+  GetClusterByIdError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetClusterByIdRequest,
+  output: GetClusterResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetUserCredentialsError = NotFound | FlyIoOpError;
+/** Get a user's credentials */
+export const getUserCredentials: API.OperationMethod<
+  GetUserCredentialsRequest,
+  GetUserCredentialsResponse,
+  GetUserCredentialsError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetUserCredentialsRequest,
+  output: GetUserCredentialsResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListBackupsError = NotFound | FlyIoOpError;
+/** List cluster backups */
+export const listBackups: API.OperationMethod<
+  ListBackupsRequest,
+  ListBackupsResponse,
+  ListBackupsError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListBackupsRequest,
+  output: ListBackupsResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListClustersError = Forbidden | NotFound | FlyIoOpError;
+/** List MPG v2 clusters in an organization */
+export const listClusters: API.OperationMethod<
+  ListClustersRequest,
+  ListClustersResponse,
+  ListClustersError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListClustersRequest,
+  output: ListClustersResponse,
+  errors: [Forbidden, NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListDatabasesError = NotFound | FlyIoOpError;
+/** List databases (no DELETE API) */
+export const listDatabases: API.OperationMethod<
+  ListDatabasesRequest,
+  ListDatabasesResponse,
+  ListDatabasesError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListDatabasesRequest,
+  output: ListDatabasesResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListExtensionsError = NotFound | FlyIoOpError;
+/** List available/installed extensions */
+export const listExtensions: API.OperationMethod<
+  ListExtensionsRequest,
+  ListExtensionsResponse,
+  ListExtensionsError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListExtensionsRequest,
+  output: ListExtensionsResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListRegionsError = FlyIoOpError;
+/** List regions that support MPG for an organization */
+export const listRegions: API.OperationMethod<
+  ListRegionsRequest,
+  ListRegionsResponse,
+  ListRegionsError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListRegionsRequest,
+  output: ListRegionsResponse,
+  errors: [],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListUsersError = NotFound | FlyIoOpError;
+/** List cluster users */
+export const listUsers: API.OperationMethod<
+  ListUsersRequest,
+  ListUsersResponse,
+  ListUsersError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListUsersRequest,
+  output: ListUsersResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestoreBackupError = NotFound | FlyIoOpError;
+/** Restore a cluster from a backup (creates a new cluster) */
+export const restoreBackup: API.OperationMethod<
+  RestoreBackupRequest,
+  RestoreBackupResponse,
+  RestoreBackupError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestoreBackupRequest,
+  output: RestoreBackupResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateUserRoleError = NotFound | FlyIoOpError;
+/** Update a user's role */
+export const updateUserRole: API.OperationMethod<
+  UpdateUserRoleRequest,
+  UpdateUserRoleResponse,
+  UpdateUserRoleError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateUserRoleRequest,
+  output: UpdateUserRoleResponse,
+  errors: [NotFound],
+  protocol: FlyApiProtocol,
+  retry: Retry.Retry,
+}));