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

package/lib/services/machines.d.ts

@@ -1,8 +1,13 @@
-import * as S from "@distilled.cloud/core/schema";
 import * as API from "@distilled.cloud/core/api";
-import { type FlyIoOpError, type FlyIoOpContext } from "../protocol.ts";
+import * as S from "@distilled.cloud/core/schema";
 import { BadRequest, Conflict, Forbidden, GatewayTimeout, NotFound, UnprocessableEntity } from "../errors.ts";
+import { type FlyIoOpError, type FlyIoOpContext } from "../protocol.ts";
 export type { FlyIoOpError, FlyIoOpContext };
+declare const MachineReplacing_base: S.Class<MachineReplacing, S.TaggedStruct<"MachineReplacing", {
+    readonly message: any;
+}>, import("effect/Cause").YieldableError>;
+export declare class MachineReplacing extends /*@__PURE__*/ MachineReplacing_base {
+}
 declare const MachineStartFromCreatedState_base: S.Class<MachineStartFromCreatedState, S.TaggedStruct<"MachineStartFromCreatedState", {
     readonly message: any;
 }>, import("effect/Cause").YieldableError>;
@@ -13,6 +18,16 @@ declare const MachineWaitTimeout_base: S.Class<MachineWaitTimeout, S.TaggedStruc
 }>, import("effect/Cause").YieldableError>;
 export declare class MachineWaitTimeout extends /*@__PURE__*/ MachineWaitTimeout_base {
 }
+declare const NetworkNotFound_base: S.Class<NetworkNotFound, S.TaggedStruct<"NetworkNotFound", {
+    readonly message: any;
+}>, import("effect/Cause").YieldableError>;
+export declare class NetworkNotFound extends /*@__PURE__*/ NetworkNotFound_base {
+}
+declare const VolumeAttached_base: S.Class<VolumeAttached, S.TaggedStruct<"VolumeAttached", {
+    readonly message: any;
+}>, import("effect/Cause").YieldableError>;
+export declare class VolumeAttached extends /*@__PURE__*/ VolumeAttached_base {
+}
 export interface AuthenticateTokenRequest {
     header?: string;
 }
