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

package/lib/services/machines.d.ts

@@ -1,71 +1,60 @@
 import * as API from "@distilled.cloud/core/api";
-import * as S from "@distilled.cloud/core/schema";
+import * as S from "@distilled.cloud/core/schema-lite";
+import type * as Redacted from "effect/Redacted";
 import { BadRequest, Conflict, Forbidden, GatewayTimeout, NotFound, UnprocessableEntity } from "../errors.ts";
 import { type FlyIoOpError, type FlyIoOpContext } from "../protocol.ts";
 export type { FlyIoOpError, FlyIoOpContext };
-declare const MachineReplacing_base: S.Class<MachineReplacing, S.TaggedStruct<"MachineReplacing", {
+declare const MachineReplacing_base: S.TaggedErrorClass<"MachineReplacing", {
     readonly message: any;
-}>, import("effect/Cause").YieldableError>;
+}>;
 export declare class MachineReplacing extends /*@__PURE__*/ MachineReplacing_base {
 }
-declare const MachineStartFromCreatedState_base: S.Class<MachineStartFromCreatedState, S.TaggedStruct<"MachineStartFromCreatedState", {
+declare const MachineStartFromCreatedState_base: S.TaggedErrorClass<"MachineStartFromCreatedState", {
     readonly message: any;
-}>, import("effect/Cause").YieldableError>;
+}>;
 export declare class MachineStartFromCreatedState extends /*@__PURE__*/ MachineStartFromCreatedState_base {
 }
-declare const MachineWaitTimeout_base: S.Class<MachineWaitTimeout, S.TaggedStruct<"MachineWaitTimeout", {
+declare const MachineWaitTimeout_base: S.TaggedErrorClass<"MachineWaitTimeout", {
     readonly message: any;
-}>, import("effect/Cause").YieldableError>;
+}>;
 export declare class MachineWaitTimeout extends /*@__PURE__*/ MachineWaitTimeout_base {
 }
-declare const NetworkNotFound_base: S.Class<NetworkNotFound, S.TaggedStruct<"NetworkNotFound", {
+declare const NetworkNotFound_base: S.TaggedErrorClass<"NetworkNotFound", {
     readonly message: any;
-}>, import("effect/Cause").YieldableError>;
+}>;
 export declare class NetworkNotFound extends /*@__PURE__*/ NetworkNotFound_base {
 }
-declare const VolumeAttached_base: S.Class<VolumeAttached, S.TaggedStruct<"VolumeAttached", {
+declare const VolumeAttached_base: S.TaggedErrorClass<"VolumeAttached", {
     readonly message: any;
-}>, import("effect/Cause").YieldableError>;
+}>;
 export declare class VolumeAttached extends /*@__PURE__*/ VolumeAttached_base {
 }
 export interface AuthenticateTokenRequest {
     header?: string;
 }
-export declare const AuthenticateTokenRequest: S.Schema<AuthenticateTokenRequest>;
 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 AuthenticateTokenResponseBodyList = Array<RootVerifiedToken>;
-export declare const AuthenticateTokenResponseBodyList: S.Schema<AuthenticateTokenResponseBodyList>;
 export type AuthenticateTokenResponse = AuthenticateTokenResponseBodyList;
-export declare const AuthenticateTokenResponse: S.Schema<AuthenticateTokenResponse>;
 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 & {});
@@ -92,14 +81,11 @@ export interface MainTokenAccess {
     /** 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 AuthorizeTokenRequest {
     access?: MainTokenAccess;
     header?: string;
 }
-export declare const AuthorizeTokenRequest: S.Schema<AuthorizeTokenRequest>;
 export type FlyioAccessCommandList = Array<string>;
-export declare const FlyioAccessCommandList: S.Schema<FlyioAccessCommandList>;
 export interface FlyioAccess {
     action?: RessetAction;
     app_feature?: string;
@@ -117,33 +103,25 @@ export interface FlyioAccess {
     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 CheckAppCertificateRequest {
     /** Fly App Name */
     app_name: string;
     /** Certificate Hostname */
     hostname: string;
 }
-export declare const CheckAppCertificateRequest: S.Schema<CheckAppCertificateRequest>;
 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;
@@ -152,17 +130,11 @@ export interface CertificateEntry {
     source?: CertificateEntrySource;
     status?: CertificateEntryStatus;
 }
-export declare const CertificateEntry: S.Schema<CertificateEntry>;
 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;
@@ -172,22 +144,17 @@ export interface DNSRecords {
     resolved_addresses?: DNSRecordsResolvedAddressesList;
     soa?: string;
 }
-export declare const DNSRecords: S.Schema<DNSRecords>;
 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;
