@distilled.cloud/fly-io 1.0.0-rc.12 → 1.0.0-rc.13

package/src/services/machines.ts

@@ -19,6 +19,20 @@ import * as Retry from "../retry.ts";
 
 export type { FlyIoOpError, FlyIoOpContext };
 
+export class MachineReplacing
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<MachineReplacing>()("MachineReplacing", {
+      message: S.String,
+    }),
+    [
+      {
+        status: 412,
+        message:
+          "failed_precondition: machine getting replaced, refusing to start",
+      },
+    ],
+  ) {}
+
 export class MachineStartFromCreatedState
   extends /*@__PURE__*/ T.applyErrorMatchers(
     /*@__PURE__*/ S.TaggedError<MachineStartFromCreatedState>()(
@@ -50,6 +64,29 @@ export class MachineWaitTimeout
     ],
   ) {}
 
+export class NetworkNotFound
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<NetworkNotFound>()("NetworkNotFound", {
+      message: S.String,
+    }),
+    [{ status: 400, message: { includes: "network not found" } }],
+  ) {}
+
+export class VolumeAttached
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<VolumeAttached>()("VolumeAttached", {
+      message: S.String,
+    }),
+    [
+      {
+        message: {
+          includes:
+            "failed_precondition: volume is currently bound to machine:",
+        },
+      },
+    ],
+  ) {}
+
 export interface AuthenticateTokenRequest {
   header?: string;
 }
@@ -510,11 +547,13 @@ export interface CordonMachineRequest {
   app_name: string;
   /** Machine ID */
   machine_id: string;
+  lease_nonce?: string;
 }
 export const CordonMachineRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     app_name: S.String.pipe(T.Label()),
     machine_id: S.String.pipe(T.Label()),