@@ -216,6 +231,7 @@ export interface CordonMachineRequest {
     app_name: string;
     /** Machine ID */
     machine_id: string;
+    lease_nonce?: string;
 }
 export declare const CordonMachineRequest: S.Schema<CordonMachineRequest>;
 export interface CordonMachineResponse {
@@ -223,12 +239,16 @@ export interface CordonMachineResponse {
 export declare const CordonMachineResponse: S.Schema<CordonMachineResponse>;
 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;
 }
 export declare const CreateAppRequest: S.Schema<CreateAppRequest>;
 export interface CreateAppResponse {
+    created_at?: number;
+    id?: string;
 }
 export declare const CreateAppResponse: S.Schema<CreateAppResponse>;
 export interface CreateAppAcmeCertificateRequest {
@@ -290,12 +310,20 @@ export interface IPPair {
     v6?: string;
 }
 export declare const IPPair: 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 declare const IPAssignmentNetwork: 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;
@@ -471,16 +499,14 @@ export declare const FlyContainerHealthcheck: S.Schema<FlyContainerHealthcheck>;
 /** Healthchecks determine the health of your containers. Healthchecks can use HTTP, TCP or an Exec command. */
 export type FlyContainerConfigHealthchecksList = Array<FlyContainerHealthcheck>;
 export declare const FlyContainerConfigHealthchecksList: 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 declare const FlyMachineRestartPolicy: any;
 /** 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 declare const FlyMachineRestart: S.Schema<FlyMachineRestart>;
@@ -523,7 +549,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;
@@ -576,6 +602,8 @@ export declare const FlyMachineGuestKernelArgsList: S.Schema<FlyMachineGuestKern
 /** Deprecated: use MachineConfig.Rootfs instead */
 export type FlyMachineGuestPersistRootfs = "never" | "always" | "restart";
 export declare const FlyMachineGuestPersistRootfs: any;
+export type FlyMachineGuestRequiredHostFeaturesList = Array<string>;
+export declare const FlyMachineGuestRequiredHostFeaturesList: S.Schema<FlyMachineGuestRequiredHostFeaturesList>;
 export interface FlyMachineGuest {
     cpu_kind?: string;
     cpus?: number;
@@ -587,6 +615,7 @@ export interface FlyMachineGuest {
     memory_mb?: number;
     /** Deprecated: use MachineConfig.Rootfs instead */
     persist_rootfs?: FlyMachineGuestPersistRootfs | (string & {});
+    required_host_features?: FlyMachineGuestRequiredHostFeaturesList;
 }
 export declare const FlyMachineGuest: S.Schema<FlyMachineGuest>;
 export type FlyMachineInitCmdList = Array<string>;
@@ -618,8 +647,12 @@ export interface FlyMachineMetrics {
 export declare const FlyMachineMetrics: S.Schema<FlyMachineMetrics>;
 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;
@@ -669,8 +702,11 @@ export interface FlyMachineRootfs {
 }
 export declare const FlyMachineRootfs: 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 declare const FlyMachineServiceAutostop: any;
+export type FlyMachineServiceAutostopMode = "off" | "stop" | "suspend";
+export declare const FlyMachineServiceAutostopMode: any;
+/** Accepts off, stop, or suspend. For backward compatibility, responses encode off as false and stop as true. */
+export type FlyMachineServiceAutostop = FlyMachineServiceAutostopMode | (string & {}) | boolean;
+export declare const FlyMachineServiceAutostop: S.Codec<FlyMachineServiceAutostop>;
 export type FlyMachineServiceCheckHeadersList = Array<FlyMachineHTTPHeader>;
 export declare const FlyMachineServiceCheckHeadersList: S.Schema<FlyMachineServiceCheckHeadersList>;
 export interface FlyMachineServiceCheck {
@@ -771,7 +807,7 @@ export declare const FlyMachineServicePortsList: S.Schema<FlyMachineServicePorts
 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;
@@ -873,6 +909,8 @@ export interface MachineEvent {
 export declare const MachineEvent: S.Schema<MachineEvent>;
 export type MachineEventsList = Array<MachineEvent>;
 export declare const MachineEventsList: S.Schema<MachineEventsList>;
+export type MachineHostFeaturesList = Array<string>;
+export declare const MachineHostFeaturesList: S.Schema<MachineHostFeaturesList>;
 export type MachineHostStatus = "ok" | "unknown" | "unreachable";
 export declare const MachineHostStatus: any;
 export type ImageRefLabelsMap = {
@@ -899,11 +937,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;
@@ -914,6 +953,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 declare const Machine: S.Schema<Machine>;
 export interface CreateMachineLeaseRequest {
@@ -924,6 +965,8 @@ 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 declare const CreateMachineLeaseRequest: S.Schema<CreateMachineLeaseRequest>;
 export interface Lease {
@@ -939,10 +982,15 @@ export interface Lease {
     version?: string;
 }
 export declare const Lease: S.Schema<Lease>;
+export interface MachineLease {
+    status?: string;
+    data?: Lease;
+}
+export declare const MachineLease: S.Schema<MachineLease>;
 /** Postgres major version. */
 export type CreatePostgresRequestPgMajorVersion = "16" | "17";
 export declare const CreatePostgresRequestPgMajorVersion: any;
-/** Plan slug selecting CPU, memory, and disk sizing. */
+/** Plan slug selecting CPU, memory, and disk sizing. Matched case-insensitively. */
 export type CreatePostgresRequestPlan = "basic" | "starter" | "launch" | "scale" | "Performance";
 export declare const CreatePostgresRequestPlan: any;
 /** Connection pooler mode. */
@@ -953,11 +1001,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 & {});
@@ -1022,7 +1070,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;
@@ -1045,6 +1093,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 declare const PostgresCluster: S.Schema<PostgresCluster>;
 export interface ShowPostgresClusterResponse {
@@ -1087,7 +1139,7 @@ export declare const CreatePostgresBackupResponse: S.Schema<CreatePostgresBackup
 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 declare const CreatePostgresDatabaseRequest: S.Schema<CreatePostgresDatabaseRequest>;
@@ -1108,7 +1160,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 declare const CreatePostgresUserRequest: S.Schema<CreatePostgresUserRequest>;
@@ -1166,8 +1218,12 @@ export interface CreateVolumeRequest {
     unique_zone_app_wide?: boolean;
 }
 export declare const CreateVolumeRequest: S.Schema<CreateVolumeRequest>;
+export type VolumeHostFeaturesList = Array<string>;
+export declare const VolumeHostFeaturesList: S.Schema<VolumeHostFeaturesList>;
 export type VolumeHostStatus = "ok" | "unknown" | "unreachable";
 export declare const VolumeHostStatus: any;
+export type VolumeRequiredHostFeaturesList = Array<string>;
+export declare const VolumeRequiredHostFeaturesList: S.Schema<VolumeRequiredHostFeaturesList>;
 export type VolumeType = "local" | "cache";
 export declare const VolumeType: any;
 export interface Volume {
@@ -1183,10 +1239,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;
@@ -1286,6 +1344,7 @@ export interface DeleteMachineRequest {
     machine_id: string;
     /** Force kill the machine if it's running */
     force?: boolean;
+    lease_nonce?: string;
 }
 export declare const DeleteMachineRequest: S.Schema<DeleteMachineRequest>;
 export interface DeleteMachineResponse {
@@ -1541,6 +1600,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;
 }
@@ -1734,6 +1795,7 @@ export interface IPAssignment {
     created_at?: string;
     egress?: boolean;
     ip?: string;
+    network?: IPAssignmentNetwork | null;
     region?: string;
     service_name?: string;
     shared?: boolean;
@@ -1751,12 +1813,19 @@ export interface ListAppsRequest {
     org_slug: string;
     /** Filter apps by role */
     app_role?: string;
+    /** The number of apps to fetch (must be between 1 and 5000). Providing a limit enables pagination. Without it, all apps are returned in one response. */
+    limit?: number;
+    /** Value of next_cursor from the previous page. Requires limit. Later pages only include apps that existed when the first page was requested. Apps created in the seconds before the first page was requested may be missing. Cursors expire 30 minutes after the first page was requested. */
+    cursor?: string;
 }
 export declare const ListAppsRequest: S.Schema<ListAppsRequest>;
 export type ListAppsResponseAppsList = Array<App>;
 export declare const ListAppsResponseAppsList: S.Schema<ListAppsResponseAppsList>;
 export interface ListAppsResponse {
     apps?: ListAppsResponseAppsList;
+    /** Pagination cursor for the next page. Absent when no more apps remain. Cursors expire 30 minutes after the first page was requested. */
+    next_cursor?: string;
+    /** The number of apps matching the request, across all pages. When paginating, it is counted once when the first page is requested and not updated afterwards, so it may differ slightly from the number of apps returned: it excludes apps created later and includes apps deleted while paginating. Apps created in the seconds before the first page may also be counted but missing from the pages. */
     total_apps?: number;
 }
 export declare const ListAppsResponse: S.Schema<ListAppsResponse>;
@@ -1821,6 +1890,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 declare const ListMachinesRequest: S.Schema<ListMachinesRequest>;
 export type ListMachinesResponseBodyList = Array<Machine>;
@@ -1898,7 +1971,7 @@ export declare const ListMachineVersionsResponseBodyList: S.Schema<ListMachineVe
 export type ListMachineVersionsResponse = ListMachineVersionsResponseBodyList;
 export declare const ListMachineVersionsResponse: 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;
@@ -1985,20 +2058,21 @@ export interface ListPostgresExtensionsRequest {
     database_name: string;
 }
 export declare const ListPostgresExtensionsRequest: 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 declare const PostgresInstalledExtension: S.Schema<PostgresInstalledExtension>;
+export declare const PostgresExtensionInstalled: S.Schema<PostgresExtensionInstalled>;
 export interface PostgresExtension {
     /** Default version installed when enabled. */
     default_version?: string;
     /** 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. */
@@ -2057,6 +2131,10 @@ export interface ListVolumesRequest {
     app_name: string;
     /** Only return summary info about volumes (omit blocks, block size, etc) */
     summary?: boolean;
+    /** Value of the fly-next-cursor response header from the previous page. Requires limit. */
+    cursor?: string;
+    /** The number of volumes 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 volumes remain. */
+    limit?: number;
 }
 export declare const ListVolumesRequest: S.Schema<ListVolumesRequest>;
 export type ListVolumesResponseBodyList = Array<Volume>;
@@ -2103,8 +2181,12 @@ export interface ListVolumesOrgRequest {
     limit?: number;
 }
 export declare const ListVolumesOrgRequest: S.Schema<ListVolumesOrgRequest>;
+export type OrgVolumeHostFeaturesList = Array<string>;
+export declare const OrgVolumeHostFeaturesList: S.Schema<OrgVolumeHostFeaturesList>;
 export type OrgVolumeHostStatus = "ok" | "unknown" | "unreachable";
 export declare const OrgVolumeHostStatus: any;
+export type OrgVolumeRequiredHostFeaturesList = Array<string>;
+export declare const OrgVolumeRequiredHostFeaturesList: S.Schema<OrgVolumeRequiredHostFeaturesList>;
 export type OrgVolumeType = "local" | "cache";
 export declare const OrgVolumeType: any;
 export interface OrgVolume {
@@ -2121,10 +2203,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;
@@ -2147,6 +2231,8 @@ 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 declare const MachinesReleaseLeaseRequest: S.Schema<MachinesReleaseLeaseRequest>;
 export interface MachinesReleaseLeaseResponse {
@@ -2169,6 +2255,76 @@ export declare const PatchMachineMetadataRequest: S.Schema<PatchMachineMetadataR
 export interface PatchMachineMetadataResponse {
 }
 export declare const PatchMachineMetadataResponse: 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 declare const PostgresQueriesActiveRequest: 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 declare const PostgresActiveQuery: S.Schema<PostgresActiveQuery>;
+export type ListPostgresActiveQueriesResponseDataList = Array<PostgresActiveQuery>;
+export declare const ListPostgresActiveQueriesResponseDataList: S.Schema<ListPostgresActiveQueriesResponseDataList>;
+export interface ListPostgresActiveQueriesResponse {
+    data?: ListPostgresActiveQueriesResponseDataList;
+}
+export declare const ListPostgresActiveQueriesResponse: S.Schema<ListPostgresActiveQueriesResponse>;
+export interface PostgresQueriesSlowRequest {
+    /** Managed Postgres Cluster ID */
+    postgres_cluster_id: string;
+    /** Metrics lookback in seconds */
+    range?: number;
+}
+export declare const PostgresQueriesSlowRequest: 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 declare const PostgresSlowQuery: S.Schema<PostgresSlowQuery>;
+export type ListPostgresSlowQueriesResponseDataList = Array<PostgresSlowQuery>;
+export declare const ListPostgresSlowQueriesResponseDataList: S.Schema<ListPostgresSlowQueriesResponseDataList>;
+export interface ListPostgresSlowQueriesResponse {
+    data?: ListPostgresSlowQueriesResponseDataList;
+}
+export declare const ListPostgresSlowQueriesResponse: S.Schema<ListPostgresSlowQueriesResponse>;
 export interface PostgresUsersCredentialsRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
@@ -2224,6 +2380,7 @@ export interface RestartMachineRequest {
     timeout?: string;
     /** Unix signal name */
     signal?: RestartMachineRequestSignal | (string & {});
+    lease_nonce?: string;
 }
 export declare const RestartMachineRequest: S.Schema<RestartMachineRequest>;
 export interface RestartMachineResponse {
@@ -2304,6 +2461,7 @@ export interface StartMachineRequest {
     app_name: string;
     /** Machine ID */
     machine_id: string;
+    lease_nonce?: string;
 }
 export declare const StartMachineRequest: S.Schema<StartMachineRequest>;
 export interface StartMachineResponse {
@@ -2318,6 +2476,7 @@ export interface StopMachineRequest {
     machine_id: string;
     signal?: StopMachineRequestSignal | (string & {});
     timeout?: string;
+    lease_nonce?: string;
 }
 export declare const StopMachineRequest: S.Schema<StopMachineRequest>;
 export interface StopMachineResponse {
@@ -2328,6 +2487,7 @@ export interface SuspendMachineRequest {
     app_name: string;
     /** Machine ID */
     machine_id: string;
+    lease_nonce?: string;
 }
 export declare const SuspendMachineRequest: S.Schema<SuspendMachineRequest>;
 export interface SuspendMachineResponse {
@@ -2338,6 +2498,7 @@ export interface UncordonMachineRequest {
     app_name: string;
     /** Machine ID */
     machine_id: string;
+    lease_nonce?: string;
 }
 export declare const UncordonMachineRequest: S.Schema<UncordonMachineRequest>;
 export interface UncordonMachineResponse {
@@ -2350,6 +2511,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;
@@ -2360,25 +2522,9 @@ export interface UpdateMachineRequest {
     skip_launch?: boolean;
     skip_secrets?: boolean;
     skip_service_registration?: boolean;
+    lease_nonce?: string;
 }
 export declare const UpdateMachineRequest: S.Schema<UpdateMachineRequest>;
-export type UpdateMachineMetadataRequestMetadataMap = {
-    [key: string]: string | undefined;
-};
-export declare const UpdateMachineMetadataRequestMetadataMap: 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 declare const UpdateMachineMetadataRequest: S.Schema<UpdateMachineMetadataRequest>;
-export interface UpdateMachineMetadataResponse {
-}
-export declare const UpdateMachineMetadataResponse: S.Schema<UpdateMachineMetadataResponse>;
 /** New role for the user. */
 export type UpdatePostgresUserRoleRequestRole = "schema_admin" | "writer" | "reader";
 export declare const UpdatePostgresUserRoleRequestRole: any;
@@ -2485,7 +2631,7 @@ export declare const authorizeToken: API.OperationMethod<AuthorizeTokenRequest,
 export type CheckAppCertificateError = BadRequest | Forbidden | NotFound | FlyIoOpError;
 /** Check DNS and re-validate certificate */
 export declare const checkAppCertificate: API.OperationMethod<CheckAppCertificateRequest, CertificateCheckResponse, CheckAppCertificateError, FlyIoOpContext>;
-export type CordonMachineError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+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 declare const cordonMachine: API.OperationMethod<CordonMachineRequest, CordonMachineResponse, CordonMachineError, FlyIoOpContext>;
 export type CreateAppError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | FlyIoOpError;
@@ -2500,20 +2646,20 @@ export declare const createAppCustomCertificate: API.OperationMethod<CreateAppCu
 export type CreateAppDeployTokenError = BadRequest | Forbidden | NotFound | FlyIoOpError;
 /** Create App deploy token */
 export declare const createAppDeployToken: API.OperationMethod<CreateAppDeployTokenRequest, CreateAppDeployTokenResponse, CreateAppDeployTokenError, FlyIoOpContext>;
-export type CreateAppIPAssignmentError = BadRequest | Forbidden | NotFound | Conflict | FlyIoOpError;
+export type CreateAppIPAssignmentError = BadRequest | Forbidden | NotFound | Conflict | NetworkNotFound | FlyIoOpError;
 /** Assign new IP address to app */
 export declare const createAppIPAssignment: API.OperationMethod<CreateAppIPAssignmentRequest, AssignIPResponse, CreateAppIPAssignmentError, FlyIoOpContext>;
 export type CreateMachineError = BadRequest | Forbidden | NotFound | Conflict | FlyIoOpError;
 /** Create Machine Create a Machine within a specific app using the details provided in the request body. **Important**: This request can fail, and you’re responsible for handling that failure. If you ask for a large Machine, or a Machine in a region we happen to be at capacity for, you might need to retry the request, or to fall back to another region. If you’re working directly with the Machines API, you’re taking some responsibility for your own orchestration! */
 export declare const createMachine: API.OperationMethod<CreateMachineRequest, Machine, CreateMachineError, FlyIoOpContext>;
-export type CreateMachineLeaseError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+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 declare const createMachineLease: API.OperationMethod<CreateMachineLeaseRequest, Lease, CreateMachineLeaseError, FlyIoOpContext>;
+export declare const createMachineLease: API.OperationMethod<CreateMachineLeaseRequest, MachineLease, CreateMachineLeaseError, FlyIoOpContext>;
 export type CreatePostgresError = BadRequest | 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 declare const createPostgres: API.OperationMethod<CreatePostgresRequest, ShowPostgresClusterResponse, CreatePostgresError, FlyIoOpContext>;
 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 declare const createPostgresAttachment: API.OperationMethod<CreatePostgresAttachmentRequest, CreatePostgresAttachmentResponse, CreatePostgresAttachmentError, FlyIoOpContext>;
 export type CreatePostgresBackupError = NotFound | Conflict | FlyIoOpError;
 /** Create Backup Create a backup for a specific cluster. The backup runs asynchronously and is rejected if one is already in progress. */
@@ -2575,7 +2721,7 @@ export declare const deleteSecret: API.OperationMethod<DeleteSecretRequest, Dele
 export type DeleteSecretKeyError = Forbidden | NotFound | FlyIoOpError;
 /** Delete an app's secret key */
 export declare const deleteSecretKey: API.OperationMethod<DeleteSecretKeyRequest, DeleteSecretkeyResponse, DeleteSecretKeyError, FlyIoOpContext>;
-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 declare const deleteVolume: API.OperationMethod<DeleteVolumeRequest, Volume, DeleteVolumeError, FlyIoOpContext>;
 export type DisablePostgresExtensionError = BadRequest | NotFound | UnprocessableEntity | FlyIoOpError;
@@ -2587,7 +2733,7 @@ export declare const enablePostgresExtension: API.OperationMethod<EnablePostgres
 export type EncryptSecretKeyError = BadRequest | Forbidden | NotFound | FlyIoOpError;
 /** Encrypt with a secret key */
 export declare const encryptSecretKey: API.OperationMethod<EncryptSecretKeyRequest, EncryptSecretkeyResponse, EncryptSecretKeyError, FlyIoOpContext>;
-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 declare const execMachine: API.OperationMethod<ExecMachineRequest, Flydv1ExecResponse, ExecMachineError, FlyIoOpContext>;
 export type ExtendVolumeError = BadRequest | Forbidden | NotFound | FlyIoOpError;
@@ -2613,7 +2759,7 @@ export type GetMachineError = Forbidden | NotFound | FlyIoOpError;
 export declare const getMachine: API.OperationMethod<GetMachineRequest, Machine, GetMachineError, FlyIoOpContext>;
 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 declare const getMachineLease: API.OperationMethod<GetMachineLeaseRequest, Lease, GetMachineLeaseError, FlyIoOpContext>;
+export declare const getMachineLease: API.OperationMethod<GetMachineLeaseRequest, MachineLease, GetMachineLeaseError, FlyIoOpContext>;
 export type GetMachineMemoryError = Forbidden | NotFound | FlyIoOpError;
 /** Get Machine Memory Get current memory limit and available capacity for a machine */
 export declare const getMachineMemory: API.OperationMethod<GetMachineMemoryRequest, MainMemoryResponse, GetMachineMemoryError, FlyIoOpContext>;
@@ -2665,7 +2811,7 @@ export declare const listMachinesOrg: API.OperationMethod<ListMachinesOrgRequest
 export type ListMachineVersionsError = Forbidden | NotFound | FlyIoOpError;
 /** List Versions List all versions of the configuration for a specific Machine within an app. */
 export declare const listMachineVersions: API.OperationMethod<ListMachineVersionsRequest, ListMachineVersionsResponse, ListMachineVersionsError, FlyIoOpContext>;
-export type ListPostgresError = NotFound | UnprocessableEntity | FlyIoOpError;
+export type ListPostgresError = BadRequest | NotFound | UnprocessableEntity | FlyIoOpError;
 /** List Postgres Clusters List Managed Postgres clusters for an organization. */
 export declare const listPostgres: API.OperationMethod<ListPostgresRequest, ListPostgresClustersResponse, ListPostgresError, FlyIoOpContext>;
 export type ListPostgresBackupsError = NotFound | FlyIoOpError;
@@ -2698,9 +2844,15 @@ export declare const listVolumesOrg: API.OperationMethod<ListVolumesOrgRequest,
 export type MachinesReleaseLeaseError = Forbidden | NotFound | FlyIoOpError;
 /** Release Lease Release the lease of a specific Machine within an app. Machine leases can be used to obtain an exclusive lock on modifying a Machine. */
 export declare const machinesReleaseLease: API.OperationMethod<MachinesReleaseLeaseRequest, MachinesReleaseLeaseResponse, MachinesReleaseLeaseError, FlyIoOpContext>;
-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 declare const patchMachineMetadata: API.OperationMethod<PatchMachineMetadataRequest, PatchMachineMetadataResponse, PatchMachineMetadataError, FlyIoOpContext>;
+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 declare const postgresQueriesActive: API.OperationMethod<PostgresQueriesActiveRequest, ListPostgresActiveQueriesResponse, PostgresQueriesActiveError, FlyIoOpContext>;
+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 declare const postgresQueriesSlow: API.OperationMethod<PostgresQueriesSlowRequest, ListPostgresSlowQueriesResponse, PostgresQueriesSlowError, FlyIoOpContext>;
 export type PostgresUsersCredentialsError = BadRequest | NotFound | FlyIoOpError;
 /** Get User Credentials Get the connection credentials for a specific Postgres user within a cluster. */
 export declare const postgresUsersCredentials: API.OperationMethod<PostgresUsersCredentialsRequest, GetPostgresUserCredentialsResponse, PostgresUsersCredentialsError, FlyIoOpContext>;
@@ -2708,12 +2860,12 @@ export type ReclaimMachineMemoryError = BadRequest | Forbidden | NotFound | FlyI
 /** Reclaim Machine Memory Trigger the balloon device to reclaim memory from a machine */
 export declare const reclaimMachineMemory: API.OperationMethod<ReclaimMachineMemoryRequest, MainReclaimMemoryResponse, ReclaimMachineMemoryError, FlyIoOpContext>;
 export type RequestKmsTokenError = BadRequest | Forbidden | NotFound | FlyIoOpError;
-/** Request a Petsem token for accessing KMS This site hosts documentation generated from the Fly.io Machines API OpenAPI specification. Visit our complete [Machines API docs](https://fly.io/docs/machines/api/apps-resource/) for details about using the Apps resource. */
+/** Request a Petsem token for accessing KMS */
 export declare const requestKmsToken: API.OperationMethod<RequestKmsTokenRequest, RequestKmsTokenResponse, RequestKmsTokenError, FlyIoOpContext>;
 export type RequestOidcTokenError = BadRequest | Forbidden | NotFound | FlyIoOpError;
 /** Request an OIDC token Request an Open ID Connect token for your machine. Customize the audience claim with the `aud` parameter. This returns a JWT token. Learn more about [using OpenID Connect](/docs/reference/openid-connect/) on Fly.io. */
 export declare const requestOidcToken: API.OperationMethod<RequestOidcTokenRequest, RequestOidcTokenResponse, RequestOidcTokenError, FlyIoOpContext>;
-export type RestartMachineError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+export type RestartMachineError = BadRequest | Forbidden | NotFound | Conflict | FlyIoOpError;
 /** Restart Machine Restart a specific Machine within an app, with an optional timeout parameter. */
 export declare const restartMachine: API.OperationMethod<RestartMachineRequest, RestartMachineResponse, RestartMachineError, FlyIoOpContext>;
 export type RestorePostgresError = BadRequest | NotFound | UnprocessableEntity | FlyIoOpError;
@@ -2734,24 +2886,21 @@ export declare const signalMachine: API.OperationMethod<SignalMachineRequest, Si
 export type SignSecretKeyError = BadRequest | Forbidden | NotFound | FlyIoOpError;
 /** Sign with a secret key */
 export declare const signSecretKey: API.OperationMethod<SignSecretKeyRequest, SignSecretkeyResponse, SignSecretKeyError, FlyIoOpContext>;
-export type StartMachineError = BadRequest | Forbidden | NotFound | Conflict | MachineStartFromCreatedState | FlyIoOpError;
+export type StartMachineError = BadRequest | Forbidden | NotFound | Conflict | MachineStartFromCreatedState | MachineReplacing | FlyIoOpError;
 /** Start Machine Start a specific Machine within an app. */
 export declare const startMachine: API.OperationMethod<StartMachineRequest, StartMachineResponse, StartMachineError, FlyIoOpContext>;
-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 declare const stopMachine: API.OperationMethod<StopMachineRequest, StopMachineResponse, StopMachineError, FlyIoOpContext>;
-export type SuspendMachineError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+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 declare const suspendMachine: API.OperationMethod<SuspendMachineRequest, SuspendMachineResponse, SuspendMachineError, FlyIoOpContext>;
-export type UncordonMachineError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+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 declare const uncordonMachine: API.OperationMethod<UncordonMachineRequest, UncordonMachineResponse, UncordonMachineError, FlyIoOpContext>;
 export type UpdateMachineError = BadRequest | Forbidden | NotFound | Conflict | FlyIoOpError;
 /** Update Machine Update a Machine's configuration using the details provided in the request body. */
 export declare const updateMachine: API.OperationMethod<UpdateMachineRequest, Machine, UpdateMachineError, FlyIoOpContext>;
-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 declare const updateMachineMetadata: API.OperationMethod<UpdateMachineMetadataRequest, UpdateMachineMetadataResponse, UpdateMachineMetadataError, FlyIoOpContext>;
 export type UpdatePostgresUserRoleError = BadRequest | NotFound | UnprocessableEntity | FlyIoOpError;
 /** Update User Role Update a specific Postgres user's role within a cluster. */
 export declare const updatePostgresUserRole: API.OperationMethod<UpdatePostgresUserRoleRequest, UpdatePostgresUserRoleResponse, UpdatePostgresUserRoleError, FlyIoOpContext>;