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

package/lib/services/machines.d.ts

@@ -0,0 +1,2236 @@
+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 { BadRequest, Forbidden, NotFound, UnprocessableEntity } from "../errors.ts";
+export type { FlyIoOpError, FlyIoOpContext };
+export interface AppCertificatesAcmeCreateRequest {
+    /** Fly App Name */
+    app_name: string;
+    hostname?: string;
+}
+export declare const AppCertificatesAcmeCreateRequest: S.Schema<AppCertificatesAcmeCreateRequest>;
+export type IssuedCertificateType = "rsa" | "ecdsa";
+export declare const IssuedCertificateType: any;
+export interface IssuedCertificate {
+    certificate_authority?: string;
+    expires_at?: string;
+    type?: IssuedCertificateType;
+}
+export declare const IssuedCertificate: S.Schema<IssuedCertificate>;
+export type CertificateEntryIssuedList = Array<IssuedCertificate>;
+export declare const CertificateEntryIssuedList: S.Schema<CertificateEntryIssuedList>;
+export type CertificateEntrySource = "custom" | "fly";
+export declare const CertificateEntrySource: any;
+export type CertificateEntryStatus = "active" | "pending_ownership" | "pending_validation";
+export declare const CertificateEntryStatus: any;
+export interface CertificateEntry {
+    created_at?: string;
+    expires_at?: string;
+    issued?: CertificateEntryIssuedList;
+    issuer?: string;
+    source?: CertificateEntrySource;
+    status?: CertificateEntryStatus;
+}
+export declare const CertificateEntry: S.Schema<CertificateEntry>;
+export type CertificateDetailCertificatesList = Array<CertificateEntry>;
+export declare const CertificateDetailCertificatesList: S.Schema<CertificateDetailCertificatesList>;
+export type DNSRequirementsAList = Array<string>;
+export declare const DNSRequirementsAList: S.Schema<DNSRequirementsAList>;
+export type DNSRequirementsAaaaList = Array<string>;
+export declare const DNSRequirementsAaaaList: S.Schema<DNSRequirementsAaaaList>;
+export interface AcmeChallenge {
+    name?: string;
+    target?: string;
+}
+export declare const AcmeChallenge: S.Schema<AcmeChallenge>;
+export interface OwnershipVerification {
+    app_value?: string;
+    name?: string;
+    org_value?: string;
+}
+export declare const OwnershipVerification: S.Schema<OwnershipVerification>;
+export interface DNSRequirements {
+    a?: DNSRequirementsAList;
+    aaaa?: DNSRequirementsAaaaList;
+    acme_challenge?: AcmeChallenge;
+    cname?: string;
+    ownership?: OwnershipVerification;
+}
+export declare const DNSRequirements: S.Schema<DNSRequirements>;
+export interface CertificateValidation {
+    alpn_configured?: boolean;
+    dns_configured?: boolean;
+    http_configured?: boolean;
+    ownership_txt_configured?: boolean;
+}
+export declare const CertificateValidation: S.Schema<CertificateValidation>;
+export interface CertificateValidationError {
+    code?: string;
+    message?: string;
+    remediation?: string;
+    timestamp?: string;
+}
+export declare const CertificateValidationError: S.Schema<CertificateValidationError>;
+export type CertificateDetailValidationErrorsList = Array<CertificateValidationError>;
+export declare const CertificateDetailValidationErrorsList: S.Schema<CertificateDetailValidationErrorsList>;
+export interface CertificateDetail {
+    acme_requested?: boolean;
+    certificates?: CertificateDetailCertificatesList;
+    configured?: boolean;
+    dns_provider?: string;
+    dns_requirements?: DNSRequirements;
+    hostname?: string;
+    rate_limited_until?: string;
+    status?: string;
+    validation?: CertificateValidation;
+    validation_errors?: CertificateDetailValidationErrorsList;
+}
+export declare const CertificateDetail: S.Schema<CertificateDetail>;
+export interface AppCertificatesAcmeDeleteRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Certificate Hostname */
+    hostname: string;
+}
+export declare const AppCertificatesAcmeDeleteRequest: S.Schema<AppCertificatesAcmeDeleteRequest>;
+export interface AppCertificatesCheckRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Certificate Hostname */
+    hostname: string;
+}
+export declare const AppCertificatesCheckRequest: S.Schema<AppCertificatesCheckRequest>;
+export type CertificateCheckResponseCertificatesList = Array<CertificateEntry>;
+export declare const CertificateCheckResponseCertificatesList: S.Schema<CertificateCheckResponseCertificatesList>;
+export type DNSRecordsAList = Array<string>;
+export declare const DNSRecordsAList: S.Schema<DNSRecordsAList>;
+export type DNSRecordsAaaaList = Array<string>;
+export declare const DNSRecordsAaaaList: S.Schema<DNSRecordsAaaaList>;
+export type DNSRecordsCnameList = Array<string>;
+export declare const DNSRecordsCnameList: S.Schema<DNSRecordsCnameList>;
+export type DNSRecordsResolvedAddressesList = Array<string>;
+export declare const DNSRecordsResolvedAddressesList: S.Schema<DNSRecordsResolvedAddressesList>;
+export interface DNSRecords {
+    a?: DNSRecordsAList;
+    aaaa?: DNSRecordsAaaaList;
+    acme_challenge_cname?: string;
+    cname?: DNSRecordsCnameList;
+    ownership_txt?: string;
+    resolved_addresses?: DNSRecordsResolvedAddressesList;
+    soa?: string;
+}
+export declare const DNSRecords: S.Schema<DNSRecords>;
+export type CertificateCheckResponseValidationErrorsList = Array<CertificateValidationError>;
+export declare const CertificateCheckResponseValidationErrorsList: S.Schema<CertificateCheckResponseValidationErrorsList>;
+export interface CertificateCheckResponse {
+    acme_requested?: boolean;
+    certificates?: CertificateCheckResponseCertificatesList;
+    configured?: boolean;
+    dns_provider?: string;
+    dns_records?: DNSRecords;
+    dns_requirements?: DNSRequirements;
+    hostname?: string;
+    rate_limited_until?: string;
+    status?: string;
+    validation?: CertificateValidation;
+    validation_errors?: CertificateCheckResponseValidationErrorsList;
+}
+export declare const CertificateCheckResponse: S.Schema<CertificateCheckResponse>;
+export interface AppCertificatesCustomCreateRequest {
+    /** Fly App Name */
+    app_name: string;
+    fullchain?: string;
+    hostname?: string;
+    private_key?: string;
+}
+export declare const AppCertificatesCustomCreateRequest: S.Schema<AppCertificatesCustomCreateRequest>;
+export interface AppCertificatesCustomDeleteRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Certificate Hostname */
+    hostname: string;
+}
+export declare const AppCertificatesCustomDeleteRequest: S.Schema<AppCertificatesCustomDeleteRequest>;
+export type DestroyCustomCertificateResponseCertificatesList = Array<CertificateEntry>;
+export declare const DestroyCustomCertificateResponseCertificatesList: S.Schema<DestroyCustomCertificateResponseCertificatesList>;
+export type DestroyCustomCertificateResponseValidationErrorsList = Array<CertificateValidationError>;
+export declare const DestroyCustomCertificateResponseValidationErrorsList: S.Schema<DestroyCustomCertificateResponseValidationErrorsList>;
+export interface DestroyCustomCertificateResponse {
+    acme_requested?: boolean;
+    certificates?: DestroyCustomCertificateResponseCertificatesList;
+    configured?: boolean;
+    dns_provider?: string;
+    dns_requirements?: DNSRequirements;
+    hostname?: string;
+    rate_limited_until?: string;
+    status?: string;
+    validation?: CertificateValidation;
+    validation_errors?: DestroyCustomCertificateResponseValidationErrorsList;
+    warning?: string;
+}
+export declare const DestroyCustomCertificateResponse: S.Schema<DestroyCustomCertificateResponse>;
+export interface AppCertificatesDeleteRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Certificate Hostname */
+    hostname: string;
+}
+export declare const AppCertificatesDeleteRequest: S.Schema<AppCertificatesDeleteRequest>;
+export interface AppCertificatesDeleteResponse {
+}
+export declare const AppCertificatesDeleteResponse: S.Schema<AppCertificatesDeleteResponse>;
+export interface AppCertificatesListRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Hostname filter (substring match) */
+    filter?: string;
+    /** Pagination cursor from previous response */
+    cursor?: string;
+    /** Number of results per page (default 25, max 500) */
+    limit?: number;
+}
+export declare const AppCertificatesListRequest: S.Schema<AppCertificatesListRequest>;
+export interface CertificateSummary {
+    acme_alpn_configured?: boolean;
+    acme_dns_configured?: boolean;
+    acme_http_configured?: boolean;
+    acme_requested?: boolean;
+    configured?: boolean;
+    created_at?: string;
+    dns_provider?: string;
+    has_custom_certificate?: boolean;
+    has_fly_certificate?: boolean;
+    hostname?: string;
+    ownership_txt_configured?: boolean;
+    status?: string;
+    updated_at?: string;
+}
+export declare const CertificateSummary: S.Schema<CertificateSummary>;
+export type ListCertificatesResponseCertificatesList = Array<CertificateSummary>;
+export declare const ListCertificatesResponseCertificatesList: S.Schema<ListCertificatesResponseCertificatesList>;
+export interface ListCertificatesResponse {
+    certificates?: ListCertificatesResponseCertificatesList;
+    next_cursor?: string;
+    total_count?: number;
+}
+export declare const ListCertificatesResponse: S.Schema<ListCertificatesResponse>;
+export interface AppCertificatesShowRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Certificate Hostname */
+    hostname: string;
+}
+export declare const AppCertificatesShowRequest: S.Schema<AppCertificatesShowRequest>;
+export interface AppCreateDeployTokenRequest {
+    /** Fly App Name */
+    app_name: string;
+    expiry?: string;
+}
+export declare const AppCreateDeployTokenRequest: S.Schema<AppCreateDeployTokenRequest>;
+export interface CreateAppResponse {
+    token?: string;
+}
+export declare const CreateAppResponse: S.Schema<CreateAppResponse>;
+export interface AppIPAssignmentsCreateRequest {
+    /** Fly App Name */
+    app_name: string;
+    network?: string;
+    org_slug?: string;
+    region?: string;
+    service_name?: string;
+    type?: string;
+}
+export declare const AppIPAssignmentsCreateRequest: S.Schema<AppIPAssignmentsCreateRequest>;
+export interface IPAssignment {
+    created_at?: string;
+    ip?: string;
+    region?: string;
+    service_name?: string;
+    shared?: boolean;
+}
+export declare const IPAssignment: S.Schema<IPAssignment>;
+export interface AppIPAssignmentsDeleteRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** IP address */
+    ip: string;
+}
+export declare const AppIPAssignmentsDeleteRequest: S.Schema<AppIPAssignmentsDeleteRequest>;
+export interface AppIPAssignmentsDeleteResponse {
+}
+export declare const AppIPAssignmentsDeleteResponse: S.Schema<AppIPAssignmentsDeleteResponse>;
+export interface AppIPAssignmentsListRequest {
+    /** Fly App Name */
+    app_name: string;
+}
+export declare const AppIPAssignmentsListRequest: S.Schema<AppIPAssignmentsListRequest>;
+export type ListIPAssignmentsResponseIpsList = Array<IPAssignment>;
+export declare const ListIPAssignmentsResponseIpsList: S.Schema<ListIPAssignmentsResponseIpsList>;
+export interface ListIPAssignmentsResponse {
+    ips?: ListIPAssignmentsResponseIpsList;
+}
+export declare const ListIPAssignmentsResponse: S.Schema<ListIPAssignmentsResponse>;
+export interface AppsCreateRequest {
+    enable_subdomains?: boolean;
+    name?: string;
+    network?: string;
+    org_slug?: string;
+}
+export declare const AppsCreateRequest: S.Schema<AppsCreateRequest>;
+export interface AppsCreateResponse {
+}
+export declare const AppsCreateResponse: S.Schema<AppsCreateResponse>;
+export interface AppsDeleteRequest {
+    /** Fly App Name */
+    app_name: string;
+}
+export declare const AppsDeleteRequest: S.Schema<AppsDeleteRequest>;
+export interface AppsDeleteResponse {
+}
+export declare const AppsDeleteResponse: S.Schema<AppsDeleteResponse>;
+export interface AppsListRequest {
+    /** The org slug, or 'personal', to filter apps */
+    org_slug: string;
+    /** Filter apps by role */
+    app_role?: string;
+}
+export declare const AppsListRequest: S.Schema<AppsListRequest>;
+export interface AppOrganizationInfo {
+    internal_numeric_id?: number;
+    name?: string;
+    slug?: string;
+}
+export declare const AppOrganizationInfo: S.Schema<AppOrganizationInfo>;
+export interface App {
+    id?: string;
+    internal_numeric_id?: number;
+    machine_count?: number;
+    name?: string;
+    network?: string;
+    organization?: AppOrganizationInfo;
+    status?: string;
+    volume_count?: number;
+}
+export declare const App: S.Schema<App>;
+export type ListAppsResponseAppsList = Array<App>;
+export declare const ListAppsResponseAppsList: S.Schema<ListAppsResponseAppsList>;
+export interface ListAppsResponse {
+    apps?: ListAppsResponseAppsList;
+    total_apps?: number;
+}
+export declare const ListAppsResponse: S.Schema<ListAppsResponse>;
+export interface AppsShowRequest {
+    /** Fly App Name */
+    app_name: string;
+}
+export declare const AppsShowRequest: S.Schema<AppsShowRequest>;
+export interface CreateVolumeSnapshotRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Volume ID */
+    volume_id: string;
+}
+export declare const CreateVolumeSnapshotRequest: S.Schema<CreateVolumeSnapshotRequest>;
+export interface CreateVolumeSnapshotResponse {
+}
+export declare const CreateVolumeSnapshotResponse: S.Schema<CreateVolumeSnapshotResponse>;
+export interface CurrentTokenShowRequest {
+}
+export declare const CurrentTokenShowRequest: S.Schema<CurrentTokenShowRequest>;
+export type MainTokenInfoAppsList = Array<string>;
+export declare const MainTokenInfoAppsList: S.Schema<MainTokenInfoAppsList>;
+export interface MainTokenInfo {
+    apps?: MainTokenInfoAppsList;
+    org_slug?: string;
+    organization?: string;
+    /** Machine the token is restricted to (FromMachine caveat) */
+    restricted_to_machine?: string;
+    /** Machine making the request */
+    source_machine_id?: string;
+    token_id?: string;
+    /** User identifier if token is for a user */
+    user?: string;
+}
+export declare const MainTokenInfo: S.Schema<MainTokenInfo>;
+export type CurrentTokenResponseTokensList = Array<MainTokenInfo>;
+export declare const CurrentTokenResponseTokensList: S.Schema<CurrentTokenResponseTokensList>;
+export interface CurrentTokenResponse {
+    tokens?: CurrentTokenResponseTokensList;
+}
+export declare const CurrentTokenResponse: S.Schema<CurrentTokenResponse>;
+export interface MachinesCordonRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+}
+export declare const MachinesCordonRequest: S.Schema<MachinesCordonRequest>;
+export interface MachinesCordonResponse {
+}
+export declare const MachinesCordonResponse: S.Schema<MachinesCordonResponse>;
+export interface FlyMachineCacheDrive {
+    size_mb?: number;
+}
+export declare const FlyMachineCacheDrive: S.Schema<FlyMachineCacheDrive>;
+/** The header value */
+export type FlyMachineHTTPHeaderValuesList = Array<string>;
+export declare const FlyMachineHTTPHeaderValuesList: S.Schema<FlyMachineHTTPHeaderValuesList>;
+/** For http checks, an array of objects with string field Name and array of strings field Values. The key/value pairs specify header and header values that will get passed with the check call. */
+export interface FlyMachineHTTPHeader {
+    /** The header name */
+    name?: string;
+    /** The header value */
+    values?: FlyMachineHTTPHeaderValuesList;
+}
+export declare const FlyMachineHTTPHeader: S.Schema<FlyMachineHTTPHeader>;
+export type FlyMachineCheckHeadersList = Array<FlyMachineHTTPHeader>;
+export declare const FlyMachineCheckHeadersList: S.Schema<FlyMachineCheckHeadersList>;
+/** Kind of the check (informational, readiness) */
+export type FlyMachineCheckKind = "informational" | "readiness";
+export declare const FlyMachineCheckKind: any;
+export interface FlyMachineCheck {
+    /** The time to wait after a VM starts before checking its health */
+    grace_period?: string;
+    headers?: FlyMachineCheckHeadersList;
+    /** The time between connectivity checks */
+    interval?: string;
+    /** Kind of the check (informational, readiness) */
+    kind?: FlyMachineCheckKind | (string & {});
+    /** For http checks, the HTTP method to use to when making the request */
+    method?: string;
+    /** For http checks, the path to send the request to */
+    path?: string;
+    /** The port to connect to, often the same as internal_port */
+    port?: number;
+    /** For http checks, whether to use http or https */
+    protocol?: string;
+    /** The maximum time a connection can take before being reported as failing its health check */
+    timeout?: string;
+    /** If the protocol is https, the hostname to use for TLS certificate validation */
+    tls_server_name?: string;
+    /** For http checks with https protocol, whether or not to verify the TLS certificate */
+    tls_skip_verify?: boolean;
+    /** tcp or http */
+    type?: string;
+}
+export declare const FlyMachineCheck: S.Schema<FlyMachineCheck>;
+/** An optional object that defines one or more named top-level checks. The key for each check is the check name. */
+export type FlyMachineConfigChecksMap = {
+    [key: string]: FlyMachineCheck | undefined;
+};
+export declare const FlyMachineConfigChecksMap: S.Schema<FlyMachineConfigChecksMap>;
+/** CmdOverride is used to override the default command of the image. */
+export type FlyContainerConfigCmdList = Array<string>;
+export declare const FlyContainerConfigCmdList: S.Schema<FlyContainerConfigCmdList>;
+export type FlyContainerDependencyCondition = "exited_successfully" | "healthy" | "started";
+export declare const FlyContainerDependencyCondition: any;
+export interface FlyContainerDependency {
+    condition?: FlyContainerDependencyCondition | (string & {});
+    name?: string;
+}
+export declare const FlyContainerDependency: S.Schema<FlyContainerDependency>;
+/** DependsOn can be used to define dependencies between containers. The container will only be started after all of its dependent conditions have been satisfied. */
+export type FlyContainerConfigDependsOnList = Array<FlyContainerDependency>;
+export declare const FlyContainerConfigDependsOnList: S.Schema<FlyContainerConfigDependsOnList>;
+/** EntrypointOverride is used to override the default entrypoint of the image. */
+export type FlyContainerConfigEntrypointList = Array<string>;
+export declare const FlyContainerConfigEntrypointList: S.Schema<FlyContainerConfigEntrypointList>;
+/** ExtraEnv is used to add additional environment variables to the container. */
+export type FlyContainerConfigEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const FlyContainerConfigEnvMap: S.Schema<FlyContainerConfigEnvMap>;
+/** FieldRef selects a field of the Machine: supports id, version, app_name, private_ip, region, image. */
+export type FlyEnvFromFieldRef = "id" | "version" | "app_name" | "private_ip" | "region" | "image";
+export declare const FlyEnvFromFieldRef: any;
+/** EnvVar defines an environment variable to be populated from a machine field, env_var */
+export interface FlyEnvFrom {
+    /** EnvVar is required and is the name of the environment variable that will be set from the secret. It must be a valid environment variable name. */
+    env_var?: string;
+    /** FieldRef selects a field of the Machine: supports id, version, app_name, private_ip, region, image. */
+    field_ref?: FlyEnvFromFieldRef | (string & {});
+}
+export declare const FlyEnvFrom: S.Schema<FlyEnvFrom>;
+/** EnvFrom can be provided to set environment variables from machine fields. */
+export type FlyContainerConfigEnvFromList = Array<FlyEnvFrom>;
+export declare const FlyContainerConfigEnvFromList: S.Schema<FlyContainerConfigEnvFromList>;
+/** Image Config overrides - these fields are used to override the image configuration. If not provided, the image configuration will be used. ExecOverride is used to override the default command of the image. */
+export type FlyContainerConfigExecList = Array<string>;
+export declare const FlyContainerConfigExecList: S.Schema<FlyContainerConfigExecList>;
+/** A file that will be written to the Machine. One of RawValue or SecretName must be set. */
+export interface FlyFile {
+    /** GuestPath is the path on the machine where the file will be written and must be an absolute path. For example: /full/path/to/file.json */
+    guest_path?: string;
+    /** The name of an image to use the OCI image config as the file contents. */
+    image_config?: string;
+    /** Mode bits used to set permissions on this file as accepted by chmod(2). */
+    mode?: number;
+    /** The base64 encoded string of the file contents. */
+    raw_value?: string;
+    /** The name of the secret that contains the base64 encoded file contents. */
+    secret_name?: string;
+}
+export declare const FlyFile: S.Schema<FlyFile>;
+/** Files are files that will be written to the container file system. */
+export type FlyContainerConfigFilesList = Array<FlyFile>;
+export declare const FlyContainerConfigFilesList: S.Schema<FlyContainerConfigFilesList>;
+/** The command to run to check the health of the container (e.g. ["cat", "/tmp/healthy"]) */
+export type FlyExecHealthcheckCommandList = Array<string>;
+export declare const FlyExecHealthcheckCommandList: S.Schema<FlyExecHealthcheckCommandList>;
+export interface FlyExecHealthcheck {
+    /** The command to run to check the health of the container (e.g. ["cat", "/tmp/healthy"]) */
+    command?: FlyExecHealthcheckCommandList;
+}
+export declare const FlyExecHealthcheck: S.Schema<FlyExecHealthcheck>;
+/** Additional headers to send with the request */
+export type FlyHTTPHealthcheckHeadersList = Array<FlyMachineHTTPHeader>;
+export declare const FlyHTTPHealthcheckHeadersList: S.Schema<FlyHTTPHealthcheckHeadersList>;
+export type FlyContainerHealthcheckScheme = "http" | "https";
+export declare const FlyContainerHealthcheckScheme: any;
+export interface FlyHTTPHealthcheck {
+    /** Additional headers to send with the request */
+    headers?: FlyHTTPHealthcheckHeadersList;
+    /** The HTTP method to use to when making the request */
+    method?: string;
+    /** The path to send the request to */
+    path?: string;
+    /** The port to connect to, often the same as internal_port */
+    port?: number;
+    /** Whether to use http or https */
+    scheme?: FlyContainerHealthcheckScheme | (string & {});
+    /** If the protocol is https, the hostname to use for TLS certificate validation */
+    tls_server_name?: string;
+    /** If the protocol is https, whether or not to verify the TLS certificate */
+    tls_skip_verify?: boolean;
+}
+export declare const FlyHTTPHealthcheck: S.Schema<FlyHTTPHealthcheck>;
+export type FlyContainerHealthcheckKind = "readiness" | "liveness";
+export declare const FlyContainerHealthcheckKind: any;
+export interface FlyTCPHealthcheck {
+    /** The port to connect to, often the same as internal_port */
+    port?: number;
+}
+export declare const FlyTCPHealthcheck: S.Schema<FlyTCPHealthcheck>;
+export type FlyUnhealthyPolicy = "stop";
+export declare const FlyUnhealthyPolicy: any;
+export interface FlyContainerHealthcheck {
+    exec?: FlyExecHealthcheck;
+    /** The number of times the check must fail before considering the container unhealthy. */
+    failure_threshold?: number;
+    /** The time in seconds to wait after a container starts before checking its health. */
+    grace_period?: number;
+    http?: FlyHTTPHealthcheck;
+    /** The time in seconds between executing the defined check. */
+    interval?: number;
+    /** Kind of healthcheck (readiness, liveness) */
+    kind?: FlyContainerHealthcheckKind | (string & {});
+    /** The name of the check. Must be unique within the container. */
+    name?: string;
+    /** The number of times the check must succeeed before considering the container healthy. */
+    success_threshold?: number;
+    tcp?: FlyTCPHealthcheck;
+    /** The time in seconds to wait for the check to complete. */
+    timeout?: number;
+    /** Unhealthy policy that determines what action to take if a container is deemed unhealthy */
+    unhealthy?: FlyUnhealthyPolicy | (string & {});
+}
+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";
+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. */
+    policy?: FlyMachineRestartPolicy | (string & {});
+}
+export declare const FlyMachineRestart: S.Schema<FlyMachineRestart>;
+/** A Secret needing to be set in the environment of the Machine. env_var is required */
+export interface FlyMachineSecret {
+    /** EnvVar is required and is the name of the environment variable that will be set from the secret. It must be a valid environment variable name. */
+    env_var?: string;
+    /** Name is optional and when provided is used to reference a secret name where the EnvVar is different from what was set as the secret name. */
+    name?: string;
+}
+export declare const FlyMachineSecret: S.Schema<FlyMachineSecret>;
+/** 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. */
+export type FlyContainerConfigSecretsList = Array<FlyMachineSecret>;
+export declare const FlyContainerConfigSecretsList: S.Schema<FlyContainerConfigSecretsList>;
+export type FlyStopConfigSignal = "SIGHUP" | "SIGINT" | "SIGQUIT" | "SIGKILL" | "SIGUSR1" | "SIGUSR2" | "SIGTERM";
+export declare const FlyStopConfigSignal: any;
+export interface FlyStopConfig {
+    signal?: FlyStopConfigSignal | (string & {});
+    timeout?: string;
+}
+export declare const FlyStopConfig: S.Schema<FlyStopConfig>;
+export interface FlyContainerConfig {
+    /** CmdOverride is used to override the default command of the image. */
+    cmd?: FlyContainerConfigCmdList;
+    /** DependsOn can be used to define dependencies between containers. The container will only be started after all of its dependent conditions have been satisfied. */
+    depends_on?: FlyContainerConfigDependsOnList;
+    /** EntrypointOverride is used to override the default entrypoint of the image. */
+    entrypoint?: FlyContainerConfigEntrypointList;
+    /** ExtraEnv is used to add additional environment variables to the container. */
+    env?: FlyContainerConfigEnvMap;
+    /** EnvFrom can be provided to set environment variables from machine fields. */
+    env_from?: FlyContainerConfigEnvFromList;
+    /** Image Config overrides - these fields are used to override the image configuration. If not provided, the image configuration will be used. ExecOverride is used to override the default command of the image. */
+    exec?: FlyContainerConfigExecList;
+    /** Files are files that will be written to the container file system. */
+    files?: FlyContainerConfigFilesList;
+    /** Healthchecks determine the health of your containers. Healthchecks can use HTTP, TCP or an Exec command. */
+    healthchecks?: FlyContainerConfigHealthchecksList;
+    /** Image is the docker image to run. */
+    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?: 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;
+    /** Stop is used to define the signal and timeout for stopping the container. */
+    stop?: FlyStopConfig;
+    /** UserOverride is used to override the default user of the image. */
+    user?: string;
+}
+export declare const FlyContainerConfig: S.Schema<FlyContainerConfig>;
+/** Containers are a list of containers that will run in the machine. Currently restricted to only specific organizations. */
+export type FlyMachineConfigContainersList = Array<FlyContainerConfig>;
+export declare const FlyMachineConfigContainersList: S.Schema<FlyMachineConfigContainersList>;
+export interface FlyDnsForwardRule {
+    addr?: string;
+    basename?: string;
+}
+export declare const FlyDnsForwardRule: S.Schema<FlyDnsForwardRule>;
+export type FlyDNSConfigDnsForwardRulesList = Array<FlyDnsForwardRule>;
+export declare const FlyDNSConfigDnsForwardRulesList: S.Schema<FlyDNSConfigDnsForwardRulesList>;
+export type FlyDNSConfigNameserversList = Array<string>;
+export declare const FlyDNSConfigNameserversList: S.Schema<FlyDNSConfigNameserversList>;
+export interface FlyDnsOption {
+    name?: string;
+    value?: string;
+}
+export declare const FlyDnsOption: S.Schema<FlyDnsOption>;
+export type FlyDNSConfigOptionsList = Array<FlyDnsOption>;
+export declare const FlyDNSConfigOptionsList: S.Schema<FlyDNSConfigOptionsList>;
+export type FlyDNSConfigSearchesList = Array<string>;
+export declare const FlyDNSConfigSearchesList: S.Schema<FlyDNSConfigSearchesList>;
+export interface FlyDNSConfig {
+    dns_forward_rules?: FlyDNSConfigDnsForwardRulesList;
+    hostname?: string;
+    hostname_fqdn?: string;
+    nameservers?: FlyDNSConfigNameserversList;
+    options?: FlyDNSConfigOptionsList;
+    searches?: FlyDNSConfigSearchesList;
+    skip_registration?: boolean;
+}
+export declare const FlyDNSConfig: S.Schema<FlyDNSConfig>;
+/** An object filled with key/value pairs to be set as environment variables */
+export type FlyMachineConfigEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const FlyMachineConfigEnvMap: S.Schema<FlyMachineConfigEnvMap>;
+export type FlyMachineConfigFilesList = Array<FlyFile>;
+export declare const FlyMachineConfigFilesList: S.Schema<FlyMachineConfigFilesList>;
+export type FlyMachineGuestKernelArgsList = Array<string>;
+export declare const FlyMachineGuestKernelArgsList: S.Schema<FlyMachineGuestKernelArgsList>;
+/** Deprecated: use MachineConfig.Rootfs instead */
+export type FlyMachineGuestPersistRootfs = "never" | "always" | "restart";
+export declare const FlyMachineGuestPersistRootfs: any;
+export interface FlyMachineGuest {
+    cpu_kind?: string;
+    cpus?: number;
+    gpu_kind?: string;
+    gpus?: number;
+    host_dedication_id?: string;
+    kernel_args?: FlyMachineGuestKernelArgsList;
+    max_memory_mb?: number;
+    memory_mb?: number;
+    /** Deprecated: use MachineConfig.Rootfs instead */
+    persist_rootfs?: FlyMachineGuestPersistRootfs | (string & {});
+}
+export declare const FlyMachineGuest: S.Schema<FlyMachineGuest>;
+export type FlyMachineInitCmdList = Array<string>;
+export declare const FlyMachineInitCmdList: S.Schema<FlyMachineInitCmdList>;
+export type FlyMachineInitEntrypointList = Array<string>;
+export declare const FlyMachineInitEntrypointList: S.Schema<FlyMachineInitEntrypointList>;
+export type FlyMachineInitExecList = Array<string>;
+export declare const FlyMachineInitExecList: S.Schema<FlyMachineInitExecList>;
+export type FlyMachineInitKernelArgsList = Array<string>;
+export declare const FlyMachineInitKernelArgsList: S.Schema<FlyMachineInitKernelArgsList>;
+export interface FlyMachineInit {
+    cmd?: FlyMachineInitCmdList;
+    entrypoint?: FlyMachineInitEntrypointList;
+    exec?: FlyMachineInitExecList;
+    kernel_args?: FlyMachineInitKernelArgsList;
+    swap_size_mb?: number;
+    tty?: boolean;
+}
+export declare const FlyMachineInit: S.Schema<FlyMachineInit>;
+export type FlyMachineConfigMetadataMap = {
+    [key: string]: string | undefined;
+};
+export declare const FlyMachineConfigMetadataMap: S.Schema<FlyMachineConfigMetadataMap>;
+export interface FlyMachineMetrics {
+    https?: boolean;
+    path?: string;
+    port?: number;
+}
+export declare const FlyMachineMetrics: S.Schema<FlyMachineMetrics>;
+export interface FlyMachineMount {
+    add_size_gb?: number;
+    encrypted?: boolean;
+    extend_threshold_percent?: number;
+    name?: string;
+    path?: string;
+    size_gb?: number;
+    size_gb_limit?: number;
+    volume?: string;
+}
+export declare const FlyMachineMount: S.Schema<FlyMachineMount>;
+export type FlyMachineConfigMountsList = Array<FlyMachineMount>;
+export declare const FlyMachineConfigMountsList: S.Schema<FlyMachineConfigMountsList>;
+export type FlyMachineProcessCmdList = Array<string>;
+export declare const FlyMachineProcessCmdList: S.Schema<FlyMachineProcessCmdList>;
+export type FlyMachineProcessEntrypointList = Array<string>;
+export declare const FlyMachineProcessEntrypointList: S.Schema<FlyMachineProcessEntrypointList>;
+export type FlyMachineProcessEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const FlyMachineProcessEnvMap: S.Schema<FlyMachineProcessEnvMap>;
+/** EnvFrom can be provided to set environment variables from machine fields. */
+export type FlyMachineProcessEnvFromList = Array<FlyEnvFrom>;
+export declare const FlyMachineProcessEnvFromList: S.Schema<FlyMachineProcessEnvFromList>;
+export type FlyMachineProcessExecList = Array<string>;
+export declare const FlyMachineProcessExecList: S.Schema<FlyMachineProcessExecList>;
+/** 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. */
+export type FlyMachineProcessSecretsList = Array<FlyMachineSecret>;
+export declare const FlyMachineProcessSecretsList: S.Schema<FlyMachineProcessSecretsList>;
+export interface FlyMachineProcess {
+    cmd?: FlyMachineProcessCmdList;
+    entrypoint?: FlyMachineProcessEntrypointList;
+    env?: FlyMachineProcessEnvMap;
+    /** EnvFrom can be provided to set environment variables from machine fields. */
+    env_from?: FlyMachineProcessEnvFromList;
+    exec?: FlyMachineProcessExecList;
+    /** IgnoreAppSecrets can be set to true to ignore the secrets for the App the Machine belongs to and only use the secrets provided at the process level. The default/legacy behavior is to use the secrets provided at the App level. */
+    ignore_app_secrets?: boolean;
+    /** 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?: FlyMachineProcessSecretsList;
+    user?: string;
+}
+export declare const FlyMachineProcess: S.Schema<FlyMachineProcess>;
+export type FlyMachineConfigProcessesList = Array<FlyMachineProcess>;
+export declare const FlyMachineConfigProcessesList: S.Schema<FlyMachineConfigProcessesList>;
+export type FlyMachineRootfsPersist = "never" | "always" | "restart";
+export declare const FlyMachineRootfsPersist: any;
+export interface FlyMachineRootfs {
+    persist?: FlyMachineRootfsPersist | (string & {});
+    size_gb?: number;
+}
+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 FlyMachineServiceCheckHeadersList = Array<FlyMachineHTTPHeader>;
+export declare const FlyMachineServiceCheckHeadersList: S.Schema<FlyMachineServiceCheckHeadersList>;
+export interface FlyMachineServiceCheck {
+    /** The time to wait after a VM starts before checking its health */
+    grace_period?: string;
+    headers?: FlyMachineServiceCheckHeadersList;
+    /** The time between connectivity checks */
+    interval?: string;
+    /** For http checks, the HTTP method to use to when making the request */
+    method?: string;
+    /** For http checks, the path to send the request to */
+    path?: string;
+    /** The port to connect to, often the same as internal_port */
+    port?: number;
+    /** For http checks, whether to use http or https */
+    protocol?: string;
+    /** The maximum time a connection can take before being reported as failing its health check */
+    timeout?: string;
+    /** If the protocol is https, the hostname to use for TLS certificate validation */
+    tls_server_name?: string;
+    /** For http checks with https protocol, whether or not to verify the TLS certificate */
+    tls_skip_verify?: boolean;
+    /** tcp or http */
+    type?: string;
+}
+export declare const FlyMachineServiceCheck: S.Schema<FlyMachineServiceCheck>;
+/** An optional list of service checks */
+export type FlyMachineServiceChecksList = Array<FlyMachineServiceCheck>;
+export declare const FlyMachineServiceChecksList: S.Schema<FlyMachineServiceChecksList>;
+export interface FlyMachineServiceConcurrency {
+    hard_limit?: number;
+    soft_limit?: number;
+    type?: string;
+}
+export declare const FlyMachineServiceConcurrency: S.Schema<FlyMachineServiceConcurrency>;
+export type FlyMachinePortHandlersList = Array<string>;
+export declare const FlyMachinePortHandlersList: S.Schema<FlyMachinePortHandlersList>;
+/** Currently either "cookie" or "header" */
+export type FlyReplayCacheType = "cookie" | "header";
+export declare const FlyReplayCacheType: any;
+export interface FlyReplayCache {
+    allow_bypass?: boolean;
+    /** Name of the cookie or header to key the cache on */
+    name?: string;
+    path_prefix?: string;
+    ttl_seconds?: number;
+    /** Currently either "cookie" or "header" */
+    type?: FlyReplayCacheType | (string & {});
+}
+export declare const FlyReplayCache: S.Schema<FlyReplayCache>;
+export type FlyHTTPOptionsReplayCacheList = Array<FlyReplayCache>;
+export declare const FlyHTTPOptionsReplayCacheList: S.Schema<FlyHTTPOptionsReplayCacheList>;
+export type FlyHTTPResponseOptionsHeadersMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const FlyHTTPResponseOptionsHeadersMap: S.Schema<FlyHTTPResponseOptionsHeadersMap>;
+export interface FlyHTTPResponseOptions {
+    headers?: FlyHTTPResponseOptionsHeadersMap;
+    pristine?: boolean;
+}
+export declare const FlyHTTPResponseOptions: S.Schema<FlyHTTPResponseOptions>;
+export interface FlyHTTPOptions {
+    compress?: boolean;
+    h2_backend?: boolean;
+    headers_read_timeout?: number;
+    idle_timeout?: number;
+    replay_cache?: FlyHTTPOptionsReplayCacheList;
+    response?: FlyHTTPResponseOptions;
+}
+export declare const FlyHTTPOptions: S.Schema<FlyHTTPOptions>;
+export interface FlyProxyProtoOptions {
+    version?: string;
+}
+export declare const FlyProxyProtoOptions: S.Schema<FlyProxyProtoOptions>;
+export type FlyTLSOptionsAlpnList = Array<string>;
+export declare const FlyTLSOptionsAlpnList: S.Schema<FlyTLSOptionsAlpnList>;
+export type FlyTLSOptionsVersionsList = Array<string>;
+export declare const FlyTLSOptionsVersionsList: S.Schema<FlyTLSOptionsVersionsList>;
+export interface FlyTLSOptions {
+    alpn?: FlyTLSOptionsAlpnList;
+    default_self_signed?: boolean;
+    versions?: FlyTLSOptionsVersionsList;
+}
+export declare const FlyTLSOptions: S.Schema<FlyTLSOptions>;
+export interface FlyMachinePort {
+    end_port?: number;
+    force_https?: boolean;
+    handlers?: FlyMachinePortHandlersList;
+    http_options?: FlyHTTPOptions;
+    port?: number;
+    proxy_proto_options?: FlyProxyProtoOptions;
+    start_port?: number;
+    tls_options?: FlyTLSOptions;
+}
+export declare const FlyMachinePort: S.Schema<FlyMachinePort>;
+export type FlyMachineServicePortsList = Array<FlyMachinePort>;
+export declare const FlyMachineServicePortsList: S.Schema<FlyMachineServicePortsList>;
+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 & {});
+    /** An optional list of service checks */
+    checks?: FlyMachineServiceChecksList;
+    concurrency?: FlyMachineServiceConcurrency;
+    force_instance_description?: string;
+    force_instance_key?: string;
+    internal_port?: number;
+    min_machines_running?: number;
+    ports?: FlyMachineServicePortsList;
+    protocol?: string;
+}
+export declare const FlyMachineService: S.Schema<FlyMachineService>;
+export type FlyMachineConfigServicesList = Array<FlyMachineService>;
+export declare const FlyMachineConfigServicesList: S.Schema<FlyMachineConfigServicesList>;
+export interface FlyMachineSpot {
+    /** MaxPriceFraction is the maximum fraction of the full Machine price you will pay for this Machine. Range: (0, 1.0] */
+    max_price_fraction?: number;
+}
+export declare const FlyMachineSpot: S.Schema<FlyMachineSpot>;
+/** Standbys enable a machine to be a standby for another. In the event of a hardware failure, the standby machine will be started. */
+export type FlyMachineConfigStandbysList = Array<string>;
+export declare const FlyMachineConfigStandbysList: S.Schema<FlyMachineConfigStandbysList>;
+export interface FlyStatic {
+    guest_path: string;
+    index_document?: string;
+    tigris_bucket?: string;
+    url_prefix: string;
+}
+export declare const FlyStatic: S.Schema<FlyStatic>;
+export type FlyMachineConfigStaticsList = Array<FlyStatic>;
+export declare const FlyMachineConfigStaticsList: S.Schema<FlyMachineConfigStaticsList>;
+export interface FlyMachineConfig {
+    /** Optional boolean telling the Machine to destroy itself once it’s complete (default false) */
+    auto_destroy?: boolean;
+    cache_drive?: FlyMachineCacheDrive;
+    /** An optional object that defines one or more named top-level checks. The key for each check is the check name. */
+    checks?: FlyMachineConfigChecksMap;
+    /** Containers are a list of containers that will run in the machine. Currently restricted to only specific organizations. */
+    containers?: FlyMachineConfigContainersList;
+    /** Deprecated: use Service.Autostart instead */
+    disable_machine_autostart?: boolean;
+    dns?: FlyDNSConfig;
+    /** An object filled with key/value pairs to be set as environment variables */
+    env?: FlyMachineConfigEnvMap;
+    files?: FlyMachineConfigFilesList;
+    guest?: FlyMachineGuest;
+    /** The docker image to run */
+    image?: string;
+    init?: FlyMachineInit;
+    metadata?: FlyMachineConfigMetadataMap;
+    metrics?: FlyMachineMetrics;
+    mounts?: FlyMachineConfigMountsList;
+    processes?: FlyMachineConfigProcessesList;
+    restart?: FlyMachineRestart;
+    rootfs?: FlyMachineRootfs;
+    schedule?: string;
+    services?: FlyMachineConfigServicesList;
+    /** Deprecated: use Guest instead */
+    size?: string;
+    spot?: FlyMachineSpot;
+    /** Standbys enable a machine to be a standby for another. In the event of a hardware failure, the standby machine will be started. */
+    standbys?: FlyMachineConfigStandbysList;
+    statics?: FlyMachineConfigStaticsList;
+    stop_config?: FlyStopConfig;
+}
+export declare const FlyMachineConfig: S.Schema<FlyMachineConfig>;
+export interface MachinesCreateRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** An object defining the Machine configuration */
+    config?: FlyMachineConfig;
+    lease_ttl?: number;
+    min_secrets_version?: number;
+    /** Unique name for this Machine. If omitted, one is generated for you */
+    name?: string;
+    /** The target region. Omitting this param launches in the same region as your WireGuard peer connection (somewhere near you). */
+    region?: string;
+    skip_launch?: boolean;
+    skip_secrets?: boolean;
+    skip_service_registration?: boolean;
+}
+export declare const MachinesCreateRequest: S.Schema<MachinesCreateRequest>;
+export interface CheckStatus {
+    name?: string;
+    output?: string;
+    status?: string;
+    updated_at?: string;
+}
+export declare const CheckStatus: S.Schema<CheckStatus>;
+export type MachineChecksList = Array<CheckStatus>;
+export declare const MachineChecksList: S.Schema<MachineChecksList>;
+export interface MachineEvent {
+    id?: string;
+    request?: unknown;
+    source?: string;
+    status?: string;
+    timestamp?: number;
+    type?: string;
+}
+export declare const MachineEvent: S.Schema<MachineEvent>;
+export type MachineEventsList = Array<MachineEvent>;
+export declare const MachineEventsList: S.Schema<MachineEventsList>;
+export type MachineHostStatus = "ok" | "unknown" | "unreachable";
+export declare const MachineHostStatus: any;
+export type ImageRefLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const ImageRefLabelsMap: S.Schema<ImageRefLabelsMap>;
+export interface ImageRef {
+    digest?: string;
+    labels?: ImageRefLabelsMap;
+    registry?: string;
+    repository?: string;
+    tag?: string;
+}
+export declare const ImageRef: S.Schema<ImageRef>;
+export interface Machine {
+    checks?: MachineChecksList;
+    config?: FlyMachineConfig;
+    created_at?: string;
+    events?: MachineEventsList;
+    host_status?: MachineHostStatus;
+    id?: string;
+    image_ref?: ImageRef;
+    incomplete_config?: FlyMachineConfig;
+    /** InstanceID is unique for each version of the machine */
+    instance_id?: string;
+    name?: string;
+    /** Nonce is only every returned on machine creation if a lease_duration was provided. */
+    nonce?: string;
+    /** PrivateIP is the internal 6PN address of the machine. */
+    private_ip?: string;
+    region?: string;
+    state?: string;
+    updated_at?: string;
+}
+export declare const Machine: S.Schema<Machine>;
+export interface MachinesCreateLeaseRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    description?: string;
+    /** seconds lease will be valid */
+    ttl?: number;
+}
+export declare const MachinesCreateLeaseRequest: S.Schema<MachinesCreateLeaseRequest>;
+export interface Lease {
+    /** Description or reason for the Lease. */
+    description?: string;
+    /** ExpiresAt is the unix timestamp in UTC to denote when the Lease will no longer be valid. */
+    expires_at?: number;
+    /** Nonce is the unique ID autogenerated and associated with the Lease. */
+    nonce?: string;
+    /** Owner is the user identifier which acquired the Lease. */
+    owner?: string;
+    /** Machine version */
+    version?: string;
+}
+export declare const Lease: S.Schema<Lease>;
+export interface MachinesDeleteRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    /** Force kill the machine if it's running */
+    force?: boolean;
+}
+export declare const MachinesDeleteRequest: S.Schema<MachinesDeleteRequest>;
+export interface MachinesDeleteResponse {
+}
+export declare const MachinesDeleteResponse: S.Schema<MachinesDeleteResponse>;
+export interface MachinesDeleteMetadataRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    /** Metadata Key */
+    key: string;
+}
+export declare const MachinesDeleteMetadataRequest: S.Schema<MachinesDeleteMetadataRequest>;
+export interface MachinesDeleteMetadataResponse {
+}
+export declare const MachinesDeleteMetadataResponse: S.Schema<MachinesDeleteMetadataResponse>;
+export type MachinesExecRequestCommandList = Array<string>;
+export declare const MachinesExecRequestCommandList: S.Schema<MachinesExecRequestCommandList>;
+export interface MachinesExecRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    /** Deprecated: use Command instead */
+    cmd?: string;
+    command?: MachinesExecRequestCommandList;
+    container?: string;
+    stdin?: string;
+    timeout?: number;
+}
+export declare const MachinesExecRequest: S.Schema<MachinesExecRequest>;
+export interface Flydv1ExecResponse {
+    exit_code?: number;
+    exit_signal?: number;
+    stderr?: string;
+    stdout?: string;
+}
+export declare const Flydv1ExecResponse: S.Schema<Flydv1ExecResponse>;
+export interface MachinesGetMemoryRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+}
+export declare const MachinesGetMemoryRequest: S.Schema<MachinesGetMemoryRequest>;
+export interface MainMemoryResponse {
+    available_mb?: number;
+    limit_mb?: number;
+}
+export declare const MainMemoryResponse: S.Schema<MainMemoryResponse>;
+export interface MachinesGetMetadataKeyRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    /** Metadata Key */
+    key: string;
+}
+export declare const MachinesGetMetadataKeyRequest: S.Schema<MachinesGetMetadataKeyRequest>;
+export interface MetadataValueResponse {
+    value?: string;
+}
+export declare const MetadataValueResponse: S.Schema<MetadataValueResponse>;
+export interface MachinesListRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Include deleted machines */
+    include_deleted?: boolean;
+    /** Region filter */
+    region?: string;
+    /** comma separated list of states to filter (created, started, stopped, suspended) */
+    state?: string;
+    /** Only return summary info about machines (omit config, checks, events, host_status, nonce, etc.) */
+    summary?: boolean;
+}
+export declare const MachinesListRequest: S.Schema<MachinesListRequest>;
+export type MachinesListResponseBodyList = Array<Machine>;
+export declare const MachinesListResponseBodyList: S.Schema<MachinesListResponseBodyList>;
+export type MachinesListResponse = MachinesListResponseBodyList;
+export declare const MachinesListResponse: S.Schema<MachinesListResponse>;
+export interface MachinesListEventsRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    /** The number of events to fetch (max of 50). If omitted, this is set to 20 by default. */
+    limit?: number;
+}
+export declare const MachinesListEventsRequest: S.Schema<MachinesListEventsRequest>;
+export type MachinesListEventsResponseBodyList = Array<MachineEvent>;
+export declare const MachinesListEventsResponseBodyList: S.Schema<MachinesListEventsResponseBodyList>;
+export type MachinesListEventsResponse = MachinesListEventsResponseBodyList;
+export declare const MachinesListEventsResponse: S.Schema<MachinesListEventsResponse>;
+export interface MachinesListProcessesRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    /** Sort by */
+    sort_by?: string;
+    /** Order */
+    order?: string;
+}
+export declare const MachinesListProcessesRequest: S.Schema<MachinesListProcessesRequest>;
+export interface ListenSocket {
+    address?: string;
+    proto?: string;
+}
+export declare const ListenSocket: S.Schema<ListenSocket>;
+export type ProcessStatListenSocketsList = Array<ListenSocket>;
+export declare const ProcessStatListenSocketsList: S.Schema<ProcessStatListenSocketsList>;
+export interface ProcessStat {
+    command?: string;
+    cpu?: number;
+    directory?: string;
+    listen_sockets?: ProcessStatListenSocketsList;
+    pid?: number;
+    rss?: number;
+    rtime?: number;
+    stime?: number;
+}
+export declare const ProcessStat: S.Schema<ProcessStat>;
+export type MachinesListProcessesResponseBodyList = Array<ProcessStat>;
+export declare const MachinesListProcessesResponseBodyList: S.Schema<MachinesListProcessesResponseBodyList>;
+export type MachinesListProcessesResponse = MachinesListProcessesResponseBodyList;
+export declare const MachinesListProcessesResponse: S.Schema<MachinesListProcessesResponse>;
+export interface MachinesListVersionsRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+}
+export declare const MachinesListVersionsRequest: S.Schema<MachinesListVersionsRequest>;
+export interface MachineVersion {
+    user_config?: FlyMachineConfig;
+    version?: string;
+}
+export declare const MachineVersion: S.Schema<MachineVersion>;
+export type MachinesListVersionsResponseBodyList = Array<MachineVersion>;
+export declare const MachinesListVersionsResponseBodyList: S.Schema<MachinesListVersionsResponseBodyList>;
+export type MachinesListVersionsResponse = MachinesListVersionsResponseBodyList;
+export declare const MachinesListVersionsResponse: S.Schema<MachinesListVersionsResponse>;
+export interface MachinesOrgListRequest {
+    /** Fly Organization Slug */
+    org_slug: string;
+    /** Include deleted machines */
+    include_deleted?: boolean;
+    /** Region filter */
+    region?: string;
+    /** Comma separated list of states to filter (created, started, stopped, suspended) */
+    state?: string;
+    /** Omit config from responses */
+    summary?: boolean;
+    /** Only return machines updated after this time. Timestamp must be in the RFC 3339 format */
+    updated_after?: string;
+    /** Pagination cursor from previous response (takes precedence over updated_after). Note that there is no guarantee that all machines returned by this endpoint are sorted by their updated_at fields. Pagination may reveal machines older than the last updated_at. */
+    cursor?: string;
+    /** The number of machines to fetch (max of 1000). This limit is advisory. Responses may be shorter, or even empty, even when more machines remain. If omitted, the maximum is used */
+    limit?: number;
+}
+export declare const MachinesOrgListRequest: S.Schema<MachinesOrgListRequest>;
+export type OrgMachinesResponseErrorRegionsList = Array<string>;
+export declare const OrgMachinesResponseErrorRegionsList: S.Schema<OrgMachinesResponseErrorRegionsList>;
+export type MachineOverviewConfigMetadataMap = {
+    [key: string]: string | undefined;
+};
+export declare const MachineOverviewConfigMetadataMap: S.Schema<MachineOverviewConfigMetadataMap>;
+export interface MachineOverviewConfig {
+    guest?: FlyMachineGuest;
+    image?: string;
+    metadata?: MachineOverviewConfigMetadataMap;
+}
+export declare const MachineOverviewConfig: S.Schema<MachineOverviewConfig>;
+export interface OrgMachine {
+    app_name?: string;
+    config?: MachineOverviewConfig;
+    created_at?: string;
+    id?: string;
+    name?: string;
+    private_ip?: string;
+    region?: string;
+    state?: string;
+    updated_at?: string;
+    version?: string;
+}
+export declare const OrgMachine: S.Schema<OrgMachine>;
+export type OrgMachinesResponseMachinesList = Array<OrgMachine>;
+export declare const OrgMachinesResponseMachinesList: S.Schema<OrgMachinesResponseMachinesList>;
+export interface OrgMachinesResponse {
+    error_regions?: OrgMachinesResponseErrorRegionsList;
+    last_machine_id?: string;
+    last_updated_at?: string;
+    machines?: OrgMachinesResponseMachinesList;
+    next_cursor?: string;
+}
+export declare const OrgMachinesResponse: S.Schema<OrgMachinesResponse>;
+export interface MachinesReclaimMemoryRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    amount_mb?: number;
+}
+export declare const MachinesReclaimMemoryRequest: S.Schema<MachinesReclaimMemoryRequest>;
+export interface MainReclaimMemoryResponse {
+    actual_mb?: number;
+}
+export declare const MainReclaimMemoryResponse: S.Schema<MainReclaimMemoryResponse>;
+export interface MachinesReleaseLeaseRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+}
+export declare const MachinesReleaseLeaseRequest: S.Schema<MachinesReleaseLeaseRequest>;
+export interface MachinesReleaseLeaseResponse {
+}
+export declare const MachinesReleaseLeaseResponse: S.Schema<MachinesReleaseLeaseResponse>;
+export type MachinesRestartRequestSignal = "SIGHUP" | "SIGINT" | "SIGQUIT" | "SIGKILL" | "SIGUSR1" | "SIGUSR2" | "SIGTERM";
+export declare const MachinesRestartRequestSignal: any;
+export interface MachinesRestartRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    /** Restart timeout as a Go duration string or number of seconds */
+    timeout?: string;
+    /** Unix signal name */
+    signal?: MachinesRestartRequestSignal | (string & {});
+}
+export declare const MachinesRestartRequest: S.Schema<MachinesRestartRequest>;
+export interface MachinesRestartResponse {
+}
+export declare const MachinesRestartResponse: S.Schema<MachinesRestartResponse>;
+export interface MachinesSetMemoryLimitRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    limit_mb?: number;
+}
+export declare const MachinesSetMemoryLimitRequest: S.Schema<MachinesSetMemoryLimitRequest>;
+export interface MachinesShowRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+}
+export declare const MachinesShowRequest: S.Schema<MachinesShowRequest>;
+export interface MachinesShowLeaseRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+}
+export declare const MachinesShowLeaseRequest: S.Schema<MachinesShowLeaseRequest>;
+export interface MachinesShowMetadataRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+}
+export declare const MachinesShowMetadataRequest: S.Schema<MachinesShowMetadataRequest>;
+export type MachinesShowMetadataResponseBodyMap = {
+    [key: string]: string | undefined;
+};
+export declare const MachinesShowMetadataResponseBodyMap: S.Schema<MachinesShowMetadataResponseBodyMap>;
+export type MachinesShowMetadataResponse = MachinesShowMetadataResponseBodyMap;
+export declare const MachinesShowMetadataResponse: S.Schema<MachinesShowMetadataResponse>;
+export type MachinesSignalRequestSignal = "SIGABRT" | "SIGALRM" | "SIGFPE" | "SIGHUP" | "SIGILL" | "SIGINT" | "SIGKILL" | "SIGPIPE" | "SIGQUIT" | "SIGSEGV" | "SIGTERM" | "SIGTRAP" | "SIGUSR1" | "SIGUSR2";
+export declare const MachinesSignalRequestSignal: any;
+export interface MachinesSignalRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    signal?: MachinesSignalRequestSignal | (string & {});
+}
+export declare const MachinesSignalRequest: S.Schema<MachinesSignalRequest>;
+export interface MachinesSignalResponse {
+}
+export declare const MachinesSignalResponse: S.Schema<MachinesSignalResponse>;
+export interface MachinesStartRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+}
+export declare const MachinesStartRequest: S.Schema<MachinesStartRequest>;
+export interface MachinesStartResponse {
+}
+export declare const MachinesStartResponse: S.Schema<MachinesStartResponse>;
+export type MachinesStopRequestSignal = "SIGHUP" | "SIGINT" | "SIGQUIT" | "SIGKILL" | "SIGUSR1" | "SIGUSR2" | "SIGTERM";
+export declare const MachinesStopRequestSignal: any;
+export interface MachinesStopRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    signal?: MachinesStopRequestSignal | (string & {});
+    timeout?: string;
+}
+export declare const MachinesStopRequest: S.Schema<MachinesStopRequest>;
+export interface MachinesStopResponse {
+}
+export declare const MachinesStopResponse: S.Schema<MachinesStopResponse>;
+export interface MachinesSuspendRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+}
+export declare const MachinesSuspendRequest: S.Schema<MachinesSuspendRequest>;
+export interface MachinesSuspendResponse {
+}
+export declare const MachinesSuspendResponse: S.Schema<MachinesSuspendResponse>;
+export interface MachinesUncordonRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+}
+export declare const MachinesUncordonRequest: S.Schema<MachinesUncordonRequest>;
+export interface MachinesUncordonResponse {
+}
+export declare const MachinesUncordonResponse: S.Schema<MachinesUncordonResponse>;
+export interface MachinesUpdateRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    /** An object defining the Machine configuration */
+    config?: FlyMachineConfig;
+    current_version?: string;
+    lease_ttl?: number;
+    min_secrets_version?: number;
+    /** Unique name for this Machine. If omitted, one is generated for you */
+    name?: string;
+    /** The target region. Omitting this param launches in the same region as your WireGuard peer connection (somewhere near you). */
+    region?: string;
+    skip_launch?: boolean;
+    skip_secrets?: boolean;
+    skip_service_registration?: boolean;
+}
+export declare const MachinesUpdateRequest: S.Schema<MachinesUpdateRequest>;
+export type MachinesUpdateMetadataRequestMetadataMap = {
+    [key: string]: string | undefined;
+};
+export declare const MachinesUpdateMetadataRequestMetadataMap: S.Schema<MachinesUpdateMetadataRequestMetadataMap>;
+export interface MachinesUpdateMetadataRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    machine_version?: string;
+    metadata?: MachinesUpdateMetadataRequestMetadataMap;
+    updated_at?: string;
+}
+export declare const MachinesUpdateMetadataRequest: S.Schema<MachinesUpdateMetadataRequest>;
+export interface MachinesUpdateMetadataResponse {
+}
+export declare const MachinesUpdateMetadataResponse: S.Schema<MachinesUpdateMetadataResponse>;
+export type MachinesUpdateMetadataRequestMetadataMap2 = {
+    [key: string]: string | undefined;
+};
+export declare const MachinesUpdateMetadataRequestMetadataMap2: S.Schema<MachinesUpdateMetadataRequestMetadataMap2>;
+export interface MachinesUpdateMetadataRequest2 {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    machine_version?: string;
+    metadata?: MachinesUpdateMetadataRequestMetadataMap2;
+    updated_at?: string;
+}
+export declare const MachinesUpdateMetadataRequest2: S.Schema<MachinesUpdateMetadataRequest2>;
+export interface MachinesUpdateMetadata2Response {
+}
+export declare const MachinesUpdateMetadata2Response: S.Schema<MachinesUpdateMetadata2Response>;
+export interface MachinesUpsertMetadataRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    /** Metadata Key */
+    key: string;
+    updated_at?: string;
+    value?: string;
+}
+export declare const MachinesUpsertMetadataRequest: S.Schema<MachinesUpsertMetadataRequest>;
+export interface MachinesUpsertMetadataResponse {
+}
+export declare const MachinesUpsertMetadataResponse: S.Schema<MachinesUpsertMetadataResponse>;
+export type MachinesWaitRequestState = "started" | "stopped" | "suspended" | "destroyed" | "failed" | "settled";
+export declare const MachinesWaitRequestState: any;
+export interface MachinesWaitRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Machine ID */
+    machine_id: string;
+    /** 26-character Machine version ID */
+    version?: string;
+    /** 26-character Machine version ID (deprecated; use version) */
+    instance_id?: string;
+    /** 26-character Machine event ID to start waiting after */
+    from_event_id?: string;
+    /** wait timeout. default 60s */
+    timeout?: number;
+    /** desired state(s), supports repeated or comma-separated values */
+    state?: MachinesWaitRequestState | (string & {});
+}
+export declare const MachinesWaitRequest: S.Schema<MachinesWaitRequest>;
+export interface WaitMachineResponse {
+    event_id?: string;
+    ok?: boolean;
+    state?: string;
+    version?: string;
+}
+export declare const WaitMachineResponse: S.Schema<WaitMachineResponse>;
+export type PlacementWeights = {
+    [key: string]: number | undefined;
+};
+export declare const PlacementWeights: S.Schema<PlacementWeights>;
+export interface PlatformPlacementsPostRequest {
+    /** Resource requirements for the Machine to simulate. Defaults to a performance-1x machine */
+    compute?: FlyMachineGuest;
+    /** Number of machines to simulate placement. Defaults to 0, which returns the org-specific limit for each region. */
+    count?: number;
+    org_slug: string;
+    /** Region expression for placement as a comma-delimited set of regions or aliases. Defaults to "[region],any", to prefer the API endpoint's local region with any other region as fallback. */
+    region?: string;
+    volume_name?: string;
+    volume_size_bytes?: number;
+    /** Optional weights to override default placement preferences. */
+    weights?: PlacementWeights;
+}
+export declare const PlatformPlacementsPostRequest: S.Schema<PlatformPlacementsPostRequest>;
+export interface PlacementRegionPlacement {
+    concurrency?: number;
+    count?: number;
+    region?: string;
+}
+export declare const PlacementRegionPlacement: S.Schema<PlacementRegionPlacement>;
+export type MainGetPlacementsResponseRegionsList = Array<PlacementRegionPlacement>;
+export declare const MainGetPlacementsResponseRegionsList: S.Schema<MainGetPlacementsResponseRegionsList>;
+export interface MainGetPlacementsResponse {
+    regions?: MainGetPlacementsResponseRegionsList;
+}
+export declare const MainGetPlacementsResponse: S.Schema<MainGetPlacementsResponse>;
+export interface PlatformRegionsGetRequest {
+}
+export declare const PlatformRegionsGetRequest: S.Schema<PlatformRegionsGetRequest>;
+export interface MainRegionRow {
+    code?: string;
+    deprecated?: boolean;
+    gateway_available?: boolean;
+    geo_region?: string;
+    latitude?: number;
+    longitude?: number;
+    name?: string;
+    requires_paid_plan?: boolean;
+}
+export declare const MainRegionRow: S.Schema<MainRegionRow>;
+export type MainRegionResponseRegionsList = Array<MainRegionRow>;
+export declare const MainRegionResponseRegionsList: S.Schema<MainRegionResponseRegionsList>;
+export interface MainRegionResponse {
+    nearest?: string;
+    regions?: MainRegionResponseRegionsList;
+}
+export declare const MainRegionResponse: S.Schema<MainRegionResponse>;
+export interface SecretCreateRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** App secret name */
+    secret_name: string;
+    value?: string;
+}
+export declare const SecretCreateRequest: S.Schema<SecretCreateRequest>;
+export interface SetAppSecretResponse {
+    /** DEPRECATED */
+    Version?: number;
+    created_at?: string;
+    digest?: string;
+    name?: string;
+    updated_at?: string;
+    value?: string;
+    version?: number;
+}
+export declare const SetAppSecretResponse: S.Schema<SetAppSecretResponse>;
+export interface SecretDeleteRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** App secret name */
+    secret_name: string;
+}
+export declare const SecretDeleteRequest: S.Schema<SecretDeleteRequest>;
+export interface DeleteAppSecretResponse {
+    /** DEPRECATED */
+    Version?: number;
+    version?: number;
+}
+export declare const DeleteAppSecretResponse: S.Schema<DeleteAppSecretResponse>;
+export interface SecretGetRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** App secret name */
+    secret_name: string;
+    /** Minimum secrets version to return. Returned when setting a new secret */
+    min_version?: string;
+    /** Show the secret value. */
+    show_secrets?: boolean;
+}
+export declare const SecretGetRequest: S.Schema<SecretGetRequest>;
+export interface AppSecret {
+    created_at?: string;
+    digest?: string;
+    name?: string;
+    updated_at?: string;
+    value?: string;
+}
+export declare const AppSecret: S.Schema<AppSecret>;
+export type SecretkeyDecryptRequestAssociatedDataList = Array<number>;
+export declare const SecretkeyDecryptRequestAssociatedDataList: S.Schema<SecretkeyDecryptRequestAssociatedDataList>;
+export type SecretkeyDecryptRequestCiphertextList = Array<number>;
+export declare const SecretkeyDecryptRequestCiphertextList: S.Schema<SecretkeyDecryptRequestCiphertextList>;
+export interface SecretkeyDecryptRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Secret key name */
+    secret_name: string;
+    /** Minimum secrets version to return. Returned when setting a new secret */
+    min_version?: string;
+    associated_data?: SecretkeyDecryptRequestAssociatedDataList;
+    ciphertext?: SecretkeyDecryptRequestCiphertextList;
+}
+export declare const SecretkeyDecryptRequest: S.Schema<SecretkeyDecryptRequest>;
+export type DecryptSecretkeyResponsePlaintextList = Array<number>;
+export declare const DecryptSecretkeyResponsePlaintextList: S.Schema<DecryptSecretkeyResponsePlaintextList>;
+export interface DecryptSecretkeyResponse {
+    plaintext?: DecryptSecretkeyResponsePlaintextList;
+}
+export declare const DecryptSecretkeyResponse: S.Schema<DecryptSecretkeyResponse>;
+export interface SecretkeyDeleteRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Secret key name */
+    secret_name: string;
+}
+export declare const SecretkeyDeleteRequest: S.Schema<SecretkeyDeleteRequest>;
+export interface DeleteSecretkeyResponse {
+    /** DEPRECATED */
+    Version?: number;
+    version?: number;
+}
+export declare const DeleteSecretkeyResponse: S.Schema<DeleteSecretkeyResponse>;
+export type SecretkeyEncryptRequestAssociatedDataList = Array<number>;
+export declare const SecretkeyEncryptRequestAssociatedDataList: S.Schema<SecretkeyEncryptRequestAssociatedDataList>;
+export type SecretkeyEncryptRequestPlaintextList = Array<number>;
+export declare const SecretkeyEncryptRequestPlaintextList: S.Schema<SecretkeyEncryptRequestPlaintextList>;
+export interface SecretkeyEncryptRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Secret key name */
+    secret_name: string;
+    /** Minimum secrets version to return. Returned when setting a new secret */
+    min_version?: string;
+    associated_data?: SecretkeyEncryptRequestAssociatedDataList;
+    plaintext?: SecretkeyEncryptRequestPlaintextList;
+}
+export declare const SecretkeyEncryptRequest: S.Schema<SecretkeyEncryptRequest>;
+export type EncryptSecretkeyResponseCiphertextList = Array<number>;
+export declare const EncryptSecretkeyResponseCiphertextList: S.Schema<EncryptSecretkeyResponseCiphertextList>;
+export interface EncryptSecretkeyResponse {
+    ciphertext?: EncryptSecretkeyResponseCiphertextList;
+}
+export declare const EncryptSecretkeyResponse: S.Schema<EncryptSecretkeyResponse>;
+export type SecretkeyGenerateRequestValueList = Array<number>;
+export declare const SecretkeyGenerateRequestValueList: S.Schema<SecretkeyGenerateRequestValueList>;
+export interface SecretkeyGenerateRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Secret key name */
+    secret_name: string;
+    type?: string;
+    value?: SecretkeyGenerateRequestValueList;
+}
+export declare const SecretkeyGenerateRequest: S.Schema<SecretkeyGenerateRequest>;
+export type SetSecretkeyResponsePublicKeyList = Array<number>;
+export declare const SetSecretkeyResponsePublicKeyList: S.Schema<SetSecretkeyResponsePublicKeyList>;
+export interface SetSecretkeyResponse {
+    /** DEPRECATED */
+    Version?: number;
+    created_at?: string;
+    name?: string;
+    public_key?: SetSecretkeyResponsePublicKeyList;
+    type?: string;
+    updated_at?: string;
+    version?: number;
+}
+export declare const SetSecretkeyResponse: S.Schema<SetSecretkeyResponse>;
+export interface SecretkeyGetRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Secret key name */
+    secret_name: string;
+    /** Minimum secrets version to return. Returned when setting a new secret */
+    min_version?: string;
+}
+export declare const SecretkeyGetRequest: S.Schema<SecretkeyGetRequest>;
+export type SecretKeyPublicKeyList = Array<number>;
+export declare const SecretKeyPublicKeyList: S.Schema<SecretKeyPublicKeyList>;
+export interface SecretKey {
+    created_at?: string;
+    name?: string;
+    public_key?: SecretKeyPublicKeyList;
+    type?: string;
+    updated_at?: string;
+}
+export declare const SecretKey: S.Schema<SecretKey>;
+export type SecretkeySetRequestValueList = Array<number>;
+export declare const SecretkeySetRequestValueList: S.Schema<SecretkeySetRequestValueList>;
+export interface SecretkeySetRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Secret key name */
+    secret_name: string;
+    type?: string;
+    value?: SecretkeySetRequestValueList;
+}
+export declare const SecretkeySetRequest: S.Schema<SecretkeySetRequest>;
+export type SecretkeySignRequestPlaintextList = Array<number>;
+export declare const SecretkeySignRequestPlaintextList: S.Schema<SecretkeySignRequestPlaintextList>;
+export interface SecretkeySignRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Secret key name */
+    secret_name: string;
+    /** Minimum secrets version to return. Returned when setting a new secret */
+    min_version?: string;
+    plaintext?: SecretkeySignRequestPlaintextList;
+}
+export declare const SecretkeySignRequest: S.Schema<SecretkeySignRequest>;
+export type SignSecretkeyResponseSignatureList = Array<number>;
+export declare const SignSecretkeyResponseSignatureList: S.Schema<SignSecretkeyResponseSignatureList>;
+export interface SignSecretkeyResponse {
+    signature?: SignSecretkeyResponseSignatureList;
+}
+export declare const SignSecretkeyResponse: S.Schema<SignSecretkeyResponse>;
+export interface SecretkeysListRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Minimum secrets version to return. Returned when setting a new secret */
+    min_version?: string;
+    /** Comma-seperated list of secret keys to list */
+    types?: string;
+}
+export declare const SecretkeysListRequest: S.Schema<SecretkeysListRequest>;
+export type SecretKeysSecretKeysList = Array<SecretKey>;
+export declare const SecretKeysSecretKeysList: S.Schema<SecretKeysSecretKeysList>;
+export interface SecretKeys {
+    secret_keys?: SecretKeysSecretKeysList;
+}
+export declare const SecretKeys: S.Schema<SecretKeys>;
+export type SecretkeyVerifyRequestPlaintextList = Array<number>;
+export declare const SecretkeyVerifyRequestPlaintextList: S.Schema<SecretkeyVerifyRequestPlaintextList>;
+export type SecretkeyVerifyRequestSignatureList = Array<number>;
+export declare const SecretkeyVerifyRequestSignatureList: S.Schema<SecretkeyVerifyRequestSignatureList>;
+export interface SecretkeyVerifyRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Secret key name */
+    secret_name: string;
+    /** Minimum secrets version to return. Returned when setting a new secret */
+    min_version?: string;
+    plaintext?: SecretkeyVerifyRequestPlaintextList;
+    signature?: SecretkeyVerifyRequestSignatureList;
+}
+export declare const SecretkeyVerifyRequest: S.Schema<SecretkeyVerifyRequest>;
+export interface SecretkeyVerifyResponse {
+}
+export declare const SecretkeyVerifyResponse: S.Schema<SecretkeyVerifyResponse>;
+export interface SecretsListRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Minimum secrets version to return. Returned when setting a new secret */
+    min_version?: string;
+    /** Show the secret values. */
+    show_secrets?: boolean;
+}
+export declare const SecretsListRequest: S.Schema<SecretsListRequest>;
+export type AppSecretsSecretsList = Array<AppSecret>;
+export declare const AppSecretsSecretsList: S.Schema<AppSecretsSecretsList>;
+export interface AppSecrets {
+    secrets?: AppSecretsSecretsList;
+}
+export declare const AppSecrets: S.Schema<AppSecrets>;
+export type SecretsUpdateRequestValuesMap = {
+    [key: string]: string | undefined;
+};
+export declare const SecretsUpdateRequestValuesMap: S.Schema<SecretsUpdateRequestValuesMap>;
+export interface SecretsUpdateRequest {
+    /** Fly App Name */
+    app_name: string;
+    values?: SecretsUpdateRequestValuesMap;
+}
+export declare const SecretsUpdateRequest: S.Schema<SecretsUpdateRequest>;
+export type AppSecretsUpdateRespSecretsList = Array<AppSecret>;
+export declare const AppSecretsUpdateRespSecretsList: S.Schema<AppSecretsUpdateRespSecretsList>;
+export interface AppSecretsUpdateResp {
+    /** DEPRECATED */
+    Version?: number;
+    secrets?: AppSecretsUpdateRespSecretsList;
+    version?: number;
+}
+export declare const AppSecretsUpdateResp: S.Schema<AppSecretsUpdateResp>;
+export interface TokensAuthenticateRequest {
+    header?: string;
+}
+export declare const TokensAuthenticateRequest: S.Schema<TokensAuthenticateRequest>;
+export type MacaroonCaveatSetCaveatsList = Array<unknown>;
+export declare const MacaroonCaveatSetCaveatsList: S.Schema<MacaroonCaveatSetCaveatsList>;
+export interface MacaroonCaveatSet {
+    caveats?: MacaroonCaveatSetCaveatsList;
+}
+export declare const MacaroonCaveatSet: S.Schema<MacaroonCaveatSet>;
+export type MacaroonNonceKidList = Array<number>;
+export declare const MacaroonNonceKidList: S.Schema<MacaroonNonceKidList>;
+export type MacaroonNonceRndList = Array<number>;
+export declare const MacaroonNonceRndList: S.Schema<MacaroonNonceRndList>;
+export interface MacaroonNonce {
+    kid?: MacaroonNonceKidList;
+    proof?: boolean;
+    rnd?: MacaroonNonceRndList;
+}
+export declare const MacaroonNonce: S.Schema<MacaroonNonce>;
+export type RootVerifiedTokenPermissionTokenList = Array<number>;
+export declare const RootVerifiedTokenPermissionTokenList: S.Schema<RootVerifiedTokenPermissionTokenList>;
+export interface RootVerifiedToken {
+    caveats?: MacaroonCaveatSet;
+    header?: string;
+    nonce?: MacaroonNonce;
+    permission_token?: RootVerifiedTokenPermissionTokenList;
+}
+export declare const RootVerifiedToken: S.Schema<RootVerifiedToken>;
+export type TokensAuthenticateResponseBodyList = Array<RootVerifiedToken>;
+export declare const TokensAuthenticateResponseBodyList: S.Schema<TokensAuthenticateResponseBodyList>;
+export type TokensAuthenticateResponse = TokensAuthenticateResponseBodyList;
+export declare const TokensAuthenticateResponse: S.Schema<TokensAuthenticateResponse>;
+export type RessetAction = 1 | 2 | 4 | 8 | 16 | 31 | 0;
+export declare const RessetAction: any;
+/** Command is the command being executed on a machine. If this is specified, the Machine must be set. */
+export type MainTokenAccessCommandList = Array<string>;
+export declare const MainTokenAccessCommandList: S.Schema<MainTokenAccessCommandList>;
+export interface MainTokenAccess {
+    /** Action is the action being taken on the specified resource. This is the combination of individual action characters (e.g "rw") - r: read - w: write - c: create - d: delete - C: control */
+    action?: RessetAction | (number & {});
+    /** AppFeature is a named set of functionality associated with the app. If this is specified, the AppName field must be set. - images: images in the fly.io registry */
+    app_feature?: string;
+    /** AppName is the name of the app being accessed. */
+    app_name?: string;
+    /** Command is the command being executed on a machine. If this is specified, the Machine must be set. */
+    command?: MainTokenAccessCommandList;
+    /** MachineFeature is a named set of functionality associated with the machine. If this is specified, the Machine field must be set. - metadata: machine metadata service - oidc: OIDC tokens - kmstoken: Petsem tokens for KMS access */
+    machine_feature?: string;
+    /** MachineID is the ID of the machine being accessed (e.g. 7811701f564258). */
+    machine_id?: string;
+    /** Mutation is the GraphQL mutation being performed. */
+    mutation?: string;
+    /** OrgFeature is a named set of functionality associated with the organization. If this is specified, the OrgSlug field must be set. - wg: WireGuard peers - builder: remote builders - addon: addons - membership: organization membership - billing: billing - litefs-cloud: LiteFS Cloud - authentication: authentication settings */
+    org_feature?: string;
+    /** OrgSlug is the slug of the organization being accessed. */
+    org_slug?: string;
+    /** SourceMachine is the machine ID of the actor attempting access. */
+    source_machine?: string;
+    /** StorageObject is the storage object being accessed. If this is specified, the OrgSlug must be set. */
+    storage_object?: string;
+    /** VolumeID is the encoded ID of the volume being accessed (e.g. vol_r1p6pln1k9m9j7zr). */
+    volume_id?: string;
+}
+export declare const MainTokenAccess: S.Schema<MainTokenAccess>;
+export interface TokensAuthorizeRequest {
+    access?: MainTokenAccess;
+    header?: string;
+}
+export declare const TokensAuthorizeRequest: S.Schema<TokensAuthorizeRequest>;
+export type FlyioAccessCommandList = Array<string>;
+export declare const FlyioAccessCommandList: S.Schema<FlyioAccessCommandList>;
+export interface FlyioAccess {
+    action?: RessetAction;
+    app_feature?: string;
+    appid?: number;
+    cluster?: string;
+    command?: FlyioAccessCommandList;
+    feature?: string;
+    machine?: string;
+    machine_feature?: string;
+    mutation?: string;
+    orgid?: number;
+    sourceApp?: string;
+    sourceMachine?: string;
+    sourceOrganization?: string;
+    storage_object?: string;
+    volume?: string;
+}
+export declare const FlyioAccess: S.Schema<FlyioAccess>;
+export interface AuthorizeResponse {
+    access?: FlyioAccess;
+    verified_token?: RootVerifiedToken;
+}
+export declare const AuthorizeResponse: S.Schema<AuthorizeResponse>;
+export interface TokensRequestKmsRequest {
+}
+export declare const TokensRequestKmsRequest: S.Schema<TokensRequestKmsRequest>;
+export interface TokensRequestKmsResponse {
+}
+export declare const TokensRequestKmsResponse: S.Schema<TokensRequestKmsResponse>;
+export interface TokensRequestOIDCRequest {
+    aud?: string;
+    aws_principal_tags?: boolean;
+}
+export declare const TokensRequestOIDCRequest: S.Schema<TokensRequestOIDCRequest>;
+export interface TokensRequestOIDCResponse {
+}
+export declare const TokensRequestOIDCResponse: S.Schema<TokensRequestOIDCResponse>;
+export interface VolumeDeleteRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Volume ID */
+    volume_id: string;
+}
+export declare const VolumeDeleteRequest: S.Schema<VolumeDeleteRequest>;
+export type VolumeHostStatus = "ok" | "unknown" | "unreachable";
+export declare const VolumeHostStatus: any;
+export type VolumeType = "local" | "cache";
+export declare const VolumeType: any;
+export interface Volume {
+    attached_alloc_id?: string;
+    attached_machine_id?: string;
+    auto_backup_enabled?: boolean;
+    block_size?: number;
+    blocks?: number;
+    blocks_avail?: number;
+    blocks_free?: number;
+    bytes_total?: number;
+    bytes_used?: number;
+    created_at?: string;
+    encrypted?: boolean;
+    fstype?: string;
+    host_status?: VolumeHostStatus;
+    id?: string;
+    name?: string;
+    region?: string;
+    size_gb?: number;
+    snapshot_retention?: number;
+    state?: string;
+    type?: VolumeType;
+    zone?: string;
+}
+export declare const Volume: S.Schema<Volume>;
+export interface VolumesCreateRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** enable scheduled automatic snapshots. Defaults to `true` */
+    auto_backup_enabled?: boolean;
+    compute?: FlyMachineGuest;
+    compute_image?: string;
+    encrypted?: boolean;
+    fstype?: string;
+    name?: string;
+    region?: string;
+    require_unique_zone?: boolean;
+    size_gb?: number;
+    /** restore from snapshot */
+    snapshot_id?: string;
+    snapshot_retention?: number;
+    /** fork from remote volume */
+    source_volume_id?: string;
+    unique_zone_app_wide?: boolean;
+}
+export declare const VolumesCreateRequest: S.Schema<VolumesCreateRequest>;
+export interface VolumesExtendRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Volume ID */
+    volume_id: string;
+    size_gb?: number;
+}
+export declare const VolumesExtendRequest: S.Schema<VolumesExtendRequest>;
+export interface ExtendVolumeResponse {
+    needs_restart?: boolean;
+    volume?: Volume;
+}
+export declare const ExtendVolumeResponse: S.Schema<ExtendVolumeResponse>;
+export interface VolumesGetByIdRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Volume ID */
+    volume_id: string;
+}
+export declare const VolumesGetByIdRequest: S.Schema<VolumesGetByIdRequest>;
+export interface VolumesListRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Only return summary info about volumes (omit blocks, block size, etc) */
+    summary?: boolean;
+}
+export declare const VolumesListRequest: S.Schema<VolumesListRequest>;
+export type VolumesListResponseBodyList = Array<Volume>;
+export declare const VolumesListResponseBodyList: S.Schema<VolumesListResponseBodyList>;
+export type VolumesListResponse = VolumesListResponseBodyList;
+export declare const VolumesListResponse: S.Schema<VolumesListResponse>;
+export interface VolumesListSnapshotsRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Volume ID */
+    volume_id: string;
+}
+export declare const VolumesListSnapshotsRequest: S.Schema<VolumesListSnapshotsRequest>;
+export interface VolumeSnapshot {
+    created_at?: string;
+    digest?: string;
+    id?: string;
+    retention_days?: number;
+    size?: number;
+    status?: string;
+    volume_size?: number;
+}
+export declare const VolumeSnapshot: S.Schema<VolumeSnapshot>;
+export type VolumesListSnapshotsResponseBodyList = Array<VolumeSnapshot>;
+export declare const VolumesListSnapshotsResponseBodyList: S.Schema<VolumesListSnapshotsResponseBodyList>;
+export type VolumesListSnapshotsResponse = VolumesListSnapshotsResponseBodyList;
+export declare const VolumesListSnapshotsResponse: S.Schema<VolumesListSnapshotsResponse>;
+export interface VolumesOrgListRequest {
+    /** Fly Organization Slug */
+    org_slug: string;
+    /** Include deleted volumes */
+    include_deleted?: boolean;
+    /** Region filter */
+    region?: string;
+    /** Comma separated list of volume states to filter */
+    state?: string;
+    /** Only return summary info about volumes (omit blocks, block size, etc) */
+    summary?: boolean;
+    /** Only return volumes updated after this time. Timestamp must be in the RFC 3339 format */
+    updated_after?: string;
+    /** Pagination cursor from previous response (takes precedence over updated_after) */
+    cursor?: string;
+    /** The number of volumes to fetch (max of 1000). This limit is advisory. Responses may be shorter, even when more volumes remain. If omitted, the maximum is used */
+    limit?: number;
+}
+export declare const VolumesOrgListRequest: S.Schema<VolumesOrgListRequest>;
+export type OrgVolumeHostStatus = "ok" | "unknown" | "unreachable";
+export declare const OrgVolumeHostStatus: any;
+export type OrgVolumeType = "local" | "cache";
+export declare const OrgVolumeType: any;
+export interface OrgVolume {
+    app_name?: string;
+    attached_alloc_id?: string;
+    attached_machine_id?: string;
+    auto_backup_enabled?: boolean;
+    block_size?: number;
+    blocks?: number;
+    blocks_avail?: number;
+    blocks_free?: number;
+    bytes_total?: number;
+    bytes_used?: number;
+    created_at?: string;
+    encrypted?: boolean;
+    fstype?: string;
+    host_status?: OrgVolumeHostStatus;
+    id?: string;
+    name?: string;
+    region?: string;
+    size_gb?: number;
+    snapshot_retention?: number;
+    state?: string;
+    type?: OrgVolumeType;
+    updated_at?: string;
+    zone?: string;
+}
+export declare const OrgVolume: S.Schema<OrgVolume>;
+export type OrgVolumesResponseVolumesList = Array<OrgVolume>;
+export declare const OrgVolumesResponseVolumesList: S.Schema<OrgVolumesResponseVolumesList>;
+export interface OrgVolumesResponse {
+    last_updated_at?: string;
+    last_volume_id?: string;
+    next_cursor?: string;
+    volumes?: OrgVolumesResponseVolumesList;
+}
+export declare const OrgVolumesResponse: S.Schema<OrgVolumesResponse>;
+export interface VolumesUpdateRequest {
+    /** Fly App Name */
+    app_name: string;
+    /** Volume ID */
+    volume_id: string;
+    auto_backup_enabled?: boolean;
+    snapshot_retention?: number;
+}
+export declare const VolumesUpdateRequest: S.Schema<VolumesUpdateRequest>;
+export type AppCertificatesAcmeCreateError = BadRequest | Forbidden | NotFound | UnprocessableEntity | FlyIoOpError;
+/** Request ACME certificate */
+export declare const appCertificatesAcmeCreate: API.OperationMethod<AppCertificatesAcmeCreateRequest, CertificateDetail, AppCertificatesAcmeCreateError, FlyIoOpContext>;
+export type AppCertificatesAcmeDeleteError = Forbidden | NotFound | FlyIoOpError;
+/** Remove ACME certificates */
+export declare const appCertificatesAcmeDelete: API.OperationMethod<AppCertificatesAcmeDeleteRequest, CertificateDetail, AppCertificatesAcmeDeleteError, FlyIoOpContext>;
+export type AppCertificatesCheckError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Check DNS and re-validate certificate */
+export declare const appCertificatesCheck: API.OperationMethod<AppCertificatesCheckRequest, CertificateCheckResponse, AppCertificatesCheckError, FlyIoOpContext>;
+export type AppCertificatesCustomCreateError = BadRequest | Forbidden | NotFound | UnprocessableEntity | FlyIoOpError;
+/** Upload custom certificate */
+export declare const appCertificatesCustomCreate: API.OperationMethod<AppCertificatesCustomCreateRequest, CertificateDetail, AppCertificatesCustomCreateError, FlyIoOpContext>;
+export type AppCertificatesCustomDeleteError = Forbidden | NotFound | FlyIoOpError;
+/** Remove custom certificate */
+export declare const appCertificatesCustomDelete: API.OperationMethod<AppCertificatesCustomDeleteRequest, DestroyCustomCertificateResponse, AppCertificatesCustomDeleteError, FlyIoOpContext>;
+export type AppCertificatesDeleteError = Forbidden | NotFound | FlyIoOpError;
+/** Remove certificate */
+export declare const appCertificatesDelete: API.OperationMethod<AppCertificatesDeleteRequest, AppCertificatesDeleteResponse, AppCertificatesDeleteError, FlyIoOpContext>;
+export type AppCertificatesListError = Forbidden | NotFound | FlyIoOpError;
+/** List certificates for app */
+export declare const appCertificatesList: API.OperationMethod<AppCertificatesListRequest, ListCertificatesResponse, AppCertificatesListError, FlyIoOpContext>;
+export type AppCertificatesShowError = Forbidden | NotFound | FlyIoOpError;
+/** Get certificate details */
+export declare const appCertificatesShow: API.OperationMethod<AppCertificatesShowRequest, CertificateDetail, AppCertificatesShowError, FlyIoOpContext>;
+export type AppCreateDeployTokenError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Create App deploy token */
+export declare const appCreateDeployToken: API.OperationMethod<AppCreateDeployTokenRequest, CreateAppResponse, AppCreateDeployTokenError, FlyIoOpContext>;
+export type AppIPAssignmentsCreateError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Assign new IP address to app */
+export declare const appIPAssignmentsCreate: API.OperationMethod<AppIPAssignmentsCreateRequest, IPAssignment, AppIPAssignmentsCreateError, FlyIoOpContext>;
+export type AppIPAssignmentsDeleteError = Forbidden | NotFound | FlyIoOpError;
+/** Remove IP assignment from app */
+export declare const appIPAssignmentsDelete: API.OperationMethod<AppIPAssignmentsDeleteRequest, AppIPAssignmentsDeleteResponse, AppIPAssignmentsDeleteError, FlyIoOpContext>;
+export type AppIPAssignmentsListError = Forbidden | NotFound | FlyIoOpError;
+/** List IP assignments for app */
+export declare const appIPAssignmentsList: API.OperationMethod<AppIPAssignmentsListRequest, ListIPAssignmentsResponse, AppIPAssignmentsListError, FlyIoOpContext>;
+export type AppsCreateError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Create App Create an app with the specified details in the request body. */
+export declare const appsCreate: API.OperationMethod<AppsCreateRequest, AppsCreateResponse, AppsCreateError, FlyIoOpContext>;
+export type AppsDeleteError = Forbidden | NotFound | FlyIoOpError;
+/** Destroy App Delete an app by its name. */
+export declare const appsDelete: API.OperationMethod<AppsDeleteRequest, AppsDeleteResponse, AppsDeleteError, FlyIoOpContext>;
+export type AppsListError = Forbidden | FlyIoOpError;
+/** List Apps List all apps with the ability to filter by organization slug. */
+export declare const appsList: API.OperationMethod<AppsListRequest, ListAppsResponse, AppsListError, FlyIoOpContext>;
+export type AppsShowError = Forbidden | NotFound | FlyIoOpError;
+/** Get App Retrieve details about a specific app by its name. */
+export declare const appsShow: API.OperationMethod<AppsShowRequest, App, AppsShowError, FlyIoOpContext>;
+export type CreateVolumeSnapshotError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Create Snapshot Create a snapshot for a specific volume within an app. */
+export declare const createVolumeSnapshot: API.OperationMethod<CreateVolumeSnapshotRequest, CreateVolumeSnapshotResponse, CreateVolumeSnapshotError, FlyIoOpContext>;
+export type CurrentTokenShowError = FlyIoOpError;
+/** Get Current Token Information Get information about the current macaroon token(s), including organizations, apps, user identity hashes, and machine restrictions */
+export declare const currentTokenShow: API.OperationMethod<CurrentTokenShowRequest, CurrentTokenResponse, CurrentTokenShowError, FlyIoOpContext>;
+export type MachinesCordonError = BadRequest | Forbidden | NotFound | 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 machinesCordon: API.OperationMethod<MachinesCordonRequest, MachinesCordonResponse, MachinesCordonError, FlyIoOpContext>;
+export type MachinesCreateError = BadRequest | Forbidden | NotFound | 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 machinesCreate: API.OperationMethod<MachinesCreateRequest, Machine, MachinesCreateError, FlyIoOpContext>;
+export type MachinesCreateLeaseError = BadRequest | Forbidden | NotFound | 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 machinesCreateLease: API.OperationMethod<MachinesCreateLeaseRequest, Lease, MachinesCreateLeaseError, FlyIoOpContext>;
+export type MachinesDeleteError = Forbidden | NotFound | FlyIoOpError;
+/** Destroy Machine Delete a specific Machine within an app by Machine ID, with an optional force parameter to force kill the Machine if it's running. */
+export declare const machinesDelete: API.OperationMethod<MachinesDeleteRequest, MachinesDeleteResponse, MachinesDeleteError, FlyIoOpContext>;
+export type MachinesDeleteMetadataError = Forbidden | NotFound | FlyIoOpError;
+/** Delete Metadata Delete metadata for a specific Machine within an app by providing a metadata key. */
+export declare const machinesDeleteMetadata: API.OperationMethod<MachinesDeleteMetadataRequest, MachinesDeleteMetadataResponse, MachinesDeleteMetadataError, FlyIoOpContext>;
+export type MachinesExecError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Execute Command Execute a command on a specific Machine and return the raw command output bytes. */
+export declare const machinesExec: API.OperationMethod<MachinesExecRequest, Flydv1ExecResponse, MachinesExecError, FlyIoOpContext>;
+export type MachinesGetMemoryError = Forbidden | NotFound | FlyIoOpError;
+/** Get Machine Memory Get current memory limit and available capacity for a machine */
+export declare const machinesGetMemory: API.OperationMethod<MachinesGetMemoryRequest, MainMemoryResponse, MachinesGetMemoryError, FlyIoOpContext>;
+export type MachinesGetMetadataKeyError = NotFound | FlyIoOpError;
+/** Get Metadata Value Get the value of a specific metadata key */
+export declare const machinesGetMetadataKey: API.OperationMethod<MachinesGetMetadataKeyRequest, MetadataValueResponse, MachinesGetMetadataKeyError, FlyIoOpContext>;
+export type MachinesListError = Forbidden | NotFound | FlyIoOpError;
+/** List Machines List all Machines associated with a specific app, with optional filters for including deleted Machines and filtering by region. */
+export declare const machinesList: API.OperationMethod<MachinesListRequest, MachinesListResponse, MachinesListError, FlyIoOpContext>;
+export type MachinesListEventsError = Forbidden | NotFound | FlyIoOpError;
+/** List Events List all events associated with a specific Machine within an app. */
+export declare const machinesListEvents: API.OperationMethod<MachinesListEventsRequest, MachinesListEventsResponse, MachinesListEventsError, FlyIoOpContext>;
+export type MachinesListProcessesError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** List Processes List all processes running on a specific Machine within an app, with optional sorting parameters. */
+export declare const machinesListProcesses: API.OperationMethod<MachinesListProcessesRequest, MachinesListProcessesResponse, MachinesListProcessesError, FlyIoOpContext>;
+export type MachinesListVersionsError = Forbidden | NotFound | FlyIoOpError;
+/** List Versions List all versions of the configuration for a specific Machine within an app. */
+export declare const machinesListVersions: API.OperationMethod<MachinesListVersionsRequest, MachinesListVersionsResponse, MachinesListVersionsError, FlyIoOpContext>;
+export type MachinesOrgListError = Forbidden | NotFound | FlyIoOpError;
+/** List All Machines List all Machines associated with a specific organization. Machines are sorted by their `updated_at` timestamps, oldest to newest. This API call represents "a point in time". Recent machine changes, including creations and destructions, may take time to propagate. When polling with `updated_after`, offset your timestamps to catch late-arriving events. */
+export declare const machinesOrgList: API.OperationMethod<MachinesOrgListRequest, OrgMachinesResponse, MachinesOrgListError, FlyIoOpContext>;
+export type MachinesReclaimMemoryError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Reclaim Machine Memory Trigger the balloon device to reclaim memory from a machine */
+export declare const machinesReclaimMemory: API.OperationMethod<MachinesReclaimMemoryRequest, MainReclaimMemoryResponse, MachinesReclaimMemoryError, FlyIoOpContext>;
+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 MachinesRestartError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Restart Machine Restart a specific Machine within an app, with an optional timeout parameter. */
+export declare const machinesRestart: API.OperationMethod<MachinesRestartRequest, MachinesRestartResponse, MachinesRestartError, FlyIoOpContext>;
+export type MachinesSetMemoryLimitError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Set Machine Memory Limit Set the memory limit for a machine using the balloon device */
+export declare const machinesSetMemoryLimit: API.OperationMethod<MachinesSetMemoryLimitRequest, MainMemoryResponse, MachinesSetMemoryLimitError, FlyIoOpContext>;
+export type MachinesShowError = Forbidden | NotFound | FlyIoOpError;
+/** Get Machine Get details of a specific Machine within an app by the Machine ID. */
+export declare const machinesShow: API.OperationMethod<MachinesShowRequest, Machine, MachinesShowError, FlyIoOpContext>;
+export type MachinesShowLeaseError = 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 machinesShowLease: API.OperationMethod<MachinesShowLeaseRequest, Lease, MachinesShowLeaseError, FlyIoOpContext>;
+export type MachinesShowMetadataError = Forbidden | NotFound | FlyIoOpError;
+/** Get Metadata Retrieve metadata for a specific Machine within an app. */
+export declare const machinesShowMetadata: API.OperationMethod<MachinesShowMetadataRequest, MachinesShowMetadataResponse, MachinesShowMetadataError, FlyIoOpContext>;
+export type MachinesSignalError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Signal Machine Send a signal to a specific Machine within an app using the details provided in the request body. */
+export declare const machinesSignal: API.OperationMethod<MachinesSignalRequest, MachinesSignalResponse, MachinesSignalError, FlyIoOpContext>;
+export type MachinesStartError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Start Machine Start a specific Machine within an app. */
+export declare const machinesStart: API.OperationMethod<MachinesStartRequest, MachinesStartResponse, MachinesStartError, FlyIoOpContext>;
+export type MachinesStopError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Stop Machine Stop a specific Machine within an app, with an optional request body to specify signal and timeout. */
+export declare const machinesStop: API.OperationMethod<MachinesStopRequest, MachinesStopResponse, MachinesStopError, FlyIoOpContext>;
+export type MachinesSuspendError = BadRequest | Forbidden | NotFound | 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 machinesSuspend: API.OperationMethod<MachinesSuspendRequest, MachinesSuspendResponse, MachinesSuspendError, FlyIoOpContext>;
+export type MachinesUncordonError = BadRequest | Forbidden | NotFound | 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 machinesUncordon: API.OperationMethod<MachinesUncordonRequest, MachinesUncordonResponse, MachinesUncordonError, FlyIoOpContext>;
+export type MachinesUpdateError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Update Machine Update a Machine's configuration using the details provided in the request body. */
+export declare const machinesUpdate: API.OperationMethod<MachinesUpdateRequest, Machine, MachinesUpdateError, FlyIoOpContext>;
+export type MachinesUpdateMetadataError = 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 machinesUpdateMetadata: API.OperationMethod<MachinesUpdateMetadataRequest, MachinesUpdateMetadataResponse, MachinesUpdateMetadataError, FlyIoOpContext>;
+export type MachinesUpdateMetadata2Error = 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 declare const machinesUpdateMetadata2: API.OperationMethod<MachinesUpdateMetadataRequest2, MachinesUpdateMetadata2Response, MachinesUpdateMetadata2Error, FlyIoOpContext>;
+export type MachinesUpsertMetadataError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Upsert Metadata Key Update metadata for a specific machine within an app by providing a metadata key. */
+export declare const machinesUpsertMetadata: API.OperationMethod<MachinesUpsertMetadataRequest, MachinesUpsertMetadataResponse, MachinesUpsertMetadataError, FlyIoOpContext>;
+export type MachinesWaitError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Wait for State Wait for a Machine to reach a specific state. Specify the desired state with the state parameter. See the [Machine states table](https://fly.io/docs/machines/working-with-machines/#machine-states) for a list of possible states. The default for this parameter is `started`. This request will block for up to 60 seconds. Set a shorter timeout with the timeout parameter. */
+export declare const machinesWait: API.OperationMethod<MachinesWaitRequest, WaitMachineResponse, MachinesWaitError, FlyIoOpContext>;
+export type PlatformPlacementsPostError = BadRequest | Forbidden | FlyIoOpError;
+/** Get Placements Simulates placing the specified number of machines into regions, depending on available capacity and limits. */
+export declare const platformPlacementsPost: API.OperationMethod<PlatformPlacementsPostRequest, MainGetPlacementsResponse, PlatformPlacementsPostError, FlyIoOpContext>;
+export type PlatformRegionsGetError = Forbidden | FlyIoOpError;
+/** Get Regions List all regions on the platform with their details. */
+export declare const platformRegionsGet: API.OperationMethod<PlatformRegionsGetRequest, MainRegionResponse, PlatformRegionsGetError, FlyIoOpContext>;
+export type SecretCreateError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Create or update Secret */
+export declare const secretCreate: API.OperationMethod<SecretCreateRequest, SetAppSecretResponse, SecretCreateError, FlyIoOpContext>;
+export type SecretDeleteError = Forbidden | NotFound | FlyIoOpError;
+/** Delete an app secret */
+export declare const secretDelete: API.OperationMethod<SecretDeleteRequest, DeleteAppSecretResponse, SecretDeleteError, FlyIoOpContext>;
+export type SecretGetError = Forbidden | NotFound | FlyIoOpError;
+/** Get an app secret */
+export declare const secretGet: API.OperationMethod<SecretGetRequest, AppSecret, SecretGetError, FlyIoOpContext>;
+export type SecretkeyDecryptError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Decrypt with a secret key */
+export declare const secretkeyDecrypt: API.OperationMethod<SecretkeyDecryptRequest, DecryptSecretkeyResponse, SecretkeyDecryptError, FlyIoOpContext>;
+export type SecretkeyDeleteError = Forbidden | NotFound | FlyIoOpError;
+/** Delete an app's secret key */
+export declare const secretkeyDelete: API.OperationMethod<SecretkeyDeleteRequest, DeleteSecretkeyResponse, SecretkeyDeleteError, FlyIoOpContext>;
+export type SecretkeyEncryptError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Encrypt with a secret key */
+export declare const secretkeyEncrypt: API.OperationMethod<SecretkeyEncryptRequest, EncryptSecretkeyResponse, SecretkeyEncryptError, FlyIoOpContext>;
+export type SecretkeyGenerateError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Generate a random secret key */
+export declare const secretkeyGenerate: API.OperationMethod<SecretkeyGenerateRequest, SetSecretkeyResponse, SecretkeyGenerateError, FlyIoOpContext>;
+export type SecretkeyGetError = Forbidden | NotFound | FlyIoOpError;
+/** Get an app's secret key */
+export declare const secretkeyGet: API.OperationMethod<SecretkeyGetRequest, SecretKey, SecretkeyGetError, FlyIoOpContext>;
+export type SecretkeySetError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Create or update a secret key */
+export declare const secretkeySet: API.OperationMethod<SecretkeySetRequest, SetSecretkeyResponse, SecretkeySetError, FlyIoOpContext>;
+export type SecretkeySignError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Sign with a secret key */
+export declare const secretkeySign: API.OperationMethod<SecretkeySignRequest, SignSecretkeyResponse, SecretkeySignError, FlyIoOpContext>;
+export type SecretkeysListError = Forbidden | NotFound | FlyIoOpError;
+/** List secret keys belonging to an app */
+export declare const secretkeysList: API.OperationMethod<SecretkeysListRequest, SecretKeys, SecretkeysListError, FlyIoOpContext>;
+export type SecretkeyVerifyError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Verify with a secret key */
+export declare const secretkeyVerify: API.OperationMethod<SecretkeyVerifyRequest, SecretkeyVerifyResponse, SecretkeyVerifyError, FlyIoOpContext>;
+export type SecretsListError = Forbidden | NotFound | FlyIoOpError;
+/** List app secrets belonging to an app */
+export declare const secretsList: API.OperationMethod<SecretsListRequest, AppSecrets, SecretsListError, FlyIoOpContext>;
+export type SecretsUpdateError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Update app secrets belonging to an app */
+export declare const secretsUpdate: API.OperationMethod<SecretsUpdateRequest, AppSecretsUpdateResp, SecretsUpdateError, FlyIoOpContext>;
+export type TokensAuthenticateError = BadRequest | FlyIoOpError;
+/** Authenticate token header Verify a token header without checking resource access. */
+export declare const tokensAuthenticate: API.OperationMethod<TokensAuthenticateRequest, TokensAuthenticateResponse, TokensAuthenticateError, FlyIoOpContext>;
+export type TokensAuthorizeError = BadRequest | FlyIoOpError;
+/** Authorize token for resource access Verify a token header and validate it against a requested access scope. */
+export declare const tokensAuthorize: API.OperationMethod<TokensAuthorizeRequest, AuthorizeResponse, TokensAuthorizeError, FlyIoOpContext>;
+export type TokensRequestKmsError = 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. */
+export declare const tokensRequestKms: API.OperationMethod<TokensRequestKmsRequest, TokensRequestKmsResponse, TokensRequestKmsError, FlyIoOpContext>;
+export type TokensRequestOIDCError = 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 tokensRequestOIDC: API.OperationMethod<TokensRequestOIDCRequest, TokensRequestOIDCResponse, TokensRequestOIDCError, FlyIoOpContext>;
+export type VolumeDeleteError = Forbidden | NotFound | FlyIoOpError;
+/** Destroy Volume Delete a specific volume within an app by volume ID. */
+export declare const volumeDelete: API.OperationMethod<VolumeDeleteRequest, Volume, VolumeDeleteError, FlyIoOpContext>;
+export type VolumesCreateError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Create Volume Create a volume for a specific app using the details provided in the request body. */
+export declare const volumesCreate: API.OperationMethod<VolumesCreateRequest, Volume, VolumesCreateError, FlyIoOpContext>;
+export type VolumesExtendError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Extend Volume Extend a volume's size within an app using the details provided in the request body. */
+export declare const volumesExtend: API.OperationMethod<VolumesExtendRequest, ExtendVolumeResponse, VolumesExtendError, FlyIoOpContext>;
+export type VolumesGetByIdError = Forbidden | NotFound | FlyIoOpError;
+/** Get Volume Retrieve details about a specific volume by its ID within an app. */
+export declare const volumesGetById: API.OperationMethod<VolumesGetByIdRequest, Volume, VolumesGetByIdError, FlyIoOpContext>;
+export type VolumesListError = Forbidden | NotFound | FlyIoOpError;
+/** List Volumes List all volumes associated with a specific app. */
+export declare const volumesList: API.OperationMethod<VolumesListRequest, VolumesListResponse, VolumesListError, FlyIoOpContext>;
+export type VolumesListSnapshotsError = Forbidden | NotFound | FlyIoOpError;
+/** List Snapshots List all snapshots for a specific volume within an app. */
+export declare const volumesListSnapshots: API.OperationMethod<VolumesListSnapshotsRequest, VolumesListSnapshotsResponse, VolumesListSnapshotsError, FlyIoOpContext>;
+export type VolumesOrgListError = FlyIoOpError;
+/** List All Volumes List all volumes for an organization with optional filters and cursor-based pagination. */
+export declare const volumesOrgList: API.OperationMethod<VolumesOrgListRequest, OrgVolumesResponse, VolumesOrgListError, FlyIoOpContext>;
+export type VolumesUpdateError = BadRequest | Forbidden | NotFound | FlyIoOpError;
+/** Update Volume Update a volume's configuration using the details provided in the request body. */
+export declare const volumesUpdate: API.OperationMethod<VolumesUpdateRequest, Volume, VolumesUpdateError, FlyIoOpContext>;
+//# sourceMappingURL=machines.d.ts.map