+    lease_nonce: S.optional(S.String.pipe(T.Header("fly-machine-lease-nonce"))),
   }).pipe(
     T.Http({
       method: "POST",
@@ -535,6 +574,8 @@ export const CordonMachineResponse = /*@__PURE__*/ S.suspend(() =>
 
 export interface CreateAppRequest {
   enable_subdomains?: boolean;
+  /** When set, makes a retry of this exact request safe: a second create with the same key and the same name (or no name) returns the app the first request created, instead of erroring on a false name conflict or creating a duplicate. A second create with the same key but a *different* name is rejected outright; it won't silently hand back the first app. */
+  idempotency_key?: string;
   name?: string;
   network?: string;
   org_slug?: string;
@@ -542,6 +583,7 @@ export interface CreateAppRequest {
 export const CreateAppRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     enable_subdomains: S.optional(S.Boolean),
+    idempotency_key: S.optional(S.String),
     name: S.optional(S.String),
     network: S.optional(S.String),
     org_slug: S.optional(S.String),
@@ -550,9 +592,15 @@ export const CreateAppRequest = /*@__PURE__*/ S.suspend(() =>
   identifier: "CreateAppRequest",
 }) as any as S.Schema<CreateAppRequest>;
 
-export interface CreateAppResponse {}
+export interface CreateAppResponse {
+  created_at?: number;
+  id?: string;
+}
 export const CreateAppResponse = /*@__PURE__*/ S.suspend(() =>
-  S.Struct({}),
+  S.Struct({
+    created_at: S.optional(S.Number),
+    id: S.optional(S.String),
+  }),
 ).annotate({
   identifier: "CreateAppResponse",
 }) as any as S.Schema<CreateAppResponse>;
@@ -722,12 +770,28 @@ export const IPPair = /*@__PURE__*/ S.suspend(() =>
   }),
 ).annotate({ identifier: "IPPair" }) as any as S.Schema<IPPair>;
 
+/** The 6PN network a Flycast (private_v6) address belongs to. Null for all other IP types. */
+export interface IPAssignmentNetwork {
+  /** Network name; empty for the organization's default network. */
+  name?: string;
+  org_slug?: string;
+}
+export const IPAssignmentNetwork = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    org_slug: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "IPAssignmentNetwork",
+}) as any as S.Schema<IPAssignmentNetwork>;
+
 export interface AssignIPResponse {
   created_at?: string;
   egress?: boolean;
   ip?: string;
   /** ip_pair is returned when "egress-pair" IP type is requested; in this case, ip is null. */
   ip_pair?: IPPair;
+  network?: IPAssignmentNetwork | null;
   region?: string;
   service_name?: string;
   shared?: boolean;
@@ -738,6 +802,7 @@ export const AssignIPResponse = /*@__PURE__*/ S.suspend(() =>
     egress: S.optional(S.Boolean),
     ip: S.optional(S.String),
     ip_pair: S.optional(IPPair),
+    network: S.optional(S.NullOr(IPAssignmentNetwork)),
     region: S.optional(S.String),
     service_name: S.optional(S.String),
     shared: S.optional(S.Boolean),
@@ -1070,26 +1135,19 @@ export const FlyContainerConfigHealthchecksList = /*@__PURE__*/ S.Array(
   FlyContainerHealthcheck,
 ) as any as S.Schema<FlyContainerConfigHealthchecksList>;
 
-/** * no - Never try to restart a Machine automatically when its main process exits, whether that’s on purpose or on a crash. * always - Always restart a Machine automatically and never let it enter a stopped state, even when the main process exits cleanly. * on-failure - Try up to MaxRetries times to automatically restart the Machine if it exits with a non-zero exit code. Default when no explicit policy is set, and for Machines with schedules. * spot-price - Starts the Machine only when there is capacity and the spot price is less than or equal to the bid price. */
-export type FlyMachineRestartPolicy =
-  | "no"
-  | "always"
-  | "on-failure"
-  | "spot-price";
+/** * no - Never try to restart a Machine automatically when its main process exits, whether that’s on purpose or on a crash. * always - Always restart a Machine automatically and never let it enter a stopped state, even when the main process exits cleanly. * on-failure - Try up to MaxRetries times to automatically restart the Machine if it exits with a non-zero exit code. Default when no explicit policy is set, and for Machines with schedules. */
+export type FlyMachineRestartPolicy = "no" | "always" | "on-failure";
 export const FlyMachineRestartPolicy = S.String;
 
 /** The Machine restart policy defines whether and how flyd restarts a Machine after its main process exits. See https://fly.io/docs/machines/guides-examples/machine-restart-policy/. */
 export interface FlyMachineRestart {
-  /** GPU bid price for spot Machines. */
-  gpu_bid_price?: number;
   /** When policy is on-failure, the maximum number of times to attempt to restart the Machine before letting it stop. */
   max_retries?: number;
-  /** * no - Never try to restart a Machine automatically when its main process exits, whether that’s on purpose or on a crash. * always - Always restart a Machine automatically and never let it enter a stopped state, even when the main process exits cleanly. * on-failure - Try up to MaxRetries times to automatically restart the Machine if it exits with a non-zero exit code. Default when no explicit policy is set, and for Machines with schedules. * spot-price - Starts the Machine only when there is capacity and the spot price is less than or equal to the bid price. */
+  /** * no - Never try to restart a Machine automatically when its main process exits, whether that’s on purpose or on a crash. * always - Always restart a Machine automatically and never let it enter a stopped state, even when the main process exits cleanly. * on-failure - Try up to MaxRetries times to automatically restart the Machine if it exits with a non-zero exit code. Default when no explicit policy is set, and for Machines with schedules. */
   policy?: FlyMachineRestartPolicy | (string & {});
 }
 export const FlyMachineRestart = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
-    gpu_bid_price: S.optional(S.Number),
     max_retries: S.optional(S.Number),
     policy: S.optional(FlyMachineRestartPolicy),
   }),
@@ -1161,7 +1219,7 @@ export interface FlyContainerConfig {
   image?: string;
   /** Name is used to identify the container in the machine. */
   name?: string;
-  /** Restart is used to define the restart policy for the container. NOTE: spot-price is not supported for containers. */
+  /** Restart is used to define the restart policy for the container. */
   restart?: FlyMachineRestart;
   /** Secrets can be provided at the process level to explicitly indicate which secrets should be used for the process. If not provided, the secrets provided at the machine level will be used. */
   secrets?: FlyContainerConfigSecretsList;
@@ -1283,6 +1341,11 @@ export const FlyMachineGuestKernelArgsList = /*@__PURE__*/ S.Array(
 export type FlyMachineGuestPersistRootfs = "never" | "always" | "restart";
 export const FlyMachineGuestPersistRootfs = S.String;
 
+export type FlyMachineGuestRequiredHostFeaturesList = Array<string>;
+export const FlyMachineGuestRequiredHostFeaturesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<FlyMachineGuestRequiredHostFeaturesList>;
+
 export interface FlyMachineGuest {
   cpu_kind?: string;
   cpus?: number;
@@ -1294,6 +1357,7 @@ export interface FlyMachineGuest {
   memory_mb?: number;
   /** Deprecated: use MachineConfig.Rootfs instead */
   persist_rootfs?: FlyMachineGuestPersistRootfs | (string & {});
+  required_host_features?: FlyMachineGuestRequiredHostFeaturesList;
 }
 export const FlyMachineGuest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
@@ -1306,6 +1370,7 @@ export const FlyMachineGuest = /*@__PURE__*/ S.suspend(() =>
     max_memory_mb: S.optional(S.Number),
     memory_mb: S.optional(S.Number),
     persist_rootfs: S.optional(FlyMachineGuestPersistRootfs),
+    required_host_features: S.optional(FlyMachineGuestRequiredHostFeaturesList),
   }),
 ).annotate({
   identifier: "FlyMachineGuest",
@@ -1373,8 +1438,12 @@ export const FlyMachineMetrics = /*@__PURE__*/ S.suspend(() =>
 
 export interface FlyMachineMount {
   add_size_gb?: number;
+  /** AddSizePercent grows by a percentage of the current size, rounded up to GiB. It is mutually exclusive with AddSizeGb. */
+  add_size_percent?: number;
   encrypted?: boolean;
   extend_threshold_percent?: number;
+  /** MinAddSizeGb is the minimum proportional growth in GiB (default 1). */
+  min_add_size_gb?: number;
   name?: string;
   path?: string;
   size_gb?: number;
@@ -1384,8 +1453,10 @@ export interface FlyMachineMount {
 export const FlyMachineMount = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     add_size_gb: S.optional(S.Number),
+    add_size_percent: S.optional(S.Number),
     encrypted: S.optional(S.Boolean),
     extend_threshold_percent: S.optional(S.Number),
+    min_add_size_gb: S.optional(S.Number),
     name: S.optional(S.String),
     path: S.optional(S.String),
     size_gb: S.optional(S.Number),
@@ -1484,8 +1555,16 @@ export const FlyMachineRootfs = /*@__PURE__*/ S.suspend(() =>
 }) as any as S.Schema<FlyMachineRootfs>;
 
 /** Accepts a string (new format) or a boolean (old format). For backward compatibility with older clients, the API continues to use booleans for "off" and "stop" in responses. * "off" or false - Do not autostop the Machine. * "stop" or true - Automatically stop the Machine. * "suspend" - Automatically suspend the Machine, falling back to a full stop if this is not possible. */
-export type FlyMachineServiceAutostop = "off" | "stop" | "suspend";
-export const FlyMachineServiceAutostop = S.String;
+export type FlyMachineServiceAutostopMode = "off" | "stop" | "suspend";
+export const FlyMachineServiceAutostopMode = S.String;
+
+/** Accepts off, stop, or suspend. For backward compatibility, responses encode off as false and stop as true. */
+export type FlyMachineServiceAutostop =
+  | FlyMachineServiceAutostopMode
+  | (string & {})
+  | boolean;
+export const FlyMachineServiceAutostop: S.Codec<FlyMachineServiceAutostop> =
+  /*@__PURE__*/ S.Union([FlyMachineServiceAutostopMode, S.Boolean]);
 
 export type FlyMachineServiceCheckHeadersList = Array<FlyMachineHTTPHeader>;
 export const FlyMachineServiceCheckHeadersList = /*@__PURE__*/ S.Array(
@@ -1692,7 +1771,7 @@ export const FlyMachineServicePortsList = /*@__PURE__*/ S.Array(
 export interface FlyMachineService {
   autostart?: boolean;
   /** Accepts a string (new format) or a boolean (old format). For backward compatibility with older clients, the API continues to use booleans for "off" and "stop" in responses. * "off" or false - Do not autostop the Machine. * "stop" or true - Automatically stop the Machine. * "suspend" - Automatically suspend the Machine, falling back to a full stop if this is not possible. */
-  autostop?: FlyMachineServiceAutostop | (string & {});
+  autostop?: FlyMachineServiceAutostop;
   /** An optional list of service checks */
   checks?: FlyMachineServiceChecksList;
   concurrency?: FlyMachineServiceConcurrency;
@@ -1903,6 +1982,11 @@ export const MachineEventsList = /*@__PURE__*/ S.Array(
   MachineEvent,
 ) as any as S.Schema<MachineEventsList>;
 
+export type MachineHostFeaturesList = Array<string>;
+export const MachineHostFeaturesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<MachineHostFeaturesList>;
+
 export type MachineHostStatus = "ok" | "unknown" | "unreachable";
 export const MachineHostStatus = S.String;
 
@@ -1948,11 +2032,12 @@ export interface Machine {
   cordoned?: boolean;
   created_at?: string;
   events?: MachineEventsList;
+  host_features?: MachineHostFeaturesList;
   host_status?: MachineHostStatus;
   id?: string;
   image_ref?: ImageRef;
   incomplete_config?: FlyMachineConfig;
-  /** InstanceID is unique for each version of the machine */
+  /** InstanceID is the same value as `version`. Deprecated: use `version`. */
   instance_id?: string;
   lease?: StrippedLease;
   name?: string;
@@ -1963,6 +2048,8 @@ export interface Machine {
   region?: string;
   state?: string;
   updated_at?: string;
+  /** Version is unique for each version of the machine. Pass it as `current_version` when updating the Machine to reject the update if the Machine has changed since this version. */
+  version?: string;
 }
 export const Machine = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
@@ -1971,6 +2058,7 @@ export const Machine = /*@__PURE__*/ S.suspend(() =>
     cordoned: S.optional(S.Boolean),
     created_at: S.optional(S.String),
     events: S.optional(MachineEventsList),
+    host_features: S.optional(MachineHostFeaturesList),
     host_status: S.optional(MachineHostStatus),
     id: S.optional(S.String),
     image_ref: S.optional(ImageRef),
@@ -1983,6 +2071,7 @@ export const Machine = /*@__PURE__*/ S.suspend(() =>
     region: S.optional(S.String),
     state: S.optional(S.String),
     updated_at: S.optional(S.String),
+    version: S.optional(S.String),
   }),
 ).annotate({ identifier: "Machine" }) as any as S.Schema<Machine>;
 
@@ -1994,13 +2083,16 @@ export interface CreateMachineLeaseRequest {
   description?: string;
   /** seconds lease will be valid */
   ttl?: number;
+  /** Existing lease nonce when refreshing; omit to acquire a new lease. Keep the nonce private. */
+  lease_nonce?: string;
 }
 export const CreateMachineLeaseRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     app_name: S.String.pipe(T.Label()),
     machine_id: S.String.pipe(T.Label()),
     description: S.optional(S.String),
-    ttl: S.optional(S.Number),
+    ttl: S.optional(S.Number.pipe(T.Query())),
+    lease_nonce: S.optional(S.String.pipe(T.Header("fly-machine-lease-nonce"))),
   }).pipe(
     T.Http({
       method: "POST",
@@ -2034,11 +2126,22 @@ export const Lease = /*@__PURE__*/ S.suspend(() =>
   }),
 ).annotate({ identifier: "Lease" }) as any as S.Schema<Lease>;
 
+export interface MachineLease {
+  status?: string;
+  data?: Lease;
+}
+export const MachineLease = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    status: S.optional(S.String),
+    data: S.optional(Lease),
+  }),
+).annotate({ identifier: "MachineLease" }) as any as S.Schema<MachineLease>;
+
 /** Postgres major version. */
 export type CreatePostgresRequestPgMajorVersion = "16" | "17";
 export const CreatePostgresRequestPgMajorVersion = S.String;
 
-/** Plan slug selecting CPU, memory, and disk sizing. */
+/** Plan slug selecting CPU, memory, and disk sizing. Matched case-insensitively. */
 export type CreatePostgresRequestPlan =
   | "basic"
   | "starter"
@@ -2056,11 +2159,11 @@ export interface CreatePostgresRequest {
   disk_size_gb?: number;
   /** Name for the cluster. A name is generated when omitted. */
   name?: string;
-  /** Slug of the organization that will own the cluster. */
+  /** Slug of the organization that will own the cluster, or "personal" for the caller's personal organization. */
   org_slug: string;
   /** Postgres major version. */
   pg_major_version?: CreatePostgresRequestPgMajorVersion | (string & {});
-  /** Plan slug selecting CPU, memory, and disk sizing. */
+  /** Plan slug selecting CPU, memory, and disk sizing. Matched case-insensitively. */
   plan: CreatePostgresRequestPlan | (string & {});
   /** Connection pooler mode. */
   pool_mode?: CreatePostgresRequestPoolMode | (string & {});
@@ -2195,7 +2298,7 @@ export interface PostgresCluster {
   cpus?: number;
   /** RFC 3339 creation timestamp. */
   created_at?: string;
-  /** Disk size in gigabytes. */
+  /** Disk size in gigabytes, for one replica. */
   disk_size_gb?: number;
   /** Connection endpoints. Populated once the cluster is ready. */
   endpoints?: PostgresClusterEndpoints;
@@ -2218,6 +2321,10 @@ export interface PostgresCluster {
   replicas?: number;
   /** Current lifecycle status. */
   status?: PostgresClusterStatus;
+  /** Storage provisioned, summed across the cluster's volumes and measured hourly. Null until first measured. */
+  storage_provisioned_bytes?: number | null;
+  /** Storage used, summed across the cluster's volumes and measured hourly. Null until first measured. */
+  storage_used_bytes?: number | null;
 }
 export const PostgresCluster = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
@@ -2237,6 +2344,8 @@ export const PostgresCluster = /*@__PURE__*/ S.suspend(() =>
     region: S.optional(S.String),
     replicas: S.optional(S.Number),
     status: S.optional(PostgresClusterStatus),
+    storage_provisioned_bytes: S.optional(S.NullOr(S.Number)),
+    storage_used_bytes: S.optional(S.NullOr(S.Number)),
   }),
 ).annotate({
   identifier: "PostgresCluster",
@@ -2338,7 +2447,7 @@ export const CreatePostgresBackupResponse = /*@__PURE__*/ S.suspend(() =>
 export interface CreatePostgresDatabaseRequest {
   /** Managed Postgres Cluster ID */
   postgres_cluster_id: string;
-  /** Name of the database to create. */
+  /** Name of the database to create. Must start and end with an alphanumeric character and may contain hyphens and underscores, up to 63 characters. */
   name: string;
 }
 export const CreatePostgresDatabaseRequest = /*@__PURE__*/ S.suspend(() =>
@@ -2391,7 +2500,7 @@ export interface CreatePostgresUserRequest {
   postgres_cluster_id: string;
   /** Role to grant the user. */
   role: CreatePostgresUserRequestRole | (string & {});
-  /** Name for the new user. */
+  /** Name for the new user. Must start and end with a lowercase alphanumeric character and may contain hyphens and underscores, up to 63 characters. */
   username: string;
 }
 export const CreatePostgresUserRequest = /*@__PURE__*/ S.suspend(() =>
@@ -2528,9 +2637,19 @@ export const CreateVolumeRequest = /*@__PURE__*/ S.suspend(() =>
   identifier: "CreateVolumeRequest",
 }) as any as S.Schema<CreateVolumeRequest>;
 
+export type VolumeHostFeaturesList = Array<string>;
+export const VolumeHostFeaturesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VolumeHostFeaturesList>;
+
 export type VolumeHostStatus = "ok" | "unknown" | "unreachable";
 export const VolumeHostStatus = S.String;
 
+export type VolumeRequiredHostFeaturesList = Array<string>;
+export const VolumeRequiredHostFeaturesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VolumeRequiredHostFeaturesList>;
+
 export type VolumeType = "local" | "cache";
 export const VolumeType = S.String;
 
@@ -2547,10 +2666,12 @@ export interface Volume {
   created_at?: string;
   encrypted?: boolean;
   fstype?: string;
+  host_features?: VolumeHostFeaturesList;
   host_status?: VolumeHostStatus;
   id?: string;
   name?: string;
   region?: string;
+  required_host_features?: VolumeRequiredHostFeaturesList;
   size_gb?: number;
   snapshot_retention?: number;
   state?: string;
@@ -2571,10 +2692,12 @@ export const Volume = /*@__PURE__*/ S.suspend(() =>
     created_at: S.optional(S.String),
     encrypted: S.optional(S.Boolean),
     fstype: S.optional(S.String),
+    host_features: S.optional(VolumeHostFeaturesList),
     host_status: S.optional(VolumeHostStatus),
     id: S.optional(S.String),
     name: S.optional(S.String),
     region: S.optional(S.String),
+    required_host_features: S.optional(VolumeRequiredHostFeaturesList),
     size_gb: S.optional(S.Number),
     snapshot_retention: S.optional(S.Number),
     state: S.optional(S.String),
@@ -2821,12 +2944,14 @@ export interface DeleteMachineRequest {
   machine_id: string;
   /** Force kill the machine if it's running */
   force?: boolean;
+  lease_nonce?: string;
 }
 export const DeleteMachineRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     app_name: S.String.pipe(T.Label()),
     machine_id: S.String.pipe(T.Label()),
     force: S.optional(S.Boolean.pipe(T.Query())),
+    lease_nonce: S.optional(S.String.pipe(T.Header("fly-machine-lease-nonce"))),
   }).pipe(
     T.Http({
       method: "DELETE",
@@ -3477,6 +3602,8 @@ export interface GetMachineRequest {
   app_name: string;
   /** Machine ID */
   machine_id: string;
+  /** 26-character Machine version ID; returns that version of the Machine instead of the current one */
+  version?: string;
   /** Include machine lease */
   include_leases?: boolean;
 }
@@ -3484,6 +3611,7 @@ export const GetMachineRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     app_name: S.String.pipe(T.Label()),
     machine_id: S.String.pipe(T.Label()),
+    version: S.optional(S.String.pipe(T.Query())),
     include_leases: S.optional(S.Boolean.pipe(T.Query())),
   }).pipe(
     T.Http({
@@ -3970,6 +4098,7 @@ export interface IPAssignment {
   created_at?: string;
   egress?: boolean;
   ip?: string;
+  network?: IPAssignmentNetwork | null;
   region?: string;
   service_name?: string;
   shared?: boolean;
@@ -3980,6 +4109,7 @@ export const IPAssignment = /*@__PURE__*/ S.suspend(() =>
     created_at: S.optional(S.String),
     egress: S.optional(S.Boolean),
     ip: S.optional(S.String),
+    network: S.optional(S.NullOr(IPAssignmentNetwork)),
     region: S.optional(S.String),
     service_name: S.optional(S.String),
     shared: S.optional(S.Boolean),
@@ -4165,6 +4295,10 @@ export interface ListMachinesRequest {
   summary?: boolean;
   /** Filter by a machine metadata key and exact value. Replace {key} with the metadata key, for example metadata.foo=bar. Specify multiple metadata filters to require all matches. */
   metadata__key_?: string;
+  /** Value of the fly-next-cursor response header from the previous page. Requires limit. */
+  cursor?: string;
+  /** The number of machines to fetch (must be between 1 and 1000). Providing a limit enables pagination. This limit is advisory; responses may be shorter, or even empty, even when more machines remain. */
+  limit?: number;
 }
 export const ListMachinesRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
@@ -4175,6 +4309,8 @@ export const ListMachinesRequest = /*@__PURE__*/ S.suspend(() =>
     state: S.optional(S.String.pipe(T.Query())),
     summary: S.optional(S.Boolean.pipe(T.Query())),
     metadata__key_: S.optional(S.String.pipe(T.Query("metadata.{key}"))),
+    cursor: S.optional(S.String.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
   }).pipe(
     T.Http({ method: "GET", uri: "/v1/apps/{app_name}/machines", code: 200 }),
   ),
@@ -4353,7 +4489,7 @@ export const ListMachineVersionsResponse = /*@__PURE__*/ S.suspend(() =>
 }) as any as S.Schema<ListMachineVersionsResponse>;
 
 export interface ListPostgresRequest {
-  /** Fly Organization Slug */
+  /** Fly Organization Slug, or 'personal' for the caller's personal organization */
   org_slug: string;
   /** Include deleted clusters */
   include_deleted?: boolean;
@@ -4560,20 +4696,21 @@ export const ListPostgresExtensionsRequest = /*@__PURE__*/ S.suspend(() =>
   identifier: "ListPostgresExtensionsRequest",
 }) as any as S.Schema<ListPostgresExtensionsRequest>;
 
-export interface PostgresInstalledExtension {
+/** Installation details, or null when the extension is not installed. */
+export interface PostgresExtensionInstalled {
   /** Schema the extension is installed into. */
   schema?: string;
   /** Installed version. */
   version?: string;
 }
-export const PostgresInstalledExtension = /*@__PURE__*/ S.suspend(() =>
+export const PostgresExtensionInstalled = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     schema: S.optional(S.String),
     version: S.optional(S.String),
   }),
 ).annotate({
-  identifier: "PostgresInstalledExtension",
-}) as any as S.Schema<PostgresInstalledExtension>;
+  identifier: "PostgresExtensionInstalled",
+}) as any as S.Schema<PostgresExtensionInstalled>;
 
 export interface PostgresExtension {
   /** Default version installed when enabled. */
@@ -4581,7 +4718,7 @@ export interface PostgresExtension {
   /** Human-readable description. */
   description?: string;
   /** Installation details, or null when the extension is not installed. */
-  installed?: PostgresInstalledExtension;
+  installed?: PostgresExtensionInstalled | null;
   /** Extension name. */
   name?: string;
   /** Whether this is a system extension that cannot be disabled. */
@@ -4591,7 +4728,7 @@ export const PostgresExtension = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     default_version: S.optional(S.String),
     description: S.optional(S.String),
-    installed: S.optional(PostgresInstalledExtension),
+    installed: S.optional(S.NullOr(PostgresExtensionInstalled)),
     name: S.optional(S.String),
     system: S.optional(S.Boolean),
   }),
@@ -4835,9 +4972,19 @@ export const ListVolumesOrgRequest = /*@__PURE__*/ S.suspend(() =>
   identifier: "ListVolumesOrgRequest",
 }) as any as S.Schema<ListVolumesOrgRequest>;
 
+export type OrgVolumeHostFeaturesList = Array<string>;
+export const OrgVolumeHostFeaturesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<OrgVolumeHostFeaturesList>;
+
 export type OrgVolumeHostStatus = "ok" | "unknown" | "unreachable";
 export const OrgVolumeHostStatus = S.String;
 
+export type OrgVolumeRequiredHostFeaturesList = Array<string>;
+export const OrgVolumeRequiredHostFeaturesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<OrgVolumeRequiredHostFeaturesList>;
+
 export type OrgVolumeType = "local" | "cache";
 export const OrgVolumeType = S.String;
 
@@ -4855,10 +5002,12 @@ export interface OrgVolume {
   created_at?: string;
   encrypted?: boolean;
   fstype?: string;
+  host_features?: OrgVolumeHostFeaturesList;
   host_status?: OrgVolumeHostStatus;
   id?: string;
   name?: string;
   region?: string;
+  required_host_features?: OrgVolumeRequiredHostFeaturesList;
   size_gb?: number;
   snapshot_retention?: number;
   state?: string;
@@ -4881,10 +5030,12 @@ export const OrgVolume = /*@__PURE__*/ S.suspend(() =>
     created_at: S.optional(S.String),
     encrypted: S.optional(S.Boolean),
     fstype: S.optional(S.String),
+    host_features: S.optional(OrgVolumeHostFeaturesList),
     host_status: S.optional(OrgVolumeHostStatus),
     id: S.optional(S.String),
     name: S.optional(S.String),
     region: S.optional(S.String),
+    required_host_features: S.optional(OrgVolumeRequiredHostFeaturesList),
     size_gb: S.optional(S.Number),
     snapshot_retention: S.optional(S.Number),
     state: S.optional(S.String),
@@ -4921,11 +5072,14 @@ export interface MachinesReleaseLeaseRequest {
   app_name: string;
   /** Machine ID */
   machine_id: string;
+  /** Nonce of the lease to release. Keep the nonce private. */
+  lease_nonce: string;
 }
 export const MachinesReleaseLeaseRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     app_name: S.String.pipe(T.Label()),
     machine_id: S.String.pipe(T.Label()),
+    lease_nonce: S.String.pipe(T.Header("fly-machine-lease-nonce")),
   }).pipe(
     T.Http({
       method: "DELETE",
@@ -4986,6 +5140,156 @@ export const PatchMachineMetadataResponse = /*@__PURE__*/ S.suspend(() =>
   identifier: "PatchMachineMetadataResponse",
 }) as any as S.Schema<PatchMachineMetadataResponse>;
 
+export interface PostgresQueriesActiveRequest {
+  /** Managed Postgres Cluster ID */
+  postgres_cluster_id: string;
+  /** Database to inspect (must not be empty or whitespace-only) */
+  database: string;
+}
+export const PostgresQueriesActiveRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    postgres_cluster_id: S.String.pipe(T.Label()),
+    database: S.String.pipe(T.Query()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/postgres/{postgres_cluster_id}/queries/active",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PostgresQueriesActiveRequest",
+}) as any as S.Schema<PostgresQueriesActiveRequest>;
+
+export interface PostgresActiveQuery {
+  /** Application connected to the backend. */
+  application_name?: string;
+  /** Client address. */
+  client?: string;
+  /** Database name. */
+  database?: string;
+  /** Query duration in seconds. */
+  duration_seconds?: number;
+  /** Process ID of the backend running the query. */
+  pid?: number;
+  /** Full query text. */
+  query?: string;
+  /** Current backend state. */
+  state?: string;
+  /** Time spent in the current state, in seconds. */
+  state_duration_seconds?: number;
+  /** User running the query. */
+  user?: string;
+  /** Event the backend is waiting for. */
+  wait_event?: string;
+  /** Type of event the backend is waiting for. */
+  wait_event_type?: string;
+}
+export const PostgresActiveQuery = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    application_name: S.optional(S.String),
+    client: S.optional(S.String),
+    database: S.optional(S.String),
+    duration_seconds: S.optional(S.Number),
+    pid: S.optional(S.Number),
+    query: S.optional(S.String),
+    state: S.optional(S.String),
+    state_duration_seconds: S.optional(S.Number),
+    user: S.optional(S.String),
+    wait_event: S.optional(S.String),
+    wait_event_type: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "PostgresActiveQuery",
+}) as any as S.Schema<PostgresActiveQuery>;
+
+export type ListPostgresActiveQueriesResponseDataList =
+  Array<PostgresActiveQuery>;
+export const ListPostgresActiveQueriesResponseDataList = /*@__PURE__*/ S.Array(
+  PostgresActiveQuery,
+) as any as S.Schema<ListPostgresActiveQueriesResponseDataList>;
+
+export interface ListPostgresActiveQueriesResponse {
+  data?: ListPostgresActiveQueriesResponseDataList;
+}
+export const ListPostgresActiveQueriesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(ListPostgresActiveQueriesResponseDataList),
+  }),
+).annotate({
+  identifier: "ListPostgresActiveQueriesResponse",
+}) as any as S.Schema<ListPostgresActiveQueriesResponse>;
+
+export interface PostgresQueriesSlowRequest {
+  /** Managed Postgres Cluster ID */
+  postgres_cluster_id: string;
+  /** Metrics lookback in seconds */
+  range?: number;
+}
+export const PostgresQueriesSlowRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    postgres_cluster_id: S.String.pipe(T.Label()),
+    range: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/postgres/{postgres_cluster_id}/queries/slow",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PostgresQueriesSlowRequest",
+}) as any as S.Schema<PostgresQueriesSlowRequest>;
+
+export interface PostgresSlowQuery {
+  /** Cumulative number of executions. */
+  calls?: number;
+  /** Database name. */
+  database?: string;
+  /** Maximum execution time in seconds. */
+  max_exec_time_seconds?: number;
+  /** Mean execution time in seconds. */
+  mean_exec_time_seconds?: number;
+  /** Full query pattern. */
+  query?: string;
+  /** Query identifier. */
+  query_id?: string;
+  /** Cumulative total execution time in seconds. */
+  total_exec_time_seconds?: number;
+  /** User running the query. */
+  user?: string;
+}
+export const PostgresSlowQuery = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    calls: S.optional(S.Number),
+    database: S.optional(S.String),
+    max_exec_time_seconds: S.optional(S.Number),
+    mean_exec_time_seconds: S.optional(S.Number),
+    query: S.optional(S.String),
+    query_id: S.optional(S.String),
+    total_exec_time_seconds: S.optional(S.Number),
+    user: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "PostgresSlowQuery",
+}) as any as S.Schema<PostgresSlowQuery>;
+
+export type ListPostgresSlowQueriesResponseDataList = Array<PostgresSlowQuery>;
+export const ListPostgresSlowQueriesResponseDataList = /*@__PURE__*/ S.Array(
+  PostgresSlowQuery,
+) as any as S.Schema<ListPostgresSlowQueriesResponseDataList>;
+
+export interface ListPostgresSlowQueriesResponse {
+  data?: ListPostgresSlowQueriesResponseDataList;
+}
+export const ListPostgresSlowQueriesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(ListPostgresSlowQueriesResponseDataList),
+  }),
+).annotate({
+  identifier: "ListPostgresSlowQueriesResponse",
+}) as any as S.Schema<ListPostgresSlowQueriesResponse>;
+
 export interface PostgresUsersCredentialsRequest {
   /** Managed Postgres Cluster ID */
   postgres_cluster_id: string;
@@ -5122,6 +5426,7 @@ export interface RestartMachineRequest {
   timeout?: string;
   /** Unix signal name */
   signal?: RestartMachineRequestSignal | (string & {});
+  lease_nonce?: string;
 }
 export const RestartMachineRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
@@ -5129,6 +5434,7 @@ export const RestartMachineRequest = /*@__PURE__*/ S.suspend(() =>
     machine_id: S.String.pipe(T.Label()),
     timeout: S.optional(S.String.pipe(T.Query())),
     signal: S.optional(RestartMachineRequestSignal.pipe(T.Query())),
+    lease_nonce: S.optional(S.String.pipe(T.Header("fly-machine-lease-nonce"))),
   }).pipe(
     T.Http({
       method: "POST",
@@ -5351,11 +5657,13 @@ export interface StartMachineRequest {
   app_name: string;
   /** Machine ID */
   machine_id: string;
+  lease_nonce?: string;
 }
 export const StartMachineRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     app_name: S.String.pipe(T.Label()),
     machine_id: S.String.pipe(T.Label()),
+    lease_nonce: S.optional(S.String.pipe(T.Header("fly-machine-lease-nonce"))),
   }).pipe(
     T.Http({
       method: "POST",
@@ -5391,6 +5699,7 @@ export interface StopMachineRequest {
   machine_id: string;
   signal?: StopMachineRequestSignal | (string & {});
   timeout?: string;
+  lease_nonce?: string;
 }
 export const StopMachineRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
@@ -5398,6 +5707,7 @@ export const StopMachineRequest = /*@__PURE__*/ S.suspend(() =>
     machine_id: S.String.pipe(T.Label()),
     signal: S.optional(StopMachineRequestSignal),
     timeout: S.optional(S.String),
+    lease_nonce: S.optional(S.String.pipe(T.Header("fly-machine-lease-nonce"))),
   }).pipe(
     T.Http({
       method: "POST",
@@ -5421,11 +5731,13 @@ export interface SuspendMachineRequest {
   app_name: string;
   /** Machine ID */
   machine_id: string;
+  lease_nonce?: string;
 }
 export const SuspendMachineRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     app_name: S.String.pipe(T.Label()),
     machine_id: S.String.pipe(T.Label()),
+    lease_nonce: S.optional(S.String.pipe(T.Header("fly-machine-lease-nonce"))),
   }).pipe(
     T.Http({
       method: "POST",
@@ -5449,11 +5761,13 @@ export interface UncordonMachineRequest {
   app_name: string;
   /** Machine ID */
   machine_id: string;
+  lease_nonce?: string;
 }
 export const UncordonMachineRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     app_name: S.String.pipe(T.Label()),
     machine_id: S.String.pipe(T.Label()),
+    lease_nonce: S.optional(S.String.pipe(T.Header("fly-machine-lease-nonce"))),
   }).pipe(
     T.Http({
       method: "POST",
@@ -5479,6 +5793,7 @@ export interface UpdateMachineRequest {
   machine_id: string;
   /** An object defining the Machine configuration */
   config?: FlyMachineConfig;
+  /** CurrentVersion is an optional optimistic-concurrency guard: the Machine's `version`, as returned by create, get or a previous update. When set and it is no longer the Machine's current version, the update is rejected with 409 Conflict and nothing changes. Omit it to update unconditionally. */
   current_version?: string;
   lease_ttl?: number;
   min_secrets_version?: number;
@@ -5489,6 +5804,7 @@ export interface UpdateMachineRequest {
   skip_launch?: boolean;
   skip_secrets?: boolean;
   skip_service_registration?: boolean;
+  lease_nonce?: string;
 }
 export const UpdateMachineRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
@@ -5503,6 +5819,7 @@ export const UpdateMachineRequest = /*@__PURE__*/ S.suspend(() =>
     skip_launch: S.optional(S.Boolean),
     skip_secrets: S.optional(S.Boolean),
     skip_service_registration: S.optional(S.Boolean),
+    lease_nonce: S.optional(S.String.pipe(T.Header("fly-machine-lease-nonce"))),
   }).pipe(
     T.Http({
       method: "POST",
@@ -5514,48 +5831,6 @@ export const UpdateMachineRequest = /*@__PURE__*/ S.suspend(() =>
   identifier: "UpdateMachineRequest",
 }) as any as S.Schema<UpdateMachineRequest>;
 
-export type UpdateMachineMetadataRequestMetadataMap = {
-  [key: string]: string | undefined;
-};
-export const UpdateMachineMetadataRequestMetadataMap = /*@__PURE__*/ S.Record(
-  S.String,
-  S.String,
-) as any as S.Schema<UpdateMachineMetadataRequestMetadataMap>;
-
-export interface UpdateMachineMetadataRequest {
-  /** Fly App Name */
-  app_name: string;
-  /** Machine ID */
-  machine_id: string;
-  machine_version?: string;
-  metadata?: UpdateMachineMetadataRequestMetadataMap;
-  updated_at?: string;
-}
-export const UpdateMachineMetadataRequest = /*@__PURE__*/ S.suspend(() =>
-  S.Struct({
-    app_name: S.String.pipe(T.Label()),
-    machine_id: S.String.pipe(T.Label()),
-    machine_version: S.optional(S.String),
-    metadata: S.optional(UpdateMachineMetadataRequestMetadataMap),
-    updated_at: S.optional(S.String),
-  }).pipe(
-    T.Http({
-      method: "PUT",
-      uri: "/v1/apps/{app_name}/machines/{machine_id}/metadata",
-      code: 200,
-    }),
-  ),
-).annotate({
-  identifier: "UpdateMachineMetadataRequest",
-}) as any as S.Schema<UpdateMachineMetadataRequest>;
-
-export interface UpdateMachineMetadataResponse {}
-export const UpdateMachineMetadataResponse = /*@__PURE__*/ S.suspend(() =>
-  S.Struct({}),
-).annotate({
-  identifier: "UpdateMachineMetadataResponse",
-}) as any as S.Schema<UpdateMachineMetadataResponse>;
-
 /** New role for the user. */
 export type UpdatePostgresUserRoleRequestRole =
   | "schema_admin"
@@ -5849,6 +6124,7 @@ export type CordonMachineError =
   | BadRequest
   | Forbidden
   | NotFound
+  | Conflict
   | FlyIoOpError;
 /** Cordon Machine “Cordoning” a Machine refers to disabling its services, so the Fly Proxy won’t route requests to it. In flyctl this is used by blue/green deployments; one set of Machines is started up with services disabled, and when they are all healthy, the services are enabled on the new Machines and disabled on the old ones. */
 export const cordonMachine: API.OperationMethod<
@@ -5859,7 +6135,7 @@ export const cordonMachine: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: CordonMachineRequest,
   output: CordonMachineResponse,
-  errors: [BadRequest, Forbidden, NotFound],
+  errors: [BadRequest, Forbidden, NotFound, Conflict],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -5951,6 +6227,7 @@ export type CreateAppIPAssignmentError =
   | Forbidden
   | NotFound
   | Conflict
+  | NetworkNotFound
   | FlyIoOpError;
 /** Assign new IP address to app */
 export const createAppIPAssignment: API.OperationMethod<
@@ -5961,7 +6238,7 @@ export const createAppIPAssignment: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: CreateAppIPAssignmentRequest,
   output: AssignIPResponse,
-  errors: [BadRequest, Forbidden, NotFound, Conflict],
+  errors: [BadRequest, Forbidden, NotFound, Conflict, NetworkNotFound],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -5990,17 +6267,18 @@ export type CreateMachineLeaseError =
   | BadRequest
   | Forbidden
   | NotFound
+  | Conflict
   | FlyIoOpError;
 /** Create Lease Create a lease for a specific Machine within an app using the details provided in the request body. Machine leases can be used to obtain an exclusive lock on modifying a Machine. */
 export const createMachineLease: API.OperationMethod<
   CreateMachineLeaseRequest,
-  Lease,
+  MachineLease,
   CreateMachineLeaseError,
   FlyIoOpContext
 > = /*@__PURE__*/ API.make(() => ({
   input: CreateMachineLeaseRequest,
-  output: Lease,
-  errors: [BadRequest, Forbidden, NotFound],
+  output: MachineLease,
+  errors: [BadRequest, Forbidden, NotFound, Conflict],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -6010,7 +6288,7 @@ export type CreatePostgresError =
   | NotFound
   | UnprocessableEntity
   | FlyIoOpError;
-/** Create Postgres Cluster Create a Managed Postgres cluster for the organization named in the request body. Provisioning is asynchronous, and a name is generated when one is not supplied. */
+/** Create Postgres Cluster Create a Managed Postgres cluster for the organization named in the request body. Provisioning is asynchronous: poll `GET /v1/postgres/{id}` until `status == ready` before calling database, user, extension, or credential endpoints. */
 export const createPostgres: API.OperationMethod<
   CreatePostgresRequest,
   ShowPostgresClusterResponse,
@@ -6025,7 +6303,7 @@ export const createPostgres: API.OperationMethod<
 }));
 
 export type CreatePostgresAttachmentError = NotFound | FlyIoOpError;
-/** Attach Cluster to App Attach a specific cluster to a Fly app. The attachment is created if it does not already exist. */
+/** Attach Cluster to App Record an attachment between a cluster and a Fly app. This endpoint records the relationship but does not set DATABASE_URL or other app secrets; configure the connection string separately. The attachment is created if it does not already exist. */
 export const createPostgresAttachment: API.OperationMethod<
   CreatePostgresAttachmentRequest,
   CreatePostgresAttachmentResponse,
@@ -6370,7 +6648,12 @@ export const deleteSecretKey: API.OperationMethod<
   retry: Retry.Retry,
 }));
 
-export type DeleteVolumeError = Forbidden | NotFound | Conflict | FlyIoOpError;
+export type DeleteVolumeError =
+  | Forbidden
+  | NotFound
+  | Conflict
+  | VolumeAttached
+  | FlyIoOpError;
 /** Destroy Volume Delete a specific volume within an app by volume ID. */
 export const deleteVolume: API.OperationMethod<
   DeleteVolumeRequest,
@@ -6380,7 +6663,7 @@ export const deleteVolume: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: DeleteVolumeRequest,
   output: Volume,
-  errors: [Forbidden, NotFound, Conflict],
+  errors: [Forbidden, NotFound, Conflict, VolumeAttached],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -6443,7 +6726,12 @@ export const encryptSecretKey: API.OperationMethod<
   retry: Retry.Retry,
 }));
 
-export type ExecMachineError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+export type ExecMachineError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | Conflict
+  | FlyIoOpError;
 /** Execute Command Execute a command on a specific Machine and return the raw command output bytes. */
 export const execMachine: API.OperationMethod<
   ExecMachineRequest,
@@ -6453,7 +6741,7 @@ export const execMachine: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: ExecMachineRequest,
   output: Flydv1ExecResponse,
-  errors: [BadRequest, Forbidden, NotFound],
+  errors: [BadRequest, Forbidden, NotFound, Conflict],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -6581,12 +6869,12 @@ export type GetMachineLeaseError = Forbidden | NotFound | FlyIoOpError;
 /** Get Lease Retrieve the current lease of a specific Machine within an app. Machine leases can be used to obtain an exclusive lock on modifying a Machine. */
 export const getMachineLease: API.OperationMethod<
   GetMachineLeaseRequest,
-  Lease,
+  MachineLease,
   GetMachineLeaseError,
   FlyIoOpContext
 > = /*@__PURE__*/ API.make(() => ({
   input: GetMachineLeaseRequest,
-  output: Lease,
+  output: MachineLease,
   errors: [Forbidden, NotFound],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
@@ -6851,7 +7139,11 @@ export const listMachineVersions: API.OperationMethod<
   retry: Retry.Retry,
 }));
 
-export type ListPostgresError = NotFound | UnprocessableEntity | FlyIoOpError;
+export type ListPostgresError =
+  | BadRequest
+  | NotFound
+  | UnprocessableEntity
+  | FlyIoOpError;
 /** List Postgres Clusters List Managed Postgres clusters for an organization. */
 export const listPostgres: API.OperationMethod<
   ListPostgresRequest,
@@ -6861,7 +7153,7 @@ export const listPostgres: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: ListPostgresRequest,
   output: ListPostgresClustersResponse,
-  errors: [NotFound, UnprocessableEntity],
+  errors: [BadRequest, NotFound, UnprocessableEntity],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -7016,8 +7308,12 @@ export const machinesReleaseLease: API.OperationMethod<
   retry: Retry.Retry,
 }));
 
-export type PatchMachineMetadataError = BadRequest | FlyIoOpError;
-/** Update Metadata (set/remove multiple keys) Update multiple metadata keys at once. Null values and empty strings remove keys. + If `machine_version` is provided and no longer matches the current machine version, returns 412 Precondition Failed. */
+export type PatchMachineMetadataError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | FlyIoOpError;
+/** Update Metadata (set/remove multiple keys) Update multiple metadata keys at once. Keys that are not in the request are left untouched. Null values and empty strings remove keys. + If `machine_version` is provided and no longer matches the current machine version, returns 412 Precondition Failed. */
 export const patchMachineMetadata: API.OperationMethod<
   PatchMachineMetadataRequest,
   PatchMachineMetadataResponse,
@@ -7026,7 +7322,43 @@ export const patchMachineMetadata: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: PatchMachineMetadataRequest,
   output: PatchMachineMetadataResponse,
-  errors: [BadRequest],
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: FlyIoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostgresQueriesActiveError =
+  | NotFound
+  | UnprocessableEntity
+  | FlyIoOpError;
+/** List Active Queries List active queries in the supplied database. The database query parameter is required and must not be empty or whitespace-only. Returns full query text and durations in seconds. */
+export const postgresQueriesActive: API.OperationMethod<
+  PostgresQueriesActiveRequest,
+  ListPostgresActiveQueriesResponse,
+  PostgresQueriesActiveError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostgresQueriesActiveRequest,
+  output: ListPostgresActiveQueriesResponse,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: FlyIoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostgresQueriesSlowError =
+  | NotFound
+  | UnprocessableEntity
+  | FlyIoOpError;
+/** List Slow Queries List the top 20 queries by cumulative total execution time, excluding the postgres database. Uses the latest available metrics within the lookback range; statistics are cumulative PostgreSQL counters, not deltas over that range. Returns full query text and execution times in seconds. */
+export const postgresQueriesSlow: API.OperationMethod<
+  PostgresQueriesSlowRequest,
+  ListPostgresSlowQueriesResponse,
+  PostgresQueriesSlowError,
+  FlyIoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostgresQueriesSlowRequest,
+  output: ListPostgresSlowQueriesResponse,
+  errors: [NotFound, UnprocessableEntity],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -7110,6 +7442,7 @@ export type RestartMachineError =
   | BadRequest
   | Forbidden
   | NotFound
+  | Conflict
   | FlyIoOpError;
 /** Restart Machine Restart a specific Machine within an app, with an optional timeout parameter. */
 export const restartMachine: API.OperationMethod<
@@ -7120,7 +7453,7 @@ export const restartMachine: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: RestartMachineRequest,
   output: RestartMachineResponse,
-  errors: [BadRequest, Forbidden, NotFound],
+  errors: [BadRequest, Forbidden, NotFound, Conflict],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -7246,6 +7579,7 @@ export type StartMachineError =
   | NotFound
   | Conflict
   | MachineStartFromCreatedState
+  | MachineReplacing
   | FlyIoOpError;
 /** Start Machine Start a specific Machine within an app. */
 export const startMachine: API.OperationMethod<
@@ -7262,12 +7596,18 @@ export const startMachine: API.OperationMethod<
     NotFound,
     Conflict,
     MachineStartFromCreatedState,
+    MachineReplacing,
   ],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
 