@@ -195,23 +162,19 @@ export interface DNSRequirements {
     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 CertificateCheckResponseValidationErrorsList = Array<CertificateValidationError>;
-export declare const CertificateCheckResponseValidationErrorsList: S.Schema<CertificateCheckResponseValidationErrorsList>;
 export interface CertificateCheckResponse {
     acme_requested?: boolean;
     certificates?: CertificateCheckResponseCertificatesList;
@@ -225,7 +188,6 @@ export interface CertificateCheckResponse {
     validation?: CertificateValidation;
     validation_errors?: CertificateCheckResponseValidationErrorsList;
 }
-export declare const CertificateCheckResponse: S.Schema<CertificateCheckResponse>;
 export interface CordonMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -233,10 +195,8 @@ export interface CordonMachineRequest {
     machine_id: string;
     lease_nonce?: string;
 }
-export declare const CordonMachineRequest: S.Schema<CordonMachineRequest>;
 export interface CordonMachineResponse {
 }
-export declare const CordonMachineResponse: S.Schema<CordonMachineResponse>;
 export interface CreateAppRequest {
     enable_subdomains?: boolean;
     /** When set, makes a retry of this exact request safe: a second create with the same key and the same name (or no name) returns the app the first request created, instead of erroring on a false name conflict or creating a duplicate. A second create with the same key but a *different* name is rejected outright; it won't silently hand back the first app. */
@@ -245,22 +205,17 @@ export interface CreateAppRequest {
     network?: string;
     org_slug?: string;
 }
-export declare const CreateAppRequest: S.Schema<CreateAppRequest>;
 export interface CreateAppResponse {
     created_at?: number;
     id?: string;
 }
-export declare const CreateAppResponse: S.Schema<CreateAppResponse>;
 export interface CreateAppAcmeCertificateRequest {
     /** Fly App Name */
     app_name: string;
     hostname?: string;
 }
-export declare const CreateAppAcmeCertificateRequest: S.Schema<CreateAppAcmeCertificateRequest>;
 export type CertificateDetailCertificatesList = Array<CertificateEntry>;
-export declare const CertificateDetailCertificatesList: S.Schema<CertificateDetailCertificatesList>;
 export type CertificateDetailValidationErrorsList = Array<CertificateValidationError>;
-export declare const CertificateDetailValidationErrorsList: S.Schema<CertificateDetailValidationErrorsList>;
 export interface CertificateDetail {
     acme_requested?: boolean;
     certificates?: CertificateDetailCertificatesList;
@@ -273,28 +228,23 @@ export interface CertificateDetail {
     validation?: CertificateValidation;
     validation_errors?: CertificateDetailValidationErrorsList;
 }
-export declare const CertificateDetail: S.Schema<CertificateDetail>;
 export interface CreateAppCustomCertificateRequest {
     /** Fly App Name */
     app_name: string;
     fullchain?: string;
     hostname?: string;
-    private_key?: string;
+    private_key?: string | Redacted.Redacted<string>;
 }
-export declare const CreateAppCustomCertificateRequest: S.Schema<CreateAppCustomCertificateRequest>;
 export interface CreateAppDeployTokenRequest {
     /** Fly App Name */
     app_name: string;
     expiry?: string;
 }
-export declare const CreateAppDeployTokenRequest: S.Schema<CreateAppDeployTokenRequest>;
 export interface CreateAppDeployTokenResponse {
-    token?: string;
+    token?: string | Redacted.Redacted<string>;
 }
-export declare const CreateAppDeployTokenResponse: S.Schema<CreateAppDeployTokenResponse>;
 /** Type of IP address to allocate. "egress-pair" allocates both v4 and v6 egress IP addresses (recommended when using egress IPs). */
 export type IPAssignmentType = "v4" | "v6" | "shared_v4" | "private_v6" | "egress_v4" | "egress_v6" | "egress_pair";
-export declare const IPAssignmentType: any;
 export interface CreateAppIPAssignmentRequest {
     /** Fly App Name */
     app_name: string;
@@ -304,19 +254,16 @@ export interface CreateAppIPAssignmentRequest {
     service_name?: string;
     type?: IPAssignmentType | (string & {});
 }
-export declare const CreateAppIPAssignmentRequest: S.Schema<CreateAppIPAssignmentRequest>;
 export interface IPPair {
     v4?: string;
     v6?: string;
 }
-export declare const IPPair: S.Schema<IPPair>;
 /** The 6PN network a Flycast (private_v6) address belongs to. Null for all other IP types. */
 export interface IPAssignmentNetwork {
     /** Network name; empty for the organization's default network. */
     name?: string;
     org_slug?: string;
 }
-export declare const IPAssignmentNetwork: S.Schema<IPAssignmentNetwork>;
 export interface AssignIPResponse {
     created_at?: string;
     egress?: boolean;
@@ -328,14 +275,11 @@ export interface AssignIPResponse {
     service_name?: string;
     shared?: boolean;
 }
-export declare const AssignIPResponse: S.Schema<AssignIPResponse>;
 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 */
@@ -343,12 +287,9 @@ export interface FlyMachineHTTPHeader {
     /** 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;
@@ -374,36 +315,27 @@ export interface FlyMachineCheck {
     /** 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. */
@@ -411,13 +343,10 @@ export interface FlyEnvFrom {
     /** 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 */
@@ -431,23 +360,17 @@ export interface FlyFile {
     /** 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;
@@ -464,16 +387,12 @@ export interface FlyHTTPHealthcheck {
     /** 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. */
@@ -495,21 +414,17 @@ export interface FlyContainerHealthcheck {
     /** 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. */
+/** * no - Never try to restart a Machine automatically when its main process exits, whether that's on purpose or on a crash. * always - Always restart a Machine automatically and never let it enter a stopped state, even when the main process exits cleanly. * on-failure - Try up to MaxRetries times to automatically restart the Machine if it exits with a non-zero exit code. Default when no explicit policy is set, and for Machines with schedules. */
 export type FlyMachineRestartPolicy = "no" | "always" | "on-failure";
-export declare const FlyMachineRestartPolicy: any;
 /** The Machine restart policy defines whether and how flyd restarts a Machine after its main process exits. See https://fly.io/docs/machines/guides-examples/machine-restart-policy/. */
 export interface FlyMachineRestart {
     /** 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. */
+    /** * no - Never try to restart a Machine automatically when its main process exits, whether that's on purpose or on a crash. * always - Always restart a Machine automatically and never let it enter a stopped state, even when the main process exits cleanly. * on-failure - Try up to MaxRetries times to automatically restart the Machine if it exits with a non-zero exit code. Default when no explicit policy is set, and for Machines with schedules. */
     policy?: FlyMachineRestartPolicy | (string & {});
 }
-export declare const FlyMachineRestart: S.Schema<FlyMachineRestart>;
 /** 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. */
@@ -517,17 +432,13 @@ export interface FlyMachineSecret {
     /** 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;
@@ -558,28 +469,20 @@ export interface FlyContainerConfig {
     /** 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;
@@ -589,21 +492,15 @@ export interface FlyDNSConfig {
     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 type FlyMachineGuestRequiredHostFeaturesList = Array<string>;
-export declare const FlyMachineGuestRequiredHostFeaturesList: S.Schema<FlyMachineGuestRequiredHostFeaturesList>;
 export interface FlyMachineGuest {
     cpu_kind?: string;
     cpus?: number;
@@ -617,15 +514,10 @@ export interface FlyMachineGuest {
     persist_rootfs?: FlyMachineGuestPersistRootfs | (string & {});
     required_host_features?: FlyMachineGuestRequiredHostFeaturesList;
 }
-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;
@@ -634,17 +526,14 @@ export interface FlyMachineInit {
     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;
     /** AddSizePercent grows by a percentage of the current size, rounded up to GiB. It is mutually exclusive with AddSizeGb. */
@@ -659,25 +548,17 @@ export interface FlyMachineMount {
     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;
@@ -691,24 +572,17 @@ export interface FlyMachineProcess {
     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 FlyMachineServiceAutostopMode = "off" | "stop" | "suspend";
-export declare const FlyMachineServiceAutostopMode: any;
 /** Accepts off, stop, or suspend. For backward compatibility, responses encode off as false and stop as true. */
 export type FlyMachineServiceAutostop = FlyMachineServiceAutostopMode | (string & {}) | boolean;
-export declare const FlyMachineServiceAutostop: S.Codec<FlyMachineServiceAutostop>;
 export type FlyMachineServiceCheckHeadersList = Array<FlyMachineHTTPHeader>;
-export declare const FlyMachineServiceCheckHeadersList: S.Schema<FlyMachineServiceCheckHeadersList>;
 export interface FlyMachineServiceCheck {
     /** The time to wait after a VM starts before checking its health */
     grace_period?: string;
@@ -732,21 +606,16 @@ export interface FlyMachineServiceCheck {
     /** 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 */
@@ -756,18 +625,14 @@ export interface FlyReplayCache {
     /** 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;
@@ -776,21 +641,16 @@ export interface FlyHTTPOptions {
     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;
@@ -801,9 +661,7 @@ export interface FlyMachinePort {
     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. */
@@ -818,28 +676,22 @@ export interface FlyMachineService {
     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) */
+    /** 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. */
@@ -872,7 +724,6 @@ export interface FlyMachineConfig {
     statics?: FlyMachineConfigStaticsList;
     stop_config?: FlyStopConfig;
 }
-export declare const FlyMachineConfig: S.Schema<FlyMachineConfig>;
 export interface CreateMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -888,16 +739,13 @@ export interface CreateMachineRequest {
     skip_secrets?: boolean;
     skip_service_registration?: boolean;
 }
-export declare const CreateMachineRequest: S.Schema<CreateMachineRequest>;
 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;
@@ -906,17 +754,12 @@ export interface MachineEvent {
     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 MachineHostFeaturesList = Array<string>;
-export declare const MachineHostFeaturesList: S.Schema<MachineHostFeaturesList>;
 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;
@@ -924,13 +767,11 @@ export interface ImageRef {
     repository?: string;
     tag?: string;
 }
-export declare const ImageRef: S.Schema<ImageRef>;
 export interface StrippedLease {
     description?: string;
     expires_at?: number;
     owner?: string;
 }
-export declare const StrippedLease: S.Schema<StrippedLease>;
 export interface Machine {
     checks?: MachineChecksList;
     config?: FlyMachineConfig;
@@ -956,7 +797,6 @@ export interface Machine {
     /** Version is unique for each version of the machine. Pass it as `current_version` when updating the Machine to reject the update if the Machine has changed since this version. */
     version?: string;
 }
-export declare const Machine: S.Schema<Machine>;
 export interface CreateMachineLeaseRequest {
     /** Fly App Name */
     app_name: string;
@@ -968,7 +808,6 @@ export interface CreateMachineLeaseRequest {
     /** Existing lease nonce when refreshing; omit to acquire a new lease. Keep the nonce private. */
     lease_nonce?: string;
 }
-export declare const CreateMachineLeaseRequest: S.Schema<CreateMachineLeaseRequest>;
 export interface Lease {
     /** Description or reason for the Lease. */
     description?: string;
@@ -981,21 +820,16 @@ export interface Lease {
     /** Machine version */
     version?: string;
 }
-export declare const Lease: S.Schema<Lease>;
 export interface MachineLease {
     status?: string;
     data?: Lease;
 }
-export declare const MachineLease: S.Schema<MachineLease>;
 /** Postgres major version. */
 export type CreatePostgresRequestPgMajorVersion = "16" | "17";
-export declare const CreatePostgresRequestPgMajorVersion: any;
 /** Plan slug selecting CPU, memory, and disk sizing. Matched case-insensitively. */
 export type CreatePostgresRequestPlan = "basic" | "starter" | "launch" | "scale" | "Performance";
-export declare const CreatePostgresRequestPlan: any;
 /** Connection pooler mode. */
 export type CreatePostgresRequestPoolMode = "session" | "transaction";
-export declare const CreatePostgresRequestPoolMode: any;
 export interface CreatePostgresRequest {
     /** Disk size in gigabytes. */
     disk_size_gb?: number;
@@ -1014,53 +848,42 @@ export interface CreatePostgresRequest {
     /** Fly region code where the cluster's primary runs. */
     region: string;
 }
-export declare const CreatePostgresRequest: S.Schema<CreatePostgresRequest>;
 export interface PostgresAttachedApp {
     /** Attached Fly app name. */
     name?: string;
 }
-export declare const PostgresAttachedApp: S.Schema<PostgresAttachedApp>;
 /** Apps attached to the cluster. */
 export type PostgresClusterAttachedAppsList = Array<PostgresAttachedApp>;
-export declare const PostgresClusterAttachedAppsList: S.Schema<PostgresClusterAttachedAppsList>;
 /** CPU class. */
 export type PostgresClusterCpuKind = "shared" | "performance";
-export declare const PostgresClusterCpuKind: any;
 export interface PostgresEndpoint {
     /** Hostname to connect to. */
     host?: string;
     /** TCP port. */
     port?: number;
 }
-export declare const PostgresEndpoint: S.Schema<PostgresEndpoint>;
 export interface PostgresNodeEndpoints {
     /** Unpooled connection to the cluster node. */
     direct?: PostgresEndpoint;
     /** Pooled connection to the cluster node (through PgBouncer). */
     pooler?: PostgresEndpoint;
 }
-export declare const PostgresNodeEndpoints: S.Schema<PostgresNodeEndpoints>;
 export interface PostgresClusterEndpoints {
     /** Endpoints for connecting to the primary node. */
     primary?: PostgresNodeEndpoints;
 }
-export declare const PostgresClusterEndpoints: S.Schema<PostgresClusterEndpoints>;
 export interface OrganizationRef {
     /** Organization name. */
     name?: string;
     /** Organization slug. */
     slug?: string;
 }
-export declare const OrganizationRef: S.Schema<OrganizationRef>;
 /** Postgres major version. */
 export type PostgresClusterPgMajorVersion = "16" | "17";
-export declare const PostgresClusterPgMajorVersion: any;
 /** Plan slug. */
 export type PostgresClusterPlan = "basic" | "starter" | "launch" | "scale" | "Performance";
-export declare const PostgresClusterPlan: any;
 /** Current lifecycle status. */
 export type PostgresClusterStatus = "creating" | "initializing" | "ready" | "deleting" | "deleted" | "failed";
-export declare const PostgresClusterStatus: any;
 export interface PostgresCluster {
     /** Apps attached to the cluster. */
     attached_apps?: PostgresClusterAttachedAppsList;
@@ -1098,18 +921,15 @@ export interface PostgresCluster {
     /** Storage used, summed across the cluster's volumes and measured hourly. Null until first measured. */
     storage_used_bytes?: number | null;
 }
-export declare const PostgresCluster: S.Schema<PostgresCluster>;
 export interface ShowPostgresClusterResponse {
     data?: PostgresCluster;
 }
-export declare const ShowPostgresClusterResponse: S.Schema<ShowPostgresClusterResponse>;
 export interface CreatePostgresAttachmentRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Name of the Fly app to attach. */
     app_name: string;
 }
-export declare const CreatePostgresAttachmentRequest: S.Schema<CreatePostgresAttachmentRequest>;
 export interface PostgresAttachment {
     /** Attached Fly app name. */
     app_name?: string;
@@ -1118,43 +938,34 @@ export interface PostgresAttachment {
     /** Cluster ID the app is attached to. */
     postgres_cluster_id?: string;
 }
-export declare const PostgresAttachment: S.Schema<PostgresAttachment>;
 export interface CreatePostgresAttachmentResponse {
     data?: PostgresAttachment;
 }
-export declare const CreatePostgresAttachmentResponse: S.Schema<CreatePostgresAttachmentResponse>;
 /** Backup type. */
 export type CreatePostgresBackupRequestType = "full" | "incr" | "diff";
-export declare const CreatePostgresBackupRequestType: any;
 export interface CreatePostgresBackupRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Backup type. */
     type: CreatePostgresBackupRequestType | (string & {});
 }
-export declare const CreatePostgresBackupRequest: S.Schema<CreatePostgresBackupRequest>;
 export interface CreatePostgresBackupResponse {
 }
-export declare const CreatePostgresBackupResponse: S.Schema<CreatePostgresBackupResponse>;
 export interface CreatePostgresDatabaseRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Name of the database to create. Must start and end with an alphanumeric character and may contain hyphens and underscores, up to 63 characters. */
     name: string;
 }
-export declare const CreatePostgresDatabaseRequest: S.Schema<CreatePostgresDatabaseRequest>;
 export interface PostgresDatabase {
     /** Database name. */
     name?: string;
 }
-export declare const PostgresDatabase: S.Schema<PostgresDatabase>;
 export interface PostgresDatabaseResponse {
     data?: PostgresDatabase;
 }
-export declare const PostgresDatabaseResponse: S.Schema<PostgresDatabaseResponse>;
 /** Role to grant the user. */
 export type CreatePostgresUserRequestRole = "schema_admin" | "writer" | "reader";
-export declare const CreatePostgresUserRequestRole: any;
 export interface CreatePostgresUserRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
@@ -1163,21 +974,17 @@ export interface CreatePostgresUserRequest {
     /** Name for the new user. Must start and end with a lowercase alphanumeric character and may contain hyphens and underscores, up to 63 characters. */
     username: string;
 }
-export declare const CreatePostgresUserRequest: S.Schema<CreatePostgresUserRequest>;
 /** User role. */
 export type PostgresUserRole = "schema_admin" | "writer" | "reader";
-export declare const PostgresUserRole: any;
 export interface PostgresUser {
     /** User role. */
     role?: PostgresUserRole;
     /** User name. */
     username?: string;
 }
-export declare const PostgresUser: S.Schema<PostgresUser>;
 export interface CreatePostgresUserResponse {
     data?: PostgresUser;
 }
-export declare const CreatePostgresUserResponse: S.Schema<CreatePostgresUserResponse>;
 export interface CreateSecretRequest {
     /** Fly App Name */
     app_name: string;
@@ -1185,7 +992,6 @@ export interface CreateSecretRequest {
     secret_name: string;
     value?: string;
 }
-export declare const CreateSecretRequest: S.Schema<CreateSecretRequest>;
 export interface SetAppSecretResponse {
     /** DEPRECATED */
     Version?: number;
@@ -1196,7 +1002,6 @@ export interface SetAppSecretResponse {
     value?: string;
     version?: number;
 }
-export declare const SetAppSecretResponse: S.Schema<SetAppSecretResponse>;
 export interface CreateVolumeRequest {
     /** Fly App Name */
     app_name: string;
@@ -1217,15 +1022,10 @@ export interface CreateVolumeRequest {
     source_volume_id?: string;
     unique_zone_app_wide?: boolean;
 }
-export declare const CreateVolumeRequest: S.Schema<CreateVolumeRequest>;
 export type VolumeHostFeaturesList = Array<string>;
-export declare const VolumeHostFeaturesList: S.Schema<VolumeHostFeaturesList>;
 export type VolumeHostStatus = "ok" | "unknown" | "unreachable";
-export declare const VolumeHostStatus: any;
 export type VolumeRequiredHostFeaturesList = Array<string>;
-export declare const VolumeRequiredHostFeaturesList: S.Schema<VolumeRequiredHostFeaturesList>;
 export type VolumeType = "local" | "cache";
-export declare const VolumeType: any;
 export interface Volume {
     attached_alloc_id?: string;
     attached_machine_id?: string;
@@ -1251,17 +1051,14 @@ export interface Volume {
     type?: VolumeType;
     zone?: string;
 }
-export declare const Volume: S.Schema<Volume>;
 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 DecryptSecretKeyRequest {
     /** Fly App Name */
     app_name: string;
@@ -1272,47 +1069,37 @@ export interface DecryptSecretKeyRequest {
     associated_data?: string;
     ciphertext?: string;
 }
-export declare const DecryptSecretKeyRequest: S.Schema<DecryptSecretKeyRequest>;
 export interface DecryptSecretkeyResponse {
-    plaintext?: string;
+    plaintext?: string | Redacted.Redacted<string>;
 }
-export declare const DecryptSecretkeyResponse: S.Schema<DecryptSecretkeyResponse>;
 export interface DeleteAppRequest {
     /** Fly App Name */
     app_name: string;
 }
-export declare const DeleteAppRequest: S.Schema<DeleteAppRequest>;
 export interface DeleteAppResponse {
 }
-export declare const DeleteAppResponse: S.Schema<DeleteAppResponse>;
 export interface DeleteAppAcmeCertificateRequest {
     /** Fly App Name */
     app_name: string;
     /** Certificate Hostname */
     hostname: string;
 }
-export declare const DeleteAppAcmeCertificateRequest: S.Schema<DeleteAppAcmeCertificateRequest>;
 export interface DeleteAppCertificateRequest {
     /** Fly App Name */
     app_name: string;
     /** Certificate Hostname */
     hostname: string;
 }
-export declare const DeleteAppCertificateRequest: S.Schema<DeleteAppCertificateRequest>;
 export interface DeleteAppCertificateResponse {
 }
-export declare const DeleteAppCertificateResponse: S.Schema<DeleteAppCertificateResponse>;
 export interface DeleteAppCustomCertificateRequest {
     /** Fly App Name */
     app_name: string;
     /** Certificate Hostname */
     hostname: string;
 }
-export declare const DeleteAppCustomCertificateRequest: S.Schema<DeleteAppCustomCertificateRequest>;
 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;
@@ -1326,17 +1113,14 @@ export interface DestroyCustomCertificateResponse {
     validation_errors?: DestroyCustomCertificateResponseValidationErrorsList;
     warning?: string;
 }
-export declare const DestroyCustomCertificateResponse: S.Schema<DestroyCustomCertificateResponse>;
 export interface DeleteAppIPAssignmentRequest {
     /** Fly App Name */
     app_name: string;
     /** IP address */
     ip: string;
 }
-export declare const DeleteAppIPAssignmentRequest: S.Schema<DeleteAppIPAssignmentRequest>;
 export interface DeleteAppIPAssignmentResponse {
 }
-export declare const DeleteAppIPAssignmentResponse: S.Schema<DeleteAppIPAssignmentResponse>;
 export interface DeleteMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -1346,10 +1130,8 @@ export interface DeleteMachineRequest {
     force?: boolean;
     lease_nonce?: string;
 }
-export declare const DeleteMachineRequest: S.Schema<DeleteMachineRequest>;
 export interface DeleteMachineResponse {
 }
-export declare const DeleteMachineResponse: S.Schema<DeleteMachineResponse>;
 export interface DeleteMachineMetadataRequest {
     /** Fly App Name */
     app_name: string;
@@ -1358,78 +1140,64 @@ export interface DeleteMachineMetadataRequest {
     /** Metadata Key */
     key: string;
 }
-export declare const DeleteMachineMetadataRequest: S.Schema<DeleteMachineMetadataRequest>;
 export interface DeleteMachineMetadataResponse {
 }
-export declare const DeleteMachineMetadataResponse: S.Schema<DeleteMachineMetadataResponse>;
 export interface DeletePostgresRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
 }
-export declare const DeletePostgresRequest: S.Schema<DeletePostgresRequest>;
 export interface DeletePostgresResponse {
 }
-export declare const DeletePostgresResponse: S.Schema<DeletePostgresResponse>;
 export interface DeletePostgresAttachmentRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Fly App Name */
     app_name: string;
 }
-export declare const DeletePostgresAttachmentRequest: S.Schema<DeletePostgresAttachmentRequest>;
 export interface DeletePostgresAttachmentResponse {
 }
-export declare const DeletePostgresAttachmentResponse: S.Schema<DeletePostgresAttachmentResponse>;
 export interface DeletePostgresDatabaseRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Database Name */
     database_name: string;
 }
-export declare const DeletePostgresDatabaseRequest: S.Schema<DeletePostgresDatabaseRequest>;
 export interface DeletePostgresUserRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Postgres User Name */
     username: string;
 }
-export declare const DeletePostgresUserRequest: S.Schema<DeletePostgresUserRequest>;
 export interface DeletePostgresUserResponse {
 }
-export declare const DeletePostgresUserResponse: S.Schema<DeletePostgresUserResponse>;
 export interface DeleteSecretRequest {
     /** Fly App Name */
     app_name: string;
     /** App secret name */
     secret_name: string;
 }
-export declare const DeleteSecretRequest: S.Schema<DeleteSecretRequest>;
 export interface DeleteAppSecretResponse {
     /** DEPRECATED */
     Version?: number;
     version?: number;
 }
-export declare const DeleteAppSecretResponse: S.Schema<DeleteAppSecretResponse>;
 export interface DeleteSecretKeyRequest {
     /** Fly App Name */
     app_name: string;
     /** Secret key name */
     secret_name: string;
 }
-export declare const DeleteSecretKeyRequest: S.Schema<DeleteSecretKeyRequest>;
 export interface DeleteSecretkeyResponse {
     /** DEPRECATED */
     Version?: number;
     version?: number;
 }
-export declare const DeleteSecretkeyResponse: S.Schema<DeleteSecretkeyResponse>;
 export interface DeleteVolumeRequest {
     /** Fly App Name */
     app_name: string;
     /** Volume ID */
     volume_id: string;
 }
-export declare const DeleteVolumeRequest: S.Schema<DeleteVolumeRequest>;
 export interface DisablePostgresExtensionRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
@@ -1440,10 +1208,8 @@ export interface DisablePostgresExtensionRequest {
     /** Also drop objects that depend on the extension */
     force?: boolean;
 }
-export declare const DisablePostgresExtensionRequest: S.Schema<DisablePostgresExtensionRequest>;
 export interface DisablePostgresExtensionResponse {
 }
-export declare const DisablePostgresExtensionResponse: S.Schema<DisablePostgresExtensionResponse>;
 export interface EnablePostgresExtensionRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
@@ -1456,10 +1222,8 @@ export interface EnablePostgresExtensionRequest {
     /** Schema to install the extension into. Defaults to the database's default schema. */
     schema?: string;
 }
-export declare const EnablePostgresExtensionRequest: S.Schema<EnablePostgresExtensionRequest>;
 export interface EnablePostgresExtensionResponse {
 }
-export declare const EnablePostgresExtensionResponse: S.Schema<EnablePostgresExtensionResponse>;
 export interface EncryptSecretKeyRequest {
     /** Fly App Name */
     app_name: string;
@@ -1468,15 +1232,12 @@ export interface EncryptSecretKeyRequest {
     /** Minimum secrets version to return. Returned when setting a new secret */
     min_version?: string;
     associated_data?: string;
-    plaintext?: string;
+    plaintext?: string | Redacted.Redacted<string>;
 }
-export declare const EncryptSecretKeyRequest: S.Schema<EncryptSecretKeyRequest>;
 export interface EncryptSecretkeyResponse {
     ciphertext?: string;
 }
-export declare const EncryptSecretkeyResponse: S.Schema<EncryptSecretkeyResponse>;
 export type ExecMachineRequestCommandList = Array<string>;
-export declare const ExecMachineRequestCommandList: S.Schema<ExecMachineRequestCommandList>;
 export interface ExecMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -1491,14 +1252,12 @@ export interface ExecMachineRequest {
     stdin?: string;
     timeout?: number;
 }
-export declare const ExecMachineRequest: S.Schema<ExecMachineRequest>;
 export interface Flydv1ExecResponse {
     exit_code?: number;
     exit_signal?: number;
     stderr?: string;
     stdout?: string;
 }
-export declare const Flydv1ExecResponse: S.Schema<Flydv1ExecResponse>;
 export interface ExtendVolumeRequest {
     /** Fly App Name */
     app_name: string;
@@ -1506,21 +1265,17 @@ export interface ExtendVolumeRequest {
     volume_id: string;
     size_gb?: number;
 }
-export declare const ExtendVolumeRequest: S.Schema<ExtendVolumeRequest>;
 export interface ExtendVolumeResponse {
     needs_restart?: boolean;
     volume?: Volume;
 }
-export declare const ExtendVolumeResponse: S.Schema<ExtendVolumeResponse>;
 export interface ForkPostgresRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Name for the forked cluster. Defaults to the source name with a -fork suffix. */
     name?: string;
 }
-export declare const ForkPostgresRequest: S.Schema<ForkPostgresRequest>;
 export type GenerateSecretKeyRequestValueList = Array<number>;
-export declare const GenerateSecretKeyRequestValueList: S.Schema<GenerateSecretKeyRequestValueList>;
 export interface GenerateSecretKeyRequest {
     /** Fly App Name */
     app_name: string;
@@ -1529,7 +1284,6 @@ export interface GenerateSecretKeyRequest {
     type?: string;
     value?: GenerateSecretKeyRequestValueList;
 }
-export declare const GenerateSecretKeyRequest: S.Schema<GenerateSecretKeyRequest>;
 export interface SetSecretkeyResponse {
     /** DEPRECATED */
     Version?: number;
@@ -1540,18 +1294,15 @@ export interface SetSecretkeyResponse {
     updated_at?: string;
     version?: number;
 }
-export declare const SetSecretkeyResponse: S.Schema<SetSecretkeyResponse>;
 export interface GetAppRequest {
     /** Fly App Name */
     app_name: string;
 }
-export declare const GetAppRequest: S.Schema<GetAppRequest>;
 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;
@@ -1563,19 +1314,15 @@ export interface App {
     status?: string;
     volume_count?: number;
 }
-export declare const App: S.Schema<App>;
 export interface GetAppCertificateRequest {
     /** Fly App Name */
     app_name: string;
     /** Certificate Hostname */
     hostname: string;
 }
-export declare const GetAppCertificateRequest: S.Schema<GetAppCertificateRequest>;
 export interface GetCurrentTokenRequest {
 }
-export declare const GetCurrentTokenRequest: S.Schema<GetCurrentTokenRequest>;
 export type MainTokenInfoAppsList = Array<string>;
-export declare const MainTokenInfoAppsList: S.Schema<MainTokenInfoAppsList>;
 export interface MainTokenInfo {
     apps?: MainTokenInfoAppsList;
     org_slug?: string;
@@ -1588,13 +1335,10 @@ export interface MainTokenInfo {
     /** 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 GetMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -1605,39 +1349,32 @@ export interface GetMachineRequest {
     /** Include machine lease */
     include_leases?: boolean;
 }
-export declare const GetMachineRequest: S.Schema<GetMachineRequest>;
 export interface GetMachineLeaseRequest {
     /** Fly App Name */
     app_name: string;
     /** Machine ID */
     machine_id: string;
 }
-export declare const GetMachineLeaseRequest: S.Schema<GetMachineLeaseRequest>;
 export interface GetMachineMemoryRequest {
     /** Fly App Name */
     app_name: string;
     /** Machine ID */
     machine_id: string;
 }
-export declare const GetMachineMemoryRequest: S.Schema<GetMachineMemoryRequest>;
 export interface MainMemoryResponse {
     available_mb?: number;
     limit_mb?: number;
 }
-export declare const MainMemoryResponse: S.Schema<MainMemoryResponse>;
 export interface GetMachineMetadataRequest {
     /** Fly App Name */
     app_name: string;
     /** Machine ID */
     machine_id: string;
 }
-export declare const GetMachineMetadataRequest: S.Schema<GetMachineMetadataRequest>;
 export type GetMachineMetadataResponseBodyMap = {
     [key: string]: string | undefined;
 };
-export declare const GetMachineMetadataResponseBodyMap: S.Schema<GetMachineMetadataResponseBodyMap>;
 export type GetMachineMetadataResponse = GetMachineMetadataResponseBodyMap;
-export declare const GetMachineMetadataResponse: S.Schema<GetMachineMetadataResponse>;
 export interface GetMachineMetadataKeyRequest {
     /** Fly App Name */
     app_name: string;
@@ -1646,15 +1383,12 @@ export interface GetMachineMetadataKeyRequest {
     /** Metadata Key */
     key: string;
 }
-export declare const GetMachineMetadataKeyRequest: S.Schema<GetMachineMetadataKeyRequest>;
 export interface MetadataValueResponse {
     value?: string;
 }
-export declare const MetadataValueResponse: S.Schema<MetadataValueResponse>;
 export type PlacementWeights = {
     [key: string]: number | undefined;
 };
-export declare const PlacementWeights: S.Schema<PlacementWeights>;
 export interface GetPlacementsRequest {
     /** Resource requirements for the Machine to simulate. Defaults to a performance-1x machine */
     compute?: FlyMachineGuest;
@@ -1668,27 +1402,21 @@ export interface GetPlacementsRequest {
     /** Optional weights to override default placement preferences. */
     weights?: PlacementWeights;
 }
-export declare const GetPlacementsRequest: S.Schema<GetPlacementsRequest>;
 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 GetPostgresRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
 }
-export declare const GetPostgresRequest: S.Schema<GetPostgresRequest>;
 export interface GetRegionsRequest {
 }
-export declare const GetRegionsRequest: S.Schema<GetRegionsRequest>;
 export interface MainRegionRow {
     code?: string;
     deprecated?: boolean;
@@ -1700,14 +1428,11 @@ export interface MainRegionRow {
     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 GetSecretRequest {
     /** Fly App Name */
     app_name: string;
@@ -1718,7 +1443,6 @@ export interface GetSecretRequest {
     /** Show the secret value. */
     show_secrets?: boolean;
 }
-export declare const GetSecretRequest: S.Schema<GetSecretRequest>;
 export interface AppSecret {
     created_at?: string;
     digest?: string;
@@ -1726,7 +1450,6 @@ export interface AppSecret {
     updated_at?: string;
     value?: string;
 }
-export declare const AppSecret: S.Schema<AppSecret>;
 export interface GetSecretKeyRequest {
     /** Fly App Name */
     app_name: string;
@@ -1735,7 +1458,6 @@ export interface GetSecretKeyRequest {
     /** Minimum secrets version to return. Returned when setting a new secret */
     min_version?: string;
 }
-export declare const GetSecretKeyRequest: S.Schema<GetSecretKeyRequest>;
 export interface SecretKey {
     created_at?: string;
     name?: string;
@@ -1743,14 +1465,12 @@ export interface SecretKey {
     type?: string;
     updated_at?: string;
 }
-export declare const SecretKey: S.Schema<SecretKey>;
 export interface GetVolumeByIdRequest {
     /** Fly App Name */
     app_name: string;
     /** Volume ID */
     volume_id: string;
 }
-export declare const GetVolumeByIdRequest: S.Schema<GetVolumeByIdRequest>;
 export interface ListAppCertificatesRequest {
     /** Fly App Name */
     app_name: string;
@@ -1761,7 +1481,6 @@ export interface ListAppCertificatesRequest {
     /** Number of results per page (default 25, max 500) */
     limit?: number;
 }
-export declare const ListAppCertificatesRequest: S.Schema<ListAppCertificatesRequest>;
 export interface CertificateSummary {
     acme_alpn_configured?: boolean;
     acme_dns_configured?: boolean;
@@ -1777,20 +1496,16 @@ export interface CertificateSummary {
     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 ListAppIPAssignmentsRequest {
     /** Fly App Name */
     app_name: string;
 }
-export declare const ListAppIPAssignmentsRequest: S.Schema<ListAppIPAssignmentsRequest>;
 export interface IPAssignment {
     created_at?: string;
     egress?: boolean;
@@ -1801,13 +1516,10 @@ export interface IPAssignment {
     shared?: boolean;
     type?: string;
 }
-export declare const IPAssignment: S.Schema<IPAssignment>;
 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 ListAppsRequest {
     /** The org slug, or 'personal', to filter apps */
     org_slug: string;
@@ -1818,9 +1530,7 @@ export interface ListAppsRequest {
     /** Value of next_cursor from the previous page. Requires limit. Later pages only include apps that existed when the first page was requested. Apps created in the seconds before the first page was requested may be missing. Cursors expire 30 minutes after the first page was requested. */
     cursor?: string;
 }
-export declare const ListAppsRequest: S.Schema<ListAppsRequest>;
 export type ListAppsResponseAppsList = Array<App>;
-export declare const ListAppsResponseAppsList: S.Schema<ListAppsResponseAppsList>;
 export interface ListAppsResponse {
     apps?: ListAppsResponseAppsList;
     /** Pagination cursor for the next page. Absent when no more apps remain. Cursors expire 30 minutes after the first page was requested. */
@@ -1828,7 +1538,6 @@ export interface ListAppsResponse {
     /** The number of apps matching the request, across all pages. When paginating, it is counted once when the first page is requested and not updated afterwards, so it may differ slightly from the number of apps returned: it excludes apps created later and includes apps deleted while paginating. Apps created in the seconds before the first page may also be counted but missing from the pages. */
     total_apps?: number;
 }
-export declare const ListAppsResponse: S.Schema<ListAppsResponse>;
 export interface ListMachineEventsRequest {
     /** Fly App Name */
     app_name: string;
@@ -1837,11 +1546,8 @@ export interface ListMachineEventsRequest {
     /** The number of events to fetch (max of 50). If omitted, this is set to 20 by default. */
     limit?: number;
 }
-export declare const ListMachineEventsRequest: S.Schema<ListMachineEventsRequest>;
 export type ListMachineEventsResponseBodyList = Array<MachineEvent>;
-export declare const ListMachineEventsResponseBodyList: S.Schema<ListMachineEventsResponseBodyList>;
 export type ListMachineEventsResponse = ListMachineEventsResponseBodyList;
-export declare const ListMachineEventsResponse: S.Schema<ListMachineEventsResponse>;
 export interface ListMachineProcessesRequest {
     /** Fly App Name */
     app_name: string;
@@ -1852,14 +1558,11 @@ export interface ListMachineProcessesRequest {
     /** Order */
     order?: string;
 }
-export declare const ListMachineProcessesRequest: S.Schema<ListMachineProcessesRequest>;
 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;
@@ -1870,11 +1573,8 @@ export interface ProcessStat {
     rtime?: number;
     stime?: number;
 }
-export declare const ProcessStat: S.Schema<ProcessStat>;
 export type ListMachineProcessesResponseBodyList = Array<ProcessStat>;
-export declare const ListMachineProcessesResponseBodyList: S.Schema<ListMachineProcessesResponseBodyList>;
 export type ListMachineProcessesResponse = ListMachineProcessesResponseBodyList;
-export declare const ListMachineProcessesResponse: S.Schema<ListMachineProcessesResponse>;
 export interface ListMachinesRequest {
     /** Fly App Name */
     app_name: string;
@@ -1895,11 +1595,8 @@ export interface ListMachinesRequest {
     /** The number of machines to fetch (must be between 1 and 1000). Providing a limit enables pagination. This limit is advisory; responses may be shorter, or even empty, even when more machines remain. */
     limit?: number;
 }
-export declare const ListMachinesRequest: S.Schema<ListMachinesRequest>;
 export type ListMachinesResponseBodyList = Array<Machine>;
-export declare const ListMachinesResponseBodyList: S.Schema<ListMachinesResponseBodyList>;
 export type ListMachinesResponse = ListMachinesResponseBodyList;
-export declare const ListMachinesResponse: S.Schema<ListMachinesResponse>;
 export interface ListMachinesOrgRequest {
     /** Fly Organization Slug */
     org_slug: string;
@@ -1918,19 +1615,15 @@ export interface ListMachinesOrgRequest {
     /** 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 ListMachinesOrgRequest: S.Schema<ListMachinesOrgRequest>;
 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;
@@ -1943,9 +1636,7 @@ export interface OrgMachine {
     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;
@@ -1953,39 +1644,30 @@ export interface OrgMachinesResponse {
     machines?: OrgMachinesResponseMachinesList;
     next_cursor?: string;
 }
-export declare const OrgMachinesResponse: S.Schema<OrgMachinesResponse>;
 export interface ListMachineVersionsRequest {
     /** Fly App Name */
     app_name: string;
     /** Machine ID */
     machine_id: string;
 }
-export declare const ListMachineVersionsRequest: S.Schema<ListMachineVersionsRequest>;
 export interface MachineVersion {
     user_config?: FlyMachineConfig;
     version?: string;
 }
-export declare const MachineVersion: S.Schema<MachineVersion>;
 export type ListMachineVersionsResponseBodyList = Array<MachineVersion>;
-export declare const ListMachineVersionsResponseBodyList: S.Schema<ListMachineVersionsResponseBodyList>;
 export type ListMachineVersionsResponse = ListMachineVersionsResponseBodyList;
-export declare const ListMachineVersionsResponse: S.Schema<ListMachineVersionsResponse>;
 export interface ListPostgresRequest {
     /** Fly Organization Slug, or 'personal' for the caller's personal organization */
     org_slug: string;
     /** Include deleted clusters */
     include_deleted?: boolean;
 }
-export declare const ListPostgresRequest: S.Schema<ListPostgresRequest>;
 /** Apps attached to the cluster. */
 export type PostgresClusterSummaryAttachedAppsList = Array<PostgresAttachedApp>;
-export declare const PostgresClusterSummaryAttachedAppsList: S.Schema<PostgresClusterSummaryAttachedAppsList>;
 /** Plan slug. */
 export type PostgresClusterSummaryPlan = "basic" | "starter" | "launch" | "scale" | "Performance";
-export declare const PostgresClusterSummaryPlan: any;
 /** Current lifecycle status. */
 export type PostgresClusterSummaryStatus = "creating" | "initializing" | "ready" | "deleting" | "deleted" | "failed";
-export declare const PostgresClusterSummaryStatus: any;
 export interface PostgresClusterSummary {
     /** Apps attached to the cluster. */
     attached_apps?: PostgresClusterSummaryAttachedAppsList;
@@ -2004,21 +1686,16 @@ export interface PostgresClusterSummary {
     /** Current lifecycle status. */
     status?: PostgresClusterSummaryStatus;
 }
-export declare const PostgresClusterSummary: S.Schema<PostgresClusterSummary>;
 export type ListPostgresClustersResponseDataList = Array<PostgresClusterSummary>;
-export declare const ListPostgresClustersResponseDataList: S.Schema<ListPostgresClustersResponseDataList>;
 export interface ListPostgresClustersResponse {
     data?: ListPostgresClustersResponseDataList;
 }
-export declare const ListPostgresClustersResponse: S.Schema<ListPostgresClustersResponse>;
 export interface ListPostgresBackupsRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
 }
-export declare const ListPostgresBackupsRequest: S.Schema<ListPostgresBackupsRequest>;
 /** Backup type. */
 export type PostgresBackupType = "full" | "incr" | "diff";
-export declare const PostgresBackupType: any;
 export interface PostgresBackup {
     /** RFC 3339 stop timestamp. */
     finished_at?: string;
@@ -2033,31 +1710,24 @@ export interface PostgresBackup {
     /** Backup type. */
     type?: PostgresBackupType;
 }
-export declare const PostgresBackup: S.Schema<PostgresBackup>;
 export type ListPostgresBackupsResponseDataList = Array<PostgresBackup>;
-export declare const ListPostgresBackupsResponseDataList: S.Schema<ListPostgresBackupsResponseDataList>;
 export interface ListPostgresBackupsResponse {
     data?: ListPostgresBackupsResponseDataList;
 }
-export declare const ListPostgresBackupsResponse: S.Schema<ListPostgresBackupsResponse>;
 export interface ListPostgresDatabasesRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
 }
-export declare const ListPostgresDatabasesRequest: S.Schema<ListPostgresDatabasesRequest>;
 export type ListPostgresDatabasesResponseDataList = Array<PostgresDatabase>;
-export declare const ListPostgresDatabasesResponseDataList: S.Schema<ListPostgresDatabasesResponseDataList>;
 export interface ListPostgresDatabasesResponse {
     data?: ListPostgresDatabasesResponseDataList;
 }
-export declare const ListPostgresDatabasesResponse: S.Schema<ListPostgresDatabasesResponse>;
 export interface ListPostgresExtensionsRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Database Name */
     database_name: string;
 }
-export declare const ListPostgresExtensionsRequest: S.Schema<ListPostgresExtensionsRequest>;
 /** Installation details, or null when the extension is not installed. */
 export interface PostgresExtensionInstalled {
     /** Schema the extension is installed into. */
@@ -2065,7 +1735,6 @@ export interface PostgresExtensionInstalled {
     /** Installed version. */
     version?: string;
 }
-export declare const PostgresExtensionInstalled: S.Schema<PostgresExtensionInstalled>;
 export interface PostgresExtension {
     /** Default version installed when enabled. */
     default_version?: string;
@@ -2078,24 +1747,18 @@ export interface PostgresExtension {
     /** Whether this is a system extension that cannot be disabled. */
     system?: boolean;
 }
-export declare const PostgresExtension: S.Schema<PostgresExtension>;
 export type ListPostgresExtensionsResponseDataList = Array<PostgresExtension>;
-export declare const ListPostgresExtensionsResponseDataList: S.Schema<ListPostgresExtensionsResponseDataList>;
 export interface ListPostgresExtensionsResponse {
     data?: ListPostgresExtensionsResponseDataList;
 }
-export declare const ListPostgresExtensionsResponse: S.Schema<ListPostgresExtensionsResponse>;
 export interface ListPostgresUsersRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
 }
-export declare const ListPostgresUsersRequest: S.Schema<ListPostgresUsersRequest>;
 export type ListPostgresUsersResponseDataList = Array<PostgresUser>;
-export declare const ListPostgresUsersResponseDataList: S.Schema<ListPostgresUsersResponseDataList>;
 export interface ListPostgresUsersResponse {
     data?: ListPostgresUsersResponseDataList;
 }
-export declare const ListPostgresUsersResponse: S.Schema<ListPostgresUsersResponse>;
 export interface ListSecretKeysRequest {
     /** Fly App Name */
     app_name: string;
@@ -2104,13 +1767,10 @@ export interface ListSecretKeysRequest {
     /** Comma-seperated list of secret keys to list */
     types?: string;
 }
-export declare const ListSecretKeysRequest: S.Schema<ListSecretKeysRequest>;
 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 interface ListSecretsRequest {
     /** Fly App Name */
     app_name: string;
@@ -2119,13 +1779,10 @@ export interface ListSecretsRequest {
     /** Show the secret values. */
     show_secrets?: boolean;
 }
-export declare const ListSecretsRequest: S.Schema<ListSecretsRequest>;
 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 interface ListVolumesRequest {
     /** Fly App Name */
     app_name: string;
@@ -2136,18 +1793,14 @@ export interface ListVolumesRequest {
     /** The number of volumes to fetch (must be between 1 and 1000). Providing a limit enables pagination. This limit is advisory; responses may be shorter, or even empty, even when more volumes remain. */
     limit?: number;
 }
-export declare const ListVolumesRequest: S.Schema<ListVolumesRequest>;
 export type ListVolumesResponseBodyList = Array<Volume>;
-export declare const ListVolumesResponseBodyList: S.Schema<ListVolumesResponseBodyList>;
 export type ListVolumesResponse = ListVolumesResponseBodyList;
-export declare const ListVolumesResponse: S.Schema<ListVolumesResponse>;
 export interface ListVolumeSnapshotsRequest {
     /** Fly App Name */
     app_name: string;
     /** Volume ID */
     volume_id: string;
 }
-export declare const ListVolumeSnapshotsRequest: S.Schema<ListVolumeSnapshotsRequest>;
 export interface VolumeSnapshot {
     created_at?: string;
     digest?: string;
@@ -2157,11 +1810,8 @@ export interface VolumeSnapshot {
     status?: string;
     volume_size?: number;
 }
-export declare const VolumeSnapshot: S.Schema<VolumeSnapshot>;
 export type ListVolumeSnapshotsResponseBodyList = Array<VolumeSnapshot>;
-export declare const ListVolumeSnapshotsResponseBodyList: S.Schema<ListVolumeSnapshotsResponseBodyList>;
 export type ListVolumeSnapshotsResponse = ListVolumeSnapshotsResponseBodyList;
-export declare const ListVolumeSnapshotsResponse: S.Schema<ListVolumeSnapshotsResponse>;
 export interface ListVolumesOrgRequest {
     /** Fly Organization Slug */
     org_slug: string;
@@ -2180,15 +1830,10 @@ export interface ListVolumesOrgRequest {
     /** 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 ListVolumesOrgRequest: S.Schema<ListVolumesOrgRequest>;
 export type OrgVolumeHostFeaturesList = Array<string>;
-export declare const OrgVolumeHostFeaturesList: S.Schema<OrgVolumeHostFeaturesList>;
 export type OrgVolumeHostStatus = "ok" | "unknown" | "unreachable";
-export declare const OrgVolumeHostStatus: any;
 export type OrgVolumeRequiredHostFeaturesList = Array<string>;
-export declare const OrgVolumeRequiredHostFeaturesList: S.Schema<OrgVolumeRequiredHostFeaturesList>;
 export type OrgVolumeType = "local" | "cache";
-export declare const OrgVolumeType: any;
 export interface OrgVolume {
     app_name?: string;
     attached_alloc_id?: string;
@@ -2216,16 +1861,13 @@ export interface OrgVolume {
     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 MachinesReleaseLeaseRequest {
     /** Fly App Name */
     app_name: string;
@@ -2234,14 +1876,11 @@ export interface MachinesReleaseLeaseRequest {
     /** Nonce of the lease to release. Keep the nonce private. */
     lease_nonce: string;
 }
-export declare const MachinesReleaseLeaseRequest: S.Schema<MachinesReleaseLeaseRequest>;
 export interface MachinesReleaseLeaseResponse {
 }
-export declare const MachinesReleaseLeaseResponse: S.Schema<MachinesReleaseLeaseResponse>;
 export type PatchMachineMetadataRequestMetadataMap = {
     [key: string]: string | undefined;
 };
-export declare const PatchMachineMetadataRequestMetadataMap: S.Schema<PatchMachineMetadataRequestMetadataMap>;
 export interface PatchMachineMetadataRequest {
     /** Fly App Name */
     app_name: string;
@@ -2251,17 +1890,14 @@ export interface PatchMachineMetadataRequest {
     metadata?: PatchMachineMetadataRequestMetadataMap;
     updated_at?: string;
 }
-export declare const PatchMachineMetadataRequest: S.Schema<PatchMachineMetadataRequest>;
 export interface PatchMachineMetadataResponse {
 }
-export declare const PatchMachineMetadataResponse: S.Schema<PatchMachineMetadataResponse>;
 export interface PostgresQueriesActiveRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Database to inspect (must not be empty or whitespace-only) */
     database: string;
 }
-export declare const PostgresQueriesActiveRequest: S.Schema<PostgresQueriesActiveRequest>;
 export interface PostgresActiveQuery {
     /** Application connected to the backend. */
     application_name?: string;
@@ -2286,20 +1922,16 @@ export interface PostgresActiveQuery {
     /** Type of event the backend is waiting for. */
     wait_event_type?: string;
 }
-export declare const PostgresActiveQuery: S.Schema<PostgresActiveQuery>;
 export type ListPostgresActiveQueriesResponseDataList = Array<PostgresActiveQuery>;
-export declare const ListPostgresActiveQueriesResponseDataList: S.Schema<ListPostgresActiveQueriesResponseDataList>;
 export interface ListPostgresActiveQueriesResponse {
     data?: ListPostgresActiveQueriesResponseDataList;
 }
-export declare const ListPostgresActiveQueriesResponse: S.Schema<ListPostgresActiveQueriesResponse>;
 export interface PostgresQueriesSlowRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Metrics lookback in seconds */
     range?: number;
 }
-export declare const PostgresQueriesSlowRequest: S.Schema<PostgresQueriesSlowRequest>;
 export interface PostgresSlowQuery {
     /** Cumulative number of executions. */
     calls?: number;
@@ -2318,31 +1950,25 @@ export interface PostgresSlowQuery {
     /** User running the query. */
     user?: string;
 }
-export declare const PostgresSlowQuery: S.Schema<PostgresSlowQuery>;
 export type ListPostgresSlowQueriesResponseDataList = Array<PostgresSlowQuery>;
-export declare const ListPostgresSlowQueriesResponseDataList: S.Schema<ListPostgresSlowQueriesResponseDataList>;
 export interface ListPostgresSlowQueriesResponse {
     data?: ListPostgresSlowQueriesResponseDataList;
 }
-export declare const ListPostgresSlowQueriesResponse: S.Schema<ListPostgresSlowQueriesResponse>;
 export interface PostgresUsersCredentialsRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
     /** Postgres User Name */
     username: string;
 }
-export declare const PostgresUsersCredentialsRequest: S.Schema<PostgresUsersCredentialsRequest>;
 export interface PostgresUserCredentials {
     /** User password. */
-    password?: string;
+    password?: string | Redacted.Redacted<string>;
     /** User name. */
     username?: string;
 }
-export declare const PostgresUserCredentials: S.Schema<PostgresUserCredentials>;
 export interface GetPostgresUserCredentialsResponse {
     data?: PostgresUserCredentials;
 }
-export declare const GetPostgresUserCredentialsResponse: S.Schema<GetPostgresUserCredentialsResponse>;
 export interface ReclaimMachineMemoryRequest {
     /** Fly App Name */
     app_name: string;
@@ -2350,27 +1976,20 @@ export interface ReclaimMachineMemoryRequest {
     machine_id: string;
     amount_mb?: number;
 }
-export declare const ReclaimMachineMemoryRequest: S.Schema<ReclaimMachineMemoryRequest>;
 export interface MainReclaimMemoryResponse {
     actual_mb?: number;
 }
-export declare const MainReclaimMemoryResponse: S.Schema<MainReclaimMemoryResponse>;
 export interface RequestKmsTokenRequest {
 }
-export declare const RequestKmsTokenRequest: S.Schema<RequestKmsTokenRequest>;
 export interface RequestKmsTokenResponse {
 }
-export declare const RequestKmsTokenResponse: S.Schema<RequestKmsTokenResponse>;
 export interface RequestOidcTokenRequest {
     aud?: string;
     aws_principal_tags?: boolean;
 }
-export declare const RequestOidcTokenRequest: S.Schema<RequestOidcTokenRequest>;
 export interface RequestOidcTokenResponse {
 }
-export declare const RequestOidcTokenResponse: S.Schema<RequestOidcTokenResponse>;
 export type RestartMachineRequestSignal = "SIGHUP" | "SIGINT" | "SIGQUIT" | "SIGKILL" | "SIGUSR1" | "SIGUSR2" | "SIGTERM";
-export declare const RestartMachineRequestSignal: any;
 export interface RestartMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -2382,10 +2001,8 @@ export interface RestartMachineRequest {
     signal?: RestartMachineRequestSignal | (string & {});
     lease_nonce?: string;
 }
-export declare const RestartMachineRequest: S.Schema<RestartMachineRequest>;
 export interface RestartMachineResponse {
 }
-export declare const RestartMachineResponse: S.Schema<RestartMachineResponse>;
 export interface RestorePostgresRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
@@ -2396,7 +2013,6 @@ export interface RestorePostgresRequest {
     /** Point in time to restore to, as an RFC3339 timestamp with an explicit offset from UTC (e.g. Z or +02:00). Normalized to UTC and must fall within the cluster's PITR recovery window. Mutually exclusive with backup_id. */
     pitr_time?: string;
 }
-export declare const RestorePostgresRequest: S.Schema<RestorePostgresRequest>;
 export interface RotatePostgresUserPasswordRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
@@ -2405,11 +2021,9 @@ export interface RotatePostgresUserPasswordRequest {
     /** Terminate the user's existing sessions after rotating. */
     kill_sessions?: boolean;
 }
-export declare const RotatePostgresUserPasswordRequest: S.Schema<RotatePostgresUserPasswordRequest>;
 export interface RotatePostgresPasswordResponse {
     data?: PostgresUserCredentials;
 }
-export declare const RotatePostgresPasswordResponse: S.Schema<RotatePostgresPasswordResponse>;
 export interface SetMachineMemoryLimitRequest {
     /** Fly App Name */
     app_name: string;
@@ -2417,9 +2031,7 @@ export interface SetMachineMemoryLimitRequest {
     machine_id: string;
     limit_mb?: number;
 }
-export declare const SetMachineMemoryLimitRequest: S.Schema<SetMachineMemoryLimitRequest>;
 export type SetSecretKeyRequestValueList = Array<number>;
-export declare const SetSecretKeyRequestValueList: S.Schema<SetSecretKeyRequestValueList>;
 export interface SetSecretKeyRequest {
     /** Fly App Name */
     app_name: string;
@@ -2428,9 +2040,7 @@ export interface SetSecretKeyRequest {
     type?: string;
     value?: SetSecretKeyRequestValueList;
 }
-export declare const SetSecretKeyRequest: S.Schema<SetSecretKeyRequest>;
 export type SignalMachineRequestSignal = "SIGABRT" | "SIGALRM" | "SIGFPE" | "SIGHUP" | "SIGILL" | "SIGINT" | "SIGKILL" | "SIGPIPE" | "SIGQUIT" | "SIGSEGV" | "SIGTERM" | "SIGTRAP" | "SIGUSR1" | "SIGUSR2";
-export declare const SignalMachineRequestSignal: any;
 export interface SignalMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -2438,10 +2048,8 @@ export interface SignalMachineRequest {
     machine_id: string;
     signal?: SignalMachineRequestSignal | (string & {});
 }
-export declare const SignalMachineRequest: S.Schema<SignalMachineRequest>;
 export interface SignalMachineResponse {
 }
-export declare const SignalMachineResponse: S.Schema<SignalMachineResponse>;
 export interface SignSecretKeyRequest {
     /** Fly App Name */
     app_name: string;
@@ -2449,13 +2057,11 @@ export interface SignSecretKeyRequest {
     secret_name: string;
     /** Minimum secrets version to return. Returned when setting a new secret */
     min_version?: string;
-    plaintext?: string;
+    plaintext?: string | Redacted.Redacted<string>;
 }
-export declare const SignSecretKeyRequest: S.Schema<SignSecretKeyRequest>;
 export interface SignSecretkeyResponse {
     signature?: string;
 }
-export declare const SignSecretkeyResponse: S.Schema<SignSecretkeyResponse>;
 export interface StartMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -2463,12 +2069,9 @@ export interface StartMachineRequest {
     machine_id: string;
     lease_nonce?: string;
 }
-export declare const StartMachineRequest: S.Schema<StartMachineRequest>;
 export interface StartMachineResponse {
 }
-export declare const StartMachineResponse: S.Schema<StartMachineResponse>;
 export type StopMachineRequestSignal = "SIGHUP" | "SIGINT" | "SIGQUIT" | "SIGKILL" | "SIGUSR1" | "SIGUSR2" | "SIGTERM";
-export declare const StopMachineRequestSignal: any;
 export interface StopMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -2478,10 +2081,8 @@ export interface StopMachineRequest {
     timeout?: string;
     lease_nonce?: string;
 }
-export declare const StopMachineRequest: S.Schema<StopMachineRequest>;
 export interface StopMachineResponse {
 }
-export declare const StopMachineResponse: S.Schema<StopMachineResponse>;
 export interface SuspendMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -2489,10 +2090,8 @@ export interface SuspendMachineRequest {
     machine_id: string;
     lease_nonce?: string;
 }
-export declare const SuspendMachineRequest: S.Schema<SuspendMachineRequest>;
 export interface SuspendMachineResponse {
 }
-export declare const SuspendMachineResponse: S.Schema<SuspendMachineResponse>;
 export interface UncordonMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -2500,10 +2099,8 @@ export interface UncordonMachineRequest {
     machine_id: string;
     lease_nonce?: string;
 }
-export declare const UncordonMachineRequest: S.Schema<UncordonMachineRequest>;
 export interface UncordonMachineResponse {
 }
-export declare const UncordonMachineResponse: S.Schema<UncordonMachineResponse>;
 export interface UpdateMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -2524,10 +2121,8 @@ export interface UpdateMachineRequest {
     skip_service_registration?: boolean;
     lease_nonce?: string;
 }
-export declare const UpdateMachineRequest: S.Schema<UpdateMachineRequest>;
 /** New role for the user. */
 export type UpdatePostgresUserRoleRequestRole = "schema_admin" | "writer" | "reader";
-export declare const UpdatePostgresUserRoleRequestRole: any;
 export interface UpdatePostgresUserRoleRequest {
     /** Managed Postgres Cluster ID */
     postgres_cluster_id: string;
@@ -2536,29 +2131,23 @@ export interface UpdatePostgresUserRoleRequest {
     /** New role for the user. */
     role: UpdatePostgresUserRoleRequestRole | (string & {});
 }
-export declare const UpdatePostgresUserRoleRequest: S.Schema<UpdatePostgresUserRoleRequest>;
 export interface UpdatePostgresUserRoleResponse {
 }
-export declare const UpdatePostgresUserRoleResponse: S.Schema<UpdatePostgresUserRoleResponse>;
 export type UpdateSecretsRequestValuesMap = {
     [key: string]: string | undefined;
 };
-export declare const UpdateSecretsRequestValuesMap: S.Schema<UpdateSecretsRequestValuesMap>;
 export interface UpdateSecretsRequest {
     /** Fly App Name */
     app_name: string;
     values?: UpdateSecretsRequestValuesMap;
 }
-export declare const UpdateSecretsRequest: S.Schema<UpdateSecretsRequest>;
 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 UpdateVolumeRequest {
     /** Fly App Name */
     app_name: string;
@@ -2567,7 +2156,6 @@ export interface UpdateVolumeRequest {
     auto_backup_enabled?: boolean;
     snapshot_retention?: number;
 }
-export declare const UpdateVolumeRequest: S.Schema<UpdateVolumeRequest>;
 export interface UpsertMachineMetadataRequest {
     /** Fly App Name */
     app_name: string;
@@ -2578,10 +2166,8 @@ export interface UpsertMachineMetadataRequest {
     updated_at?: string;
     value?: string;
 }
-export declare const UpsertMachineMetadataRequest: S.Schema<UpsertMachineMetadataRequest>;
 export interface UpsertMachineMetadataResponse {
 }
-export declare const UpsertMachineMetadataResponse: S.Schema<UpsertMachineMetadataResponse>;
 export interface VerifySecretKeyRequest {
     /** Fly App Name */
     app_name: string;
@@ -2589,15 +2175,12 @@ export interface VerifySecretKeyRequest {
     secret_name: string;
     /** Minimum secrets version to return. Returned when setting a new secret */
     min_version?: string;
-    plaintext?: string;
+    plaintext?: string | Redacted.Redacted<string>;
     signature?: string;
 }
-export declare const VerifySecretKeyRequest: S.Schema<VerifySecretKeyRequest>;
 export interface VerifySecretKeyResponse {
 }
-export declare const VerifySecretKeyResponse: S.Schema<VerifySecretKeyResponse>;
 export type WaitMachineRequestState = "started" | "stopped" | "suspended" | "destroyed" | "failed" | "settled";
-export declare const WaitMachineRequestState: any;
 export interface WaitMachineRequest {
     /** Fly App Name */
     app_name: string;
@@ -2614,14 +2197,12 @@ export interface WaitMachineRequest {
     /** desired state(s), supports repeated or comma-separated values */
     state?: WaitMachineRequestState | (string & {});
 }
-export declare const WaitMachineRequest: S.Schema<WaitMachineRequest>;
 export interface WaitMachineResponse {
     event_id?: string;
     ok?: boolean;
     state?: string;
     version?: string;
 }
-export declare const WaitMachineResponse: S.Schema<WaitMachineResponse>;
 export type AuthenticateTokenError = BadRequest | FlyIoOpError;
 /** Authenticate token header Verify a token header without checking resource access. */
 export declare const authenticateToken: API.OperationMethod<AuthenticateTokenRequest, AuthenticateTokenResponse, AuthenticateTokenError, FlyIoOpContext>;
@@ -2632,7 +2213,7 @@ export type CheckAppCertificateError = BadRequest | Forbidden | NotFound | FlyIo
 /** Check DNS and re-validate certificate */
 export declare const checkAppCertificate: API.OperationMethod<CheckAppCertificateRequest, CertificateCheckResponse, CheckAppCertificateError, FlyIoOpContext>;
 export type CordonMachineError = BadRequest | Forbidden | NotFound | Conflict | FlyIoOpError;
-/** Cordon Machine “Cordoning” a Machine refers to disabling its services, so the Fly Proxy won’t route requests to it. In flyctl this is used by blue/green deployments; one set of Machines is started up with services disabled, and when they are all healthy, the services are enabled on the new Machines and disabled on the old ones. */
+/** Cordon Machine "Cordoning" a Machine refers to disabling its services, so the Fly Proxy won't route requests to it. In flyctl this is used by blue/green deployments; one set of Machines is started up with services disabled, and when they are all healthy, the services are enabled on the new Machines and disabled on the old ones. */
 export declare const cordonMachine: API.OperationMethod<CordonMachineRequest, CordonMachineResponse, CordonMachineError, FlyIoOpContext>;
 export type CreateAppError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | FlyIoOpError;
 /** Create App Create an app with the specified details in the request body. */
@@ -2650,7 +2231,7 @@ export type CreateAppIPAssignmentError = BadRequest | Forbidden | NotFound | Con
 /** Assign new IP address to app */
 export declare const createAppIPAssignment: API.OperationMethod<CreateAppIPAssignmentRequest, AssignIPResponse, CreateAppIPAssignmentError, FlyIoOpContext>;
 export type CreateMachineError = BadRequest | Forbidden | NotFound | Conflict | FlyIoOpError;
-/** Create Machine Create a Machine within a specific app using the details provided in the request body. **Important**: This request can fail, and you’re responsible for handling that failure. If you ask for a large Machine, or a Machine in a region we happen to be at capacity for, you might need to retry the request, or to fall back to another region. If you’re working directly with the Machines API, you’re taking some responsibility for your own orchestration! */
+/** Create Machine Create a Machine within a specific app using the details provided in the request body. **Important**: This request can fail, and you're responsible for handling that failure. If you ask for a large Machine, or a Machine in a region we happen to be at capacity for, you might need to retry the request, or to fall back to another region. If you're working directly with the Machines API, you're taking some responsibility for your own orchestration! */
 export declare const createMachine: API.OperationMethod<CreateMachineRequest, Machine, CreateMachineError, FlyIoOpContext>;
 export type CreateMachineLeaseError = BadRequest | Forbidden | NotFound | Conflict | FlyIoOpError;
 /** Create Lease Create a lease for a specific Machine within an app using the details provided in the request body. Machine leases can be used to obtain an exclusive lock on modifying a Machine. */
@@ -2896,7 +2477,7 @@ export type SuspendMachineError = BadRequest | Forbidden | NotFound | Conflict |
 /** Suspend Machine Suspend a specific Machine within an app. The next start operation will attempt (but is not guaranteed) to resume the Machine from a snapshot taken at suspension time, rather than performing a cold boot. */
 export declare const suspendMachine: API.OperationMethod<SuspendMachineRequest, SuspendMachineResponse, SuspendMachineError, FlyIoOpContext>;
 export type UncordonMachineError = BadRequest | Forbidden | NotFound | Conflict | FlyIoOpError;
-/** Uncordon Machine “Cordoning” a Machine refers to disabling its services, so the Fly Proxy won’t route requests to it. In flyctl this is used by blue/green deployments; one set of Machines is started up with services disabled, and when they are all healthy, the services are enabled on the new Machines and disabled on the old ones. */
+/** Uncordon Machine "Cordoning" a Machine refers to disabling its services, so the Fly Proxy won't route requests to it. In flyctl this is used by blue/green deployments; one set of Machines is started up with services disabled, and when they are all healthy, the services are enabled on the new Machines and disabled on the old ones. */
 export declare const uncordonMachine: API.OperationMethod<UncordonMachineRequest, UncordonMachineResponse, UncordonMachineError, FlyIoOpContext>;
 export type UpdateMachineError = BadRequest | Forbidden | NotFound | Conflict | FlyIoOpError;
 /** Update Machine Update a Machine's configuration using the details provided in the request body. */