-export type StopMachineError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+export type StopMachineError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | Conflict
+  | FlyIoOpError;
 /** Stop Machine Stop a specific Machine within an app, with an optional request body to specify signal and timeout. */
 export const stopMachine: API.OperationMethod<
   StopMachineRequest,
@@ -7277,7 +7617,7 @@ export const stopMachine: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: StopMachineRequest,
   output: StopMachineResponse,
-  errors: [BadRequest, Forbidden, NotFound],
+  errors: [BadRequest, Forbidden, NotFound, Conflict],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -7286,6 +7626,7 @@ export type SuspendMachineError =
   | BadRequest
   | Forbidden
   | NotFound
+  | Conflict
   | FlyIoOpError;
 /** Suspend Machine Suspend a specific Machine within an app. The next start operation will attempt (but is not guaranteed) to resume the Machine from a snapshot taken at suspension time, rather than performing a cold boot. */
 export const suspendMachine: API.OperationMethod<
@@ -7296,7 +7637,7 @@ export const suspendMachine: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: SuspendMachineRequest,
   output: SuspendMachineResponse,
-  errors: [BadRequest, Forbidden, NotFound],
+  errors: [BadRequest, Forbidden, NotFound, Conflict],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -7305,6 +7646,7 @@ export type UncordonMachineError =
   | BadRequest
   | Forbidden
   | NotFound
+  | Conflict
   | FlyIoOpError;
 /** Uncordon Machine “Cordoning” a Machine refers to disabling its services, so the Fly Proxy won’t route requests to it. In flyctl this is used by blue/green deployments; one set of Machines is started up with services disabled, and when they are all healthy, the services are enabled on the new Machines and disabled on the old ones. */
 export const uncordonMachine: API.OperationMethod<
@@ -7315,7 +7657,7 @@ export const uncordonMachine: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: UncordonMachineRequest,
   output: UncordonMachineResponse,
-  errors: [BadRequest, Forbidden, NotFound],
+  errors: [BadRequest, Forbidden, NotFound, Conflict],
   protocol: FlyIoProtocol,
   retry: Retry.Retry,
 }));
@@ -7340,25 +7682,6 @@ export const updateMachine: API.OperationMethod<
   retry: Retry.Retry,
 }));
 
-export type UpdateMachineMetadataError =
-  | BadRequest
-  | Forbidden
-  | NotFound
-  | FlyIoOpError;
-/** Update Metadata (set/remove multiple keys) Update multiple metadata keys at once. Null values and empty strings remove keys. + If `machine_version` is provided and no longer matches the current machine version, returns 412 Precondition Failed. */
-export const updateMachineMetadata: API.OperationMethod<
-  UpdateMachineMetadataRequest,
-  UpdateMachineMetadataResponse,
-  UpdateMachineMetadataError,
-  FlyIoOpContext
-> = /*@__PURE__*/ API.make(() => ({
-  input: UpdateMachineMetadataRequest,
-  output: UpdateMachineMetadataResponse,
-  errors: [BadRequest, Forbidden, NotFound],
-  protocol: FlyIoProtocol,
-  retry: Retry.Retry,
-}));
-
 export type UpdatePostgresUserRoleError =
   | BadRequest
   | NotFound