@cloudflare/containers-shared 0.16.0

package/dist/index.d.mts

@@ -0,0 +1,3843 @@
+import { ComplianceConfig, Logger, FetchResultFetcher, FetchPagedListResultFetcher, Config, ContainerApp } from '@cloudflare/workers-utils';
+import { ComplianceConfig as ComplianceConfig$1 } from '@cloudflare/workers-utils/compliance';
+import { StdioOptions } from 'node:child_process';
+
+type ApiRequestOptions = {
+    readonly method: "GET" | "PUT" | "POST" | "DELETE" | "OPTIONS" | "HEAD" | "PATCH";
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};
+
+type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};
+
+declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}
+
+declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+
+/**
+ * To the extend possible, prefer nodes with specified characteristics when placing application instances.
+ *
+ */
+declare enum ApplicationAffinityHardwareGeneration {
+    HIGHEST_OVERALL_PERFORMANCE = "highest-overall-performance"
+}
+
+interface WranglerLogger {
+    debug: (...args: unknown[]) => void;
+    debugWithSanitization: (label: string, ...args: unknown[]) => void;
+    log: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+interface ViteLogger {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+}
+type BuildArgs = {
+    /** image tag in the format `name:tag`, where tag is optional */
+    tag: string;
+    pathToDockerfile: string;
+    /** image_build_context or args.PATH. if not provided, defaults to the dockerfile directory */
+    buildContext: string;
+    /** any env vars that should be passed in at build time */
+    args?: Record<string, string>;
+    /** platform to build for. defaults to linux/amd64 */
+    platform?: string;
+};
+type ContainerNormalizedConfig = SharedContainerConfig & (ImageURIConfig | DockerfileConfig);
+type DockerfileConfig = {
+    /** absolute path, resolved relative to the wrangler config file */
+    dockerfile: string;
+    /** absolute path, resolved relative to the wrangler config file. defaults to the directory of the dockerfile */
+    image_build_context: string;
+    image_vars?: Record<string, string>;
+};
+type ImageURIConfig = {
+    image_uri: string;
+};
+type InstanceTypeOrLimits = {
+    /** if undefined in config, defaults to instance_type */
+    /** disk size is defined in config in mb but normalized here to bytes */
+    disk_bytes: number;
+    vcpu: number;
+    memory_mib: number;
+} | {
+    /** if undefined in config, defaults to "dev" */
+    instance_type: InstanceType;
+};
+/**
+ * Shared container config that is used regardless of whether the image is from a dockerfile or a registry link.
+ */
+type SharedContainerConfig = {
+    /** if undefined in config, defaults to worker_name[-envName]-class_name. */
+    name: string;
+    /** container's DO class name */
+    class_name: string;
+    /** if undefined in config, defaults to 0 */
+    max_instances: number;
+    /** if undefined in config, defaults to "default" */
+    scheduling_policy: SchedulingPolicy;
+    /** if undefined in config, defaults to [90, 10] */
+    rollout_step_percentage: number | number[];
+    /** if undefined in config, defaults to "full_auto" */
+    rollout_kind: "full_auto" | "full_manual" | "none";
+    rollout_active_grace_period: number;
+    wrangler_ssh?: WranglerSSHConfig;
+    authorized_keys?: Array<UserSSHPublicKey>;
+    trusted_user_ca_keys?: Array<UserSSHPublicKey>;
+    constraints: {
+        regions?: string[];
+        jurisdiction?: string;
+        cities?: string[];
+        tiers?: number[];
+    };
+    affinities?: {
+        colocation?: ApplicationAffinityColocation;
+        hardware_generation?: ApplicationAffinityHardwareGeneration;
+    };
+    observability: {
+        logs_enabled: boolean;
+        target_instance_percentage?: number;
+        target_instance_count?: number;
+    };
+} & InstanceTypeOrLimits;
+/** build/pull agnostic container options */
+type ContainerDevOptions = {
+    /** formatted as cloudflare-dev/workername-DOclassname:build-id */
+    image_tag: string;
+    /** container's DO class name */
+    class_name: string;
+} & (DockerfileConfig | ImageURIConfig);
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: "include" | "omit" | "same-origin";
+    TOKEN?: string | Resolver<string>;
+    USERNAME?: string | Resolver<string>;
+    PASSWORD?: string | Resolver<string>;
+    HEADERS?: Headers | Resolver<Headers>;
+    ENCODE_PATH?: (path: string) => string;
+    LOGGER?: WranglerLogger | undefined;
+};
+declare const OpenAPI: OpenAPIConfig;
+
+type ResultInfo = {
+    page_token?: string;
+    per_page?: number;
+    next_page_token?: string;
+};
+type PaginatedResult<T> = {
+    data: T;
+    resultInfo?: ResultInfo;
+};
+
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
+/**
+ * Request method that preserves pagination info from V4 responses
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<PaginatedResult<T>>
+ * @throws ApiError
+ */
+declare const requestPaginated: <T>(config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<PaginatedResult<T>>;
+
+/**
+ * A memory size that specifies its unit at the end.
+ */
+type MemorySizeWithUnit = string;
+
+/**
+ * Represents the default configuration for an account
+ */
+type AccountDefaults = {
+    vcpus: number;
+    memory_mib: number;
+    /**
+     * Default disk size in MB
+     */
+    disk_mb?: number;
+    /**
+     * Deprecated in favor of memory_mib
+     * @deprecated
+     */
+    memory?: MemorySizeWithUnit;
+};
+
+/**
+ * A unique identifier for the account
+ */
+type AccountID = string;
+
+/**
+ * A disk size that specifies its unit at the end.
+ */
+type DiskSizeWithUnit = string;
+
+/**
+ * Defines the network mode that the VM can include
+ */
+declare enum NetworkMode {
+    USO = "uso",
+    VHOST = "vhost",
+    XDP = "xdp"
+}
+
+/**
+ * The node type that a deployment can be deployed to. 'metal' defines normal Cloudflare metals, 'cloudchamber' is Cloudchamber nodes. For new accounts it should always be 'metal'.
+ */
+declare enum NodeGroup {
+    METAL = "metal",
+    CLOUDCHAMBER = "cloudchamber"
+}
+
+/**
+ * Represents a Cloudchamber account limit
+ */
+type AccountLimit = {
+    account_id: AccountID;
+    vcpu_per_deployment: number;
+    /**
+     * Deprecated in favor of memory_mib_per_deployment
+     * @deprecated
+     */
+    memory_per_deployment: MemorySizeWithUnit;
+    memory_mib_per_deployment: number;
+    /**
+     * Deprecated in favor of disk_mb_per_deployment
+     * @deprecated
+     */
+    disk_per_deployment: DiskSizeWithUnit;
+    disk_mb_per_deployment: number;
+    total_vcpu: number;
+    /**
+     * Deprecated in favor of total_memory_mib
+     * @deprecated
+     */
+    total_memory: MemorySizeWithUnit;
+    total_memory_mib: number;
+    /**
+     * Total amount of disk usage allowed for the account
+     */
+    total_disk_mb: number;
+    node_group: NodeGroup;
+    /**
+     * Network modes that will be included in this customer's vm
+     */
+    network_modes: Array<NetworkMode>;
+    /**
+     * Number of ipv4s available to the account
+     */
+    ipv4s: number;
+};
+
+/**
+ * Unique location code used to identify locations on a logical level
+ */
+type LocationID = string;
+
+/**
+ * Represents a location where an account can create/modify deployments.
+ */
+type AccountLocation = {
+    location: LocationID;
+};
+
+/**
+ * Represents the limits related to a location
+ */
+type AccountLocationLimits = {
+    vcpu_per_deployment: number;
+    /**
+     * Deprecated in favor of memory_mib_per_deployment
+     * @deprecated
+     */
+    memory_per_deployment: MemorySizeWithUnit;
+    memory_mib_per_deployment?: number;
+    total_vcpu: number;
+    /**
+     * Deprecated in favor of total_memory_mib
+     * @deprecated
+     */
+    total_memory: MemorySizeWithUnit;
+    total_memory_mib?: number;
+};
+
+/**
+ * Represents an account location limits property
+ */
+type AccountLocationLimitsAsProperty = {
+    limits: AccountLocationLimits;
+};
+
+/**
+ * An account registry token object that can be used to push and pull images to the registry's current account namespace
+ */
+type AccountRegistryToken = {
+    account_id: AccountID;
+    registry_host: string;
+    username: string;
+    /**
+     * If password is unset, this registry is a public one that doesn't need credentials
+     */
+    password?: string;
+};
+
+/**
+ * A deployment ID represents an identifier of a deployment configuration that maintains a healthy placement
+ */
+type DeploymentID = string;
+
+/**
+ * Placement ID
+ */
+type PlacementID = string;
+
+/**
+ * UTC Unix EPOCH in seconds
+ */
+type UnixTimestamp = number;
+
+/**
+ * The allocation that exists when an IP or a port range has been assigned to a metal
+ */
+type AddressAssignment = {
+    placementID?: PlacementID;
+    expiration?: UnixTimestamp;
+    deploymentID?: DeploymentID;
+};
+
+/**
+ * Colocation affinity is designed so schedulers try to place application instances all in the same way. Colocation is best-effort depending on available resources. If there is some leftover set of instances
+ * that can't be placed together, the scheduler will try to place them somewhere else.
+ *
+ */
+declare enum ApplicationAffinityColocation {
+    DATACENTER = "datacenter"
+}
+
+/**
+ * Defines affinity in application scheduling. (This still an experimental feature, some schedulers might not work with these affinities).
+ *
+ */
+type ApplicationAffinities = {
+    colocation?: ApplicationAffinityColocation;
+    hardware_generation?: ApplicationAffinityHardwareGeneration;
+};
+
+/**
+ * The name of a pop to be specified in an application pop. Requires specific entitlements to use this.
+ */
+type ApplicationConstraintPop = string;
+
+/**
+ * A city is represented as an airport code like MAD or SFO.
+ */
+type City = string;
+
+/**
+ * Represents a group of datacenters. You can choose between:
+ * "AFR", "APAC", "EEUR", "ENAM", "WNAM", "ME", "OC", "SAM", "WEUR".
+ *
+ */
+type Region = string;
+
+type ApplicationConstraints = {
+    region?: Region;
+    tier?: number;
+    tiers?: Array<number>;
+    regions?: Array<Region>;
+    cities?: Array<City>;
+    pops?: Array<ApplicationConstraintPop>;
+};
+
+type ApplicationHealthInstances = {
+    /**
+     * Number of active containers in this application.
+     *
+     */
+    active: number;
+    /**
+     * Number of healthy instances. If the application is attached to a DO namespace,
+     * this represents the number of prepared container instances.
+     *
+     */
+    healthy: number;
+    /**
+     * Number of failing container instances.
+     *
+     */
+    failed: number;
+    /**
+     * Number of container instances that are being prepared.
+     *
+     */
+    starting: number;
+    /**
+     * Number of container instances pending to be scheduled.
+     *
+     */
+    scheduling: number;
+};
+
+type ApplicationHealth = {
+    instances: ApplicationHealthInstances;
+};
+
+/**
+ * An Application ID represents an identifier of an application
+ */
+type ApplicationID = string;
+
+/**
+ * Application config denoting deployments with Jobs type
+ */
+type ApplicationJobsConfig = boolean;
+
+/**
+ * The application name
+ */
+type ApplicationName = string;
+
+/**
+ * Observability logging settings.
+ */
+type ObservabilityLogs = {
+    enabled?: boolean;
+};
+
+/**
+ * Application-level observability settings.
+ */
+type ApplicationObservability = {
+    logs?: ObservabilityLogs;
+    target_instance_percentage?: number;
+    target_instance_count?: number;
+};
+
+/**
+ * Application instance priority.
+ */
+type ApplicationPriority = number;
+
+/**
+ * Defines priorities of application instances that are taken into account in scheduling decisions
+ * and used to determine what instances should be evicted in the face of resource scarcity.
+ * The feature is experimental and only supported with the "gpu" scheduling policy.
+ *
+ */
+type ApplicationPriorities = {
+    default: ApplicationPriority;
+};
+
+/**
+ * Grace period for active instances to stay alive before becoming elibile for shutdown signal due to a rollout, in seconds.
+ * Defaults to 0.
+ *
+ */
+type ApplicationRolloutActiveGracePeriod = number;
+
+type ExecFormParam = string;
+
+/**
+ * The command to be executed when the container starts, passed to the entrypoint.
+ * This can be overridden at run-time. If only the command is overridden at run-time,
+ * it gets passed to the default entrypoint specified in the image.
+ *
+ */
+type Command = Array<ExecFormParam>;
+
+/**
+ * Available HTTP methods for health and readiness checks.
+ */
+declare enum HTTPMethod {
+    GET = "GET",
+    POST = "POST",
+    PATCH = "PATCH",
+    PUT = "PUT",
+    OPTIONS = "OPTIONS",
+    DELETE = "DELETE",
+    HEAD = "HEAD"
+}
+
+/**
+ * Configuration for HTTP checks.
+ */
+type DeploymentCheckHTTPRequestBody = {
+    method?: HTTPMethod;
+    /**
+     * If the method is one of POST, PATCH or PUT, this is required. It's the body that will be passed to the HTTP healthcheck request.
+     */
+    body?: string;
+    /**
+     * Path that will be used to perform the healthcheck.
+     */
+    path?: string;
+    /**
+     * HTTP headers to include in the request.
+     */
+    headers?: Record<string, any>;
+};
+
+declare enum DeploymentCheckKind {
+    HEALTH = "health",
+    READY = "ready"
+}
+
+declare enum DeploymentCheckType {
+    HTTP = "http",
+    TCP = "tcp"
+}
+
+/**
+ * Duration string. From Go documentation:
+ * A string representing the duration in the form "3d1h3m". Leading zero units are omitted.
+ * As a special case, durations less than one second format use a smaller unit (milli-, micro-, or nanoseconds)
+ * to ensure that the leading digit is non-zero.
+ *
+ */
+type Duration = string;
+
+/**
+ * Health and readiness checks for a deployment
+ */
+type DeploymentCheckRequestBody = {
+    /**
+     * Optional name for the check. If omitted, a name will be generated automatically.
+     */
+    name?: string;
+    /**
+     * The type of check to perform. A TCP check succeeds if it can connect to the provided port. An HTTP check succeeds if it receives a successful HTTP response (2XX)
+     */
+    type: DeploymentCheckType;
+    /**
+     * Connect to the port using TLS
+     */
+    tls?: boolean;
+    /**
+     * The name of the port defined in the "ports" property of the deployment
+     */
+    port: string;
+    /**
+     * Configuration for HTTP checks. Only valid when "type" is "http"
+     */
+    http?: DeploymentCheckHTTPRequestBody;
+    /**
+     * How often the check should be performed
+     */
+    interval: Duration;
+    /**
+     * The amount of time to wait for the check to complete before considering the check to have failed
+     */
+    timeout: Duration;
+    /**
+     * Number of times to attempt the check before considering it to have failed
+     */
+    attempts_before_failure?: number;
+    /**
+     * The kind of check. A failed "healthy" check affects a deployment's "healthy" status, while a failed "ready" check affects a deployment's "ready" status
+     */
+    kind: DeploymentCheckKind;
+    /**
+     * Initial time period after container start during which failed checks will be ignored
+     */
+    grace_period?: Duration;
+};
+
+/**
+ * The secret access type denotes how a secret is made available within a container. Available Options are "env".
+ */
+declare enum SecretAccessType {
+    ENV = "env"
+}
+
+/**
+ * Specifies how secrets are accessed in containers, defining the name of the secret within the container and the corresponding account secret name.
+ */
+type DeploymentSecretMap = {
+    /**
+     * The name of the secret within the container
+     */
+    name: string;
+    type: SecretAccessType;
+    /**
+     * Corresponding secret name from the account
+     */
+    secret: string;
+};
+
+/**
+ * The disk configuration for this deployment. By default, all containers have a disk size of 2GB.
+ */
+type Disk = {
+    /**
+     * Deprecated in favor of size_mb.
+     * @deprecated
+     */
+    size?: DiskSizeWithUnit;
+    /**
+     * Size of the disk, in MB.
+     */
+    size_mb?: number;
+};
+
+/**
+ * A string representation of a domain name. See RFC-1034 (https://www.ietf.org/rfc/rfc1034.txt). Consider that the limit of a domain name is min 3 and max 253 ASCII characters.
+ */
+type Domain = string;
+
+/**
+ * A string representation of an IP, can be both v6 and v4.
+ */
+type IP = string;
+
+/**
+ * Represents the /etc/resolv.conf that will appear in the deployment.
+ * If the 'dns' property is specified, even if empty object, will override the default resolv.conf of the container.
+ * The default resolv.conf of a container is 'servers = ["1.1.1.1", "9.9.9.9", "2606:4700:4700::1111"]', only if an IPv4 is assigned.
+ * The default for a non IPv4 deployment is 'servers = ["2606:4700:4700::1111", "2620:fe::fe"]'.
+ *
+ */
+type DNSConfiguration = {
+    /**
+     * List of DNS servers that the deployment will use to resolve domain names. You can only specify a maximum of 3.
+     */
+    servers?: Array<IP>;
+    /**
+     * The container resolver will append these domains to every resolve query. For example, if you have 'google.com',
+     * and your deployment queries 'web', it will append 'google.com' to 'web' in the search query before trying 'web'.
+     * Limited to 6 domains.
+     *
+     */
+    searches?: Array<Domain>;
+};
+
+/**
+ * The entry point for the container, specifying the executable to run when the container starts.
+ * This can be overridden at run-time. If overridden, the default command from the image is ignored.
+ * Both entrypoint and command can be specified at run-time to completely replace the image defaults.
+ *
+ */
+type Entrypoint = Array<ExecFormParam>;
+
+/**
+ * An environment variable name
+ */
+type EnvironmentVariableName = string;
+
+/**
+ * An environment variable value
+ */
+type EnvironmentVariableValue = string;
+
+/**
+ * An environment variable with a value set
+ */
+type EnvironmentVariable = {
+    name: EnvironmentVariableName;
+    value: EnvironmentVariableValue;
+};
+
+/**
+ * Image url
+ */
+type Image = string;
+
+/**
+ * The instance type will be used to configure vcpu, memory, and disk.
+ *
+ * - "lite": This will use a configuration of 1/16 vCPU, 256 MiB memory, and 2 GB disk
+ * - "basic": This will use a configuration of 1/4 vCPU, 1 GiB memory, and 4 GB disk
+ * - "standard-1": This will use a configuration of 1/2 vCPU, 4 GiB memory, and 8 GB disk
+ * - "standard-2": This will use a configuration of 1 vCPU, 6 GiB memory, and 12 GB disk
+ * - "standard-3": This will use a configuration of 2 vCPU, 8 GiB memory, and 16 GB disk
+ * - "standard-4": This will use a configuration of 4 vCPU, 12 GiB memory, and 20 GB disk
+ * - "standard": This will use a configuration of 1/2 vCPU, 4 GiB memory, and 4 GB disk. Now deprecated.
+ * - "dev": Is an alias for "lite". Now deprecated.
+ *
+ * The default is "lite".
+ *
+ */
+declare enum InstanceType {
+    LITE = "lite",
+    DEV = "dev",
+    BASIC = "basic",
+    STANDARD = "standard",
+    STANDARD_1 = "standard-1",
+    STANDARD_2 = "standard-2",
+    STANDARD_3 = "standard-3",
+    STANDARD_4 = "standard-4"
+}
+
+/**
+ * A label name
+ */
+type LabelName = string;
+
+/**
+ * A label value
+ */
+type LabelValue = string;
+
+/**
+ * A label
+ */
+type Label = {
+    name: LabelName;
+    value: LabelValue;
+};
+
+declare enum AssignIPv4 {
+    NONE = "none",
+    PREDEFINED = "predefined",
+    ACCOUNT = "account"
+}
+
+declare enum AssignIPv6 {
+    NONE = "none",
+    PREDEFINED = "predefined",
+    ACCOUNT = "account"
+}
+
+/**
+ * Defines the kind of networking the container will have. If "public", the container will be assigned at least an IPv6, and an IPv4 if "assign_ipv4": true. If "public-by-port" is specified, the IP address assignment logic is the same as with "public". However, at least one port must be specified. Only packets sent to specified ports will be routed to the container. If "private", the container won't have any accessible public IPs, however it will be able to access the internet.
+ *
+ */
+declare enum ContainerNetworkMode {
+    PUBLIC = "public",
+    PUBLIC_BY_PORT = "public-by-port",
+    PRIVATE = "private"
+}
+
+type NetworkParameters = {
+    /**
+     * Assign an IPv4 address to the deployment. One of 'none' (default), 'predefined' (allocate one from a set of IPv4 addresses in the global pool), 'account' (allocate one from a set of IPv4 addresses preassigned in the account pool). Only applicable to "public" mode.
+     *
+     */
+    assign_ipv4?: AssignIPv4;
+    /**
+     * Assign an IPv6 address to the deployment. One of 'predefined' (allocate one from a set of IPv6 addresses in the global pool), 'account' (allocate one from a set of IPv6 addresses preassigned in the account pool). The container will always be assigned to an IPv6 if the networking mode is "public".
+     *
+     */
+    assign_ipv6?: AssignIPv6;
+    mode?: ContainerNetworkMode;
+};
+
+/**
+ * Settings for observability such as logging.
+ */
+type Observability = {
+    logs?: ObservabilityLogs;
+};
+
+type PortRange = {
+    /**
+     * First port number. Inclusive.
+     */
+    start: number;
+    /**
+     * Last port number. Inclusive. It may be equal to the start one.
+     */
+    end: number;
+};
+
+/**
+ * Represents a port assignment for a deployment
+ */
+type Port = {
+    /**
+     * A port name. The port array should not have duplicate names. The port name should be between 1 and 15 characters long. Only alphanumeric characters, dashes (-), and underscores (_) are allowed. No consecutive dashes. The value of the port is exposed to the user's application with a set of environment variables, where `<name>` below is the name of the port with dashes converted to underscores (example: "web-ui" becomes "web_ui"):
+     * - `CLOUDFLARE_PORT_<name>`: Port inside the container
+     * - `CLOUDFLARE_HOST_PORT_<name>`: Port outside the container
+     * - `CLOUDFLARE_HOST_IP_<name>`: Address of the external network interface the port is allocated on
+     * - `CLOUDFLARE_HOST_ADDR_<name>`: `CLOUDFLARE_HOST_IP_<name>:CLOUDFLARE_HOST_PORT_<name>`
+     *
+     */
+    name: string;
+    /**
+     * Optional port number, it's assigned only if the user specified it.
+     * If it's not specified, the datacenter scheduler will decide it.
+     *
+     */
+    port?: number;
+    /**
+     * Choose a port number from a given set of port ranges and use it. It is an optional field.
+     * If it is set, "port" must not be provided. The same port ranges may be used with multiple ports
+     * as long as the port ranges are identical for each port. Otherwise no two port ranges must intersect
+     * and no fixed port must belong to any port range. The total port count for all port ranges should
+     * be sufficiently large for assigning the requested number of ports.
+     *
+     */
+    assign_port?: Array<PortRange>;
+};
+
+/**
+ * Configuration for a VM provisioner.
+ */
+type ProvisionerConfiguration = {
+    /**
+     * The provisioner to use.
+     */
+    type: ProvisionerConfiguration.type;
+};
+declare namespace ProvisionerConfiguration {
+    /**
+     * The provisioner to use.
+     */
+    enum type {
+        NONE = "none",
+        CLOUDINIT = "cloudinit"
+    }
+}
+
+/**
+ * An SSH public key ID. One can map an ssh public key to a deployment using this ID.
+ */
+type SSHPublicKeyID = string;
+
+/**
+ * An SSH public key
+ */
+type SSHPublicKey = string;
+
+/**
+ * SSH public key provided by the user
+ */
+type UserSSHPublicKey = {
+    name?: string;
+    public_key: SSHPublicKey;
+};
+
+/**
+ * Configuration properties for SSH'ing into a container with Wrangler
+ */
+type WranglerSSHConfig = {
+    enabled: boolean;
+    port?: number;
+};
+
+/**
+ * Properties required to modify a cloudchamber deployment specified by the user.
+ */
+type ModifyUserDeploymentConfiguration = {
+    image?: Image;
+    wrangler_ssh?: WranglerSSHConfig;
+    authorized_keys?: Array<UserSSHPublicKey>;
+    trusted_user_ca_keys?: Array<UserSSHPublicKey>;
+    /**
+     * A list of SSH public key IDs from the account
+     */
+    ssh_public_key_ids?: Array<SSHPublicKeyID>;
+    /**
+     * A list of objects with secret names and the their access types from the account
+     */
+    secrets?: Array<DeploymentSecretMap>;
+    instance_type?: InstanceType;
+    /**
+     * Specify the vcpu to be used for the deployment. Vcpu must be at least 0.0625. The input value will be rounded to
+     * the nearest 0.0001. The default will be the one configured for the account.
+     *
+     */
+    vcpu?: number;
+    /**
+     * Deprecated in favor of memory_mib
+     * @deprecated
+     */
+    memory?: MemorySizeWithUnit;
+    /**
+     * Specify the memory to be used for the deployment, in MiB. The default will be the one configured for the account.
+     */
+    memory_mib?: number;
+    /**
+     * The disk configuration for this deployment
+     */
+    disk?: Disk;
+    /**
+     * Container environment variables
+     */
+    environment_variables?: Array<EnvironmentVariable>;
+    /**
+     * Deployment labels
+     */
+    labels?: Array<Label>;
+    network?: NetworkParameters;
+    command?: Command;
+    entrypoint?: Entrypoint;
+    dns?: DNSConfiguration;
+    ports?: Array<Port>;
+    /**
+     * Health and readiness checks for this deployment.
+     */
+    checks?: Array<DeploymentCheckRequestBody>;
+    provisioner?: ProvisionerConfiguration;
+    observability?: Observability;
+    experimental_flags?: Array<string>;
+};
+
+type ApplicationSchedulingHint = {
+    current: {
+        instances: number;
+        configuration: ModifyUserDeploymentConfiguration;
+        version: number;
+    };
+    target: {
+        instances: number;
+        configuration: ModifyUserDeploymentConfiguration;
+        version: number;
+    };
+};
+
+/**
+ * Set of properties to configure a durable object application in Cloudchamber
+ */
+type DurableObjectsConfiguration = {
+    /**
+     * The namespace ID of a durable object namespace. It's assigned when the user deploys for the first time
+     * a durable object namespace.
+     *
+     */
+    namespace_id: string;
+};
+
+/**
+ * UTC timestamp string in ISO 8601 format
+ */
+type ISO8601Timestamp = string;
+
+/**
+ * An identifier for a specific rollout within an application.
+ */
+type RolloutID = string;
+
+/**
+ * The scheduling policy to use for an application
+ */
+declare enum SchedulingPolicy {
+    DURABLE_OBJECT = "durable_object",
+    MOON = "moon",
+    GPU = "gpu",
+    REGIONAL = "regional",
+    FILL_METALS = "fill_metals",
+    DEFAULT = "default"
+}
+
+/**
+ * Properties required to create a cloudchamber deployment specified by the user
+ */
+type UserDeploymentConfiguration = {
+    image: Image;
+    wrangler_ssh?: WranglerSSHConfig;
+    authorized_keys?: Array<UserSSHPublicKey>;
+    trusted_user_ca_keys?: Array<UserSSHPublicKey>;
+    /**
+     * A list of SSH public key IDs from the account
+     */
+    ssh_public_key_ids?: Array<SSHPublicKeyID>;
+    /**
+     * A list of objects with secret names and the their access types from the account
+     */
+    secrets?: Array<DeploymentSecretMap>;
+    instance_type?: InstanceType;
+    /**
+     * Specify the vcpu to be used for the deployment. Vcpu must be at least 0.0625. The input value will be rounded to
+     * the nearest 0.0001. The default will be the one configured for the account.
+     *
+     */
+    vcpu?: number;
+    /**
+     * Deprecated in favor of memory_mib
+     * @deprecated
+     */
+    memory?: MemorySizeWithUnit;
+    /**
+     * Specify the memory to be used for the deployment, in MiB. The default will be the one configured for the account.
+     */
+    memory_mib?: number;
+    /**
+     * The disk configuration for this deployment
+     */
+    disk?: Disk;
+    /**
+     * Container environment variables
+     */
+    environment_variables?: Array<EnvironmentVariable>;
+    /**
+     * Deployment labels
+     */
+    labels?: Array<Label>;
+    network?: NetworkParameters;
+    command?: Command;
+    entrypoint?: Entrypoint;
+    dns?: DNSConfiguration;
+    ports?: Array<Port>;
+    /**
+     * Health and readiness checks for this deployment.
+     */
+    checks?: Array<DeploymentCheckRequestBody>;
+    provisioner?: ProvisionerConfiguration;
+    observability?: Observability;
+    experimental_flags?: Array<string>;
+};
+
+/**
+ * Describes multiple deployments with parameters that describe how they should be placed
+ */
+type Application = {
+    id: ApplicationID;
+    created_at: ISO8601Timestamp;
+    account_id: AccountID;
+    name: ApplicationName;
+    version: number;
+    scheduling_policy: SchedulingPolicy;
+    /**
+     * Number of deployments to create
+     */
+    instances: number;
+    /**
+     * Maximum number of instances that the application will allow. This is relevant for applications that auto-scale.
+     */
+    max_instances?: number;
+    configuration: UserDeploymentConfiguration;
+    observability?: ApplicationObservability;
+    constraints?: ApplicationConstraints;
+    jobs?: ApplicationJobsConfig;
+    affinities?: ApplicationAffinities;
+    priorities?: ApplicationPriorities;
+    durable_objects?: DurableObjectsConfiguration;
+    scheduling_hint?: ApplicationSchedulingHint;
+    active_rollout_id?: RolloutID;
+    rollout_active_grace_period?: ApplicationRolloutActiveGracePeriod;
+    health?: ApplicationHealth;
+};
+
+/**
+ * The disk configuration for this deployment (in MB).
+ */
+type DiskMB = {
+    size_mb: number;
+};
+
+/**
+ * Name of the event that describes the kind event that happened.
+ * - SchedulerPlaced: It's the first event that creates a Cloudchamber placement. It happens when the runtime was able to retrieve deployment resources and start verify everything is correct.
+ * - NetworkingIPAssigned: It's sent when the Cloudchamber runtime has mapped the IP to the container.
+ * - VMStarted: It's sent when the Cloudchamber runtime has started the VM. However, it does not mean that the container is healthy.
+ * - ImagePulled: It's sent when the Cloudchamber runtime has pulled the image successfully.
+ * - ImagePullError: It's sent when the Cloudchamber runtime is having issues pulling image. The message and details have more information on what happened for debugging.
+ * - VMFailedToStart: It's sent when the Cloudchamber runtime was unable to boot the VM.
+ * - VMStopping: It's sent when the scheduler is stopping the VM.
+ * - VMStopped: It's sent when the VM has finally exited.
+ * - VMFailed: It's sent when the scheduling of the VM failed in the current location.
+ * - RuntimeStartFailed: It's sent when the runtime had an internal error.
+ * - SSHStarted: It's sent when the container has gained network connectivity and has opened the SSH port. This event is only sent when SSH keys are configured.
+ * - CheckUpdate: Sent when the status of a health or readiness check changes. This may also affect the health status of the placement.
+ * - DurableObjectConnected: Sent when a durable object instance connects and gains control of the deployment.
+ * This event is only sent for durable object deployments. It is sent after VMStarted.
+ * - ContainerStarted: It's sent when the container has started running.
+ *
+ */
+declare enum EventName {
+    SCHEDULER_PLACED = "SchedulerPlaced",
+    NETWORKING_IPASSIGNED = "NetworkingIPAssigned",
+    VMSTARTED = "VMStarted",
+    IMAGE_PULLED = "ImagePulled",
+    IMAGE_PULL_ERROR = "ImagePullError",
+    VMFAILED_TO_START = "VMFailedToStart",
+    NETWORKING_IPASSIGNMENT_FAILED = "NetworkingIPAssignmentFailed",
+    VMRUNNING = "VMRunning",
+    VMSTOPPING = "VMStopping",
+    VMSTOPPED = "VMStopped",
+    VMFAILED = "VMFailed",
+    RUNTIME_START_FAILED = "RuntimeStartFailed",
+    SSHSTARTED = "SSHStarted",
+    SERVICE_HEALTH_UPDATES = "ServiceHealthUpdates",
+    CHECK_UPDATE = "CheckUpdate",
+    DURABLE_OBJECT_CONNECTED = "DurableObjectConnected",
+    CONTAINER_STARTED = "ContainerStarted"
+}
+
+declare enum EventType {
+    INFO = "Info",
+    ERROR = "Error",
+    WARN = "Warn",
+    USER_ERROR = "UserError",
+    SYSTEM_ERROR = "SystemError"
+}
+
+/**
+ * An event within a Placement or a Job
+ */
+type PlacementEvent = {
+    id: string;
+    time: ISO8601Timestamp;
+    type: EventType;
+    name: EventName;
+    message: string;
+    details: Record<string, any>;
+    statusChange: Record<string, any>;
+};
+
+/**
+ * All events within a Job
+ */
+type JobEvents = Array<PlacementEvent>;
+
+/**
+ * A Job ID represents an identifier of a specific job
+ */
+type JobID = string;
+
+/**
+ * Job status health represents the job's health. It can be in one of the following states
+ * Queued    - The job has been created and is waiting to be scheduled.
+ * Scheduled - The job has been scheduled on a designated compute instance.
+ * Placed    - The job has been placed on a compute node and its relevant resources like images, networking and bind mounts are being prepared.
+ * Running   - The job has started running the container with the given job configuration.
+ * Stopped   - The job has stopped running
+ *
+ */
+declare enum JobStatusHealth {
+    QUEUED = "Queued",
+    SCHEDULED = "Scheduled",
+    PLACED = "Placed",
+    RUNNING = "Running",
+    STOPPED = "Stopped"
+}
+
+type JobStatus = {
+    health: JobStatusHealth;
+} & Record<string, any>;
+
+/**
+ * The Job timeout in seconds
+ */
+type JobTimeoutSeconds = number;
+
+/**
+ * A secret name
+ */
+type SecretName = string;
+
+/**
+ * A secret map contains a secret name and the type which denotes how it is made available within a jobs container
+ */
+type SecretMap = {
+    name: SecretName;
+    type: SecretAccessType;
+};
+
+/**
+ * An application job is a short-lived instance of an application
+ */
+type ApplicationJob = {
+    id: JobID;
+    app_id: ApplicationID;
+    created_at: ISO8601Timestamp;
+    entrypoint: Entrypoint;
+    command: Command;
+    status: JobStatus;
+    events: JobEvents;
+    image: Image;
+    instance_type?: InstanceType;
+    /**
+     * Allocated vCPUs for this job
+     */
+    vcpu: number;
+    /**
+     * Allocated vCPUs for this job
+     */
+    vcpus: number;
+    /**
+     * Allocated memory for this job
+     */
+    memory_mb: number;
+    /**
+     * Deprecated in favor of memory_mib
+     * @deprecated
+     */
+    memory: MemorySizeWithUnit;
+    /**
+     * Specify the memory to be used for the deployment, in MiB. The default will be the one configured for the account.
+     */
+    memory_mib?: number;
+    /**
+     * The disk configuration for this job expressed in string
+     */
+    disk?: Disk;
+    /**
+     * The disk configuration for this job, expressed as a number (in MB)
+     */
+    disk_mb?: DiskMB;
+    /**
+     * Job specific environment variables
+     */
+    environment_variables: Array<EnvironmentVariable>;
+    /**
+     * Job specific secrets mapping
+     */
+    secrets: Array<SecretMap>;
+    timeout: JobTimeoutSeconds;
+    /**
+     * The job's termination request status. This will be "false" by default. If the user requests a job termination, this will be set to true.
+     */
+    terminate: boolean;
+};
+
+/**
+ * Error enums that can be returned when there has been an error with mutating the applications resource
+ */
+declare enum ApplicationMutationError {
+    IMAGE_REGISTRY_RETURNED_ERROR = "IMAGE_REGISTRY_RETURNED_ERROR",
+    IMAGE_REGISTRY_DOESNT_CONTAIN_IMAGE = "IMAGE_REGISTRY_DOESNT_CONTAIN_IMAGE",
+    VALIDATE_INPUT = "VALIDATE_INPUT",
+    SURPASSED_BASE_LIMITS = "SURPASSED_BASE_LIMITS",
+    SURPASSED_TOTAL_LIMITS = "SURPASSED_TOTAL_LIMITS",
+    LOCATION_NOT_ALLOWED = "LOCATION_NOT_ALLOWED",
+    LOCATION_SURPASSED_BASE_LIMITS = "LOCATION_SURPASSED_BASE_LIMITS",
+    IMAGE_REGISTRY_NOT_CONFIGURED = "IMAGE_REGISTRY_NOT_CONFIGURED",
+    JOB_CREATE_NOT_ALLOWED = "JOB_CREATE_NOT_ALLOWED",
+    DURABLE_OBJECT_NOT_FOUND = "DURABLE_OBJECT_NOT_FOUND",
+    DURABLE_OBJECT_NOT_CONTAINER_ENABLED = "DURABLE_OBJECT_NOT_CONTAINER_ENABLED",
+    DURABLE_OBJECT_ALREADY_HAS_APPLICATION = "DURABLE_OBJECT_ALREADY_HAS_APPLICATION"
+}
+
+type ApplicationNotFoundError = {
+    error: string;
+};
+
+/**
+ * Progress details of an application rollout.
+ */
+type ApplicationRolloutProgress = {
+    /**
+     * Total number of steps in the rollout.
+     */
+    total_steps: number;
+    /**
+     * Current step being executed in the rollout process. Initialized to 0.
+     */
+    current_step: number;
+    /**
+     * Number of instances updated in the rollout process.
+     */
+    updated_instances: number;
+    /**
+     * Total number of instances affected by the rollout.
+     */
+    total_instances: number;
+};
+
+/**
+ * Steps within the rollout process.
+ */
+type RolloutStep = {
+    /**
+     * The sequential order of the rollout step, automatically assigned starting from 1, based on the total number of steps in the rollout process.
+     */
+    id: number;
+    step_size: {
+        /**
+         * Percentage of instances affected in this step. Min 10% and Max 100%.
+         */
+        percentage: number;
+    };
+    /**
+     * Description of the rollout step.
+     */
+    description: string;
+    /**
+     * Status of the rollout step.
+     */
+    status: RolloutStep.status;
+    /**
+     * Reason why the step has the current status
+     */
+    reason?: string;
+    started_at?: ISO8601Timestamp;
+    completed_at?: ISO8601Timestamp;
+};
+declare namespace RolloutStep {
+    /**
+     * Status of the rollout step.
+     */
+    enum status {
+        PENDING = "pending",
+        PROGRESSING = "progressing",
+        REVERTING = "reverting",
+        COMPLETED = "completed",
+        REVERTED = "reverted"
+    }
+}
+
+/**
+ * Represents the status and metadata of a rollout process for an application.
+ */
+type ApplicationRollout = {
+    description: string;
+    id: RolloutID;
+    created_at: ISO8601Timestamp;
+    /**
+     * Timestamp of the most recent update to status, health, or progress
+     */
+    last_updated_at: ISO8601Timestamp;
+    /**
+     * Kind of the rollout process.
+     * - "full_auto": The default rollout mode, which starts progressing the steps upon rollout creation.
+     * - "full_manual": Requires manually progressing each step in the rollout using the UpdateRollout's action paramater.
+     * - "durable_objects_auto": Default when the application is a DO application.
+     *
+     */
+    kind: ApplicationRollout.kind;
+    /**
+     * The rollout strategy
+     */
+    strategy: ApplicationRollout.strategy;
+    /**
+     * Current application version before the rollout.
+     */
+    current_version: number;
+    /**
+     * Target application version after the rollout is complete and applied to all current instances.
+     */
+    target_version: number;
+    current_configuration: ModifyUserDeploymentConfiguration;
+    target_configuration: ModifyUserDeploymentConfiguration;
+    /**
+     * Current status of the rollout.
+     */
+    status: ApplicationRollout.status;
+    health: ApplicationHealth;
+    steps: Array<RolloutStep>;
+    progress: ApplicationRolloutProgress;
+    /**
+     * Timestamp when the rollout started.
+     */
+    started_at?: string;
+};
+declare namespace ApplicationRollout {
+    /**
+     * Kind of the rollout process.
+     * - "full_auto": The default rollout mode, which starts progressing the steps upon rollout creation.
+     * - "full_manual": Requires manually progressing each step in the rollout using the UpdateRollout's action paramater.
+     * - "durable_objects_auto": Default when the application is a DO application.
+     *
+     */
+    enum kind {
+        FULL_AUTO = "full_auto",
+        FULL_MANUAL = "full_manual",
+        DURABLE_OBJECTS_AUTO = "durable_objects_auto"
+    }
+    /**
+     * The rollout strategy
+     */
+    enum strategy {
+        ROLLING = "rolling"
+    }
+    /**
+     * Current status of the rollout.
+     */
+    enum status {
+        PENDING = "pending",
+        PROGRESSING = "progressing",
+        COMPLETED = "completed",
+        REVERTED = "reverted",
+        REPLACED = "replaced"
+    }
+}
+
+/**
+ * An application status shows information about the application's scheduling status, job queue and other metadata.
+ */
+type ApplicationStatus = {
+    scheduler: Record<string, any>;
+    /**
+     * Job queue status
+     */
+    jobs: Record<string, any>;
+};
+
+type BadRequestError = {
+    error: string;
+};
+
+type BadRequestWithCodeError = {
+    /**
+     * If VALIDATE_INPUT, you should see the inputs that were wrong in the details object.
+     */
+    error: BadRequestWithCodeError.error;
+    /**
+     * Details that might be filled depending on the error code.
+     */
+    details?: Record<string, any>;
+};
+declare namespace BadRequestWithCodeError {
+    /**
+     * If VALIDATE_INPUT, you should see the inputs that were wrong in the details object.
+     */
+    enum error {
+        VALIDATE_INPUT = "VALIDATE_INPUT"
+    }
+}
+
+/**
+ * Represents a complete location object used for setting limits to users and seeing the list of available locations in Coordinator
+ */
+type Location = {
+    /**
+     * Location name that will be showcased to the user when they see which locations can they schedule on
+     */
+    name: string;
+    region: Region;
+    location: LocationID;
+};
+
+/**
+ * Represents an account location with a limit property for customers.
+ */
+type CompleteAccountLocationCustomer = AccountLocationLimitsAsProperty & AccountLocation & Location;
+
+/**
+ * An identifier for clients that has an associated account in Cloudchamber. This usually represents a customer identity
+ */
+type Identity = string;
+
+/**
+ * Represents a Cloudchamber account object with limits, locations and its defaults. It's the view for the customer.
+ */
+type CompleteAccountCustomer = {
+    external_account_id: AccountID;
+    legacy_identity: Identity;
+    limits: AccountLimit;
+    locations: Array<CompleteAccountLocationCustomer>;
+    defaults: AccountDefaults;
+};
+
+declare enum ContainerImagePreparationStatus {
+    PENDING = "pending",
+    READY = "ready",
+    ERROR = "error"
+}
+
+type ContainerImagePreparation = {
+    image: string;
+    status: ContainerImagePreparationStatus;
+    artifact_digest?: string;
+    reason?: string;
+};
+
+type CreateApplicationBadRequest = {
+    error: ApplicationMutationError;
+    /**
+     * Details that might be filled depending on the error code.
+     */
+    details?: Record<string, any>;
+};
+
+type CreateApplicationJobBadRequest = {
+    error: ApplicationMutationError;
+    /**
+     * Details that might be filled depending on the error code.
+     */
+    details?: Record<string, any>;
+};
+
+/**
+ * The secret value that is in plain text. Used only when creating a new secret.
+ */
+type PlainTextSecretValue = string;
+
+/**
+ * A job secret map contains a secret name, the plain-text secret itself and the type which denotes how it is made available within a container. This is used in an application job when creating jobs. Their lifetime is the same as the job itself, unlike an account level secret.
+ */
+type JobSecretMap = {
+    name: SecretName;
+    value: PlainTextSecretValue;
+    type: SecretAccessType;
+};
+
+/**
+ * Create a new application Job request body
+ */
+type CreateApplicationJobRequest = {
+    entrypoint: Entrypoint;
+    command: Command;
+    image?: Image;
+    timeout?: JobTimeoutSeconds;
+    instance_type?: InstanceType;
+    /**
+     * Allocate vCPUs for this job. Vcpu must be at least 0.0625. The input value will be rounded to the nearest 0.0001. It
+     * defaults to the application configuration's vCPUs setting, and if that is not specified, it uses the account defaults.
+     *
+     */
+    vcpus?: number;
+    /**
+     * Allocate vCPUs for this job. Vcpu must be at least 0.0625. The input value will be rounded to the nearest 0.0001. It
+     * defaults to the application configuration's "vCPU" setting, and if that is not specified, it uses the account defaults.
+     *
+     */
+    vcpu?: number;
+    /**
+     * Deprecated in favor of memory_mib
+     * @deprecated
+     */
+    memory?: MemorySizeWithUnit;
+    /**
+     * Amount of memory to allocate for this job, in MiB. It defaults to the application configuration's memory setting,
+     * and if that is not specified, it uses the account defaults.
+     *
+     */
+    memory_mib?: number;
+    /**
+     * Set job specific environment vars. If an env var already exists in the application configuration it would be overriden.
+     */
+    environment_variables?: Array<EnvironmentVariable>;
+    /**
+     * Set job specific secrets.
+     */
+    secrets?: Array<JobSecretMap>;
+};
+
+/**
+ * Create a new application object for dynamic scheduling
+ */
+type CreateApplicationRequest = {
+    /**
+     * The name for this application
+     */
+    name: string;
+    scheduling_policy: SchedulingPolicy;
+    /**
+     * Number of deployments to create
+     */
+    instances: number;
+    /**
+     * Maximum number of instances that the application will allow. This is relevant for applications that auto-scale.
+     */
+    max_instances?: number;
+    constraints?: ApplicationConstraints;
+    /**
+     * The deployment configuration of all deployments created by this application.
+     *
+     */
+    configuration: UserDeploymentConfiguration;
+    observability?: ApplicationObservability;
+    jobs?: ApplicationJobsConfig;
+    /**
+     * If set, it will make the container application back a durable object namespace.
+     */
+    durable_objects?: DurableObjectsConfiguration;
+    affinities?: ApplicationAffinities;
+    priorities?: ApplicationPriorities;
+    rollout_active_grace_period?: ApplicationRolloutActiveGracePeriod;
+};
+
+/**
+ * Steps defining the rollout process.
+ */
+type RolloutStepRequest = {
+    step_size: {
+        /**
+         * Percentage of instances affected in this step. Min 10% and Max 100%.
+         */
+        percentage: number;
+    };
+    /**
+     * Description of the rollout step.
+     */
+    description: string;
+};
+
+/**
+ * Request body to create a new rollout for an application.
+ */
+type CreateApplicationRolloutRequest = {
+    target_configuration: ModifyUserDeploymentConfiguration;
+    /**
+     * Strategy used for the rollout. Currently supports only "rolling".
+     */
+    strategy: CreateApplicationRolloutRequest.strategy;
+    /**
+     * Percentage of rollout to increase in each step when "steps" is not specificed. Applicable values are 5, 10, 20, 25, 50, 100.
+     * These create rollouts with 20, 10, 5, 4, 2, 1 steps respectively.
+     *
+     */
+    step_percentage?: CreateApplicationRolloutRequest.step_percentage;
+    /**
+     * Steps defining the rollout process, when "step_percentage" is not defined.
+     * Only one of "step_percentage" or "steps" can be defined when creating a rollout.
+     * "steps" allow granular control over each step.
+     *
+     */
+    steps?: Array<RolloutStepRequest>;
+    /**
+     * Description of the rollout process.
+     */
+    description: string;
+    /**
+     * Kind of the rollout process.
+     * - "full_auto": The default rollout mode, which starts progressing the steps upon rollout creation.
+     * - "full_manual": Requires manually progressing each step in the rollout using the UpdateRollout's action paramater.
+     *
+     */
+    kind?: CreateApplicationRolloutRequest.kind;
+};
+declare namespace CreateApplicationRolloutRequest {
+    /**
+     * Strategy used for the rollout. Currently supports only "rolling".
+     */
+    enum strategy {
+        ROLLING = "rolling"
+    }
+    /**
+     * Percentage of rollout to increase in each step when "steps" is not specificed. Applicable values are 5, 10, 20, 25, 50, 100.
+     * These create rollouts with 20, 10, 5, 4, 2, 1 steps respectively.
+     *
+     */
+    enum step_percentage {
+        "_5" = 5,
+        "_10" = 10,
+        "_20" = 20,
+        "_25" = 25,
+        "_50" = 50,
+        "_100" = 100
+    }
+    /**
+     * Kind of the rollout process.
+     * - "full_auto": The default rollout mode, which starts progressing the steps upon rollout creation.
+     * - "full_manual": Requires manually progressing each step in the rollout using the UpdateRollout's action paramater.
+     *
+     */
+    enum kind {
+        FULL_AUTO = "full_auto",
+        FULL_MANUAL = "full_manual"
+    }
+}
+
+/**
+ * Create a namespace-backed application whose instances are owned by Durable Objects.
+ */
+type CreateDurableObjectApplicationRequest = {
+    /**
+     * The name for this application.
+     */
+    name: string;
+    scheduling_policy: SchedulingPolicy.DURABLE_OBJECT;
+    /**
+     * The customer-owned Durable Object namespace that owns this application and its instances.
+     */
+    durable_objects: DurableObjectsConfiguration;
+};
+
+/**
+ * Error enums that can be returned when there has been an error with mutating the deployments resource
+ */
+declare enum DeploymentMutationError {
+    VALIDATE_INPUT = "VALIDATE_INPUT",
+    SURPASSED_BASE_LIMITS = "SURPASSED_BASE_LIMITS",
+    SURPASSED_TOTAL_LIMITS = "SURPASSED_TOTAL_LIMITS",
+    LOCATION_NOT_ALLOWED = "LOCATION_NOT_ALLOWED",
+    LOCATION_SURPASSED_BASE_LIMITS = "LOCATION_SURPASSED_BASE_LIMITS",
+    IMAGE_REGISTRY_NOT_CONFIGURED = "IMAGE_REGISTRY_NOT_CONFIGURED"
+}
+
+type CreateDeploymentBadRequest = {
+    error: DeploymentMutationError;
+    /**
+     * Details that might be filled depending on the error code.
+     */
+    details?: Record<string, any>;
+};
+
+/**
+ * Configuration specified by the scheduler or user to create a deployment
+ */
+type SchedulerDeploymentConfiguration = {
+    location: LocationID;
+};
+
+/**
+ * Request body for creating a new deployment
+ */
+type CreateDeploymentV2RequestBody = UserDeploymentConfiguration & SchedulerDeploymentConfiguration;
+
+/**
+ * The type of external registry that is being configured.
+ */
+declare enum ExternalRegistryKind {
+    ECR = "ECR",
+    DOCKER_HUB = "DockerHub",
+    GAR = "GAR"
+}
+
+/**
+ * A reference to a secret stored in Secrets Store
+ */
+type SecretsStoreRef = {
+    /**
+     * Store ID where the secret is stored
+     */
+    store_id: string;
+    /**
+     * Name of the secret being referenced
+     */
+    secret_name: string;
+};
+
+/**
+ * Credentials needed to authenticate with an external image registry.
+ */
+type ImageRegistryAuth = {
+    /**
+     * The format of this value is determined by the registry being configured.
+     */
+    public_credential: string;
+    private_credential: string | SecretsStoreRef;
+};
+
+/**
+ * Request body for creating a new image registry configuration
+ */
+type CreateImageRegistryRequestBody = {
+    domain: Domain;
+    /**
+     * If you own the registry and is private, this should be false or not defined. If it's a public registry like docker.io, you should set this to true
+     */
+    is_public?: boolean;
+    auth?: ImageRegistryAuth;
+    kind?: ExternalRegistryKind;
+};
+
+type CreateSSHPublicKeyError = {
+    error: string;
+    request_id: string;
+};
+
+/**
+ * Request body for adding a new SSH public key
+ */
+type CreateSSHPublicKeyRequestBody = {
+    name: string;
+    public_key: SSHPublicKey;
+};
+
+declare enum DefaultImageRegistryKind {
+    DEFAULT = "default"
+}
+
+/**
+ * An image registry added in a customer account
+ */
+type CustomerImageRegistry = {
+    /**
+     * A base64 representation of the public key that you can set to configure the registry. If null, the registry is public and doesn't have authentication setup with Cloudchamber
+     */
+    public_key?: string;
+    private_credential?: SecretsStoreRef;
+    domain: Domain;
+    /**
+     * The type of registry that is being configured.
+     */
+    kind?: ExternalRegistryKind | DefaultImageRegistryKind;
+    created_at: ISO8601Timestamp;
+};
+
+/**
+ * Summary representation of a container application, returned by the Dash endpoint.
+ * Contains only the fields needed for list display, not the full configuration.
+ */
+type DashApplication = {
+    id: ApplicationID;
+    created_at: ISO8601Timestamp;
+    updated_at: ISO8601Timestamp;
+    name: ApplicationName;
+    version: number;
+    instances: number;
+    image: Image;
+    health: ApplicationHealth;
+};
+
+type DashApplicationDurableObjectInstance = {
+    id: string;
+    deployment_id?: string;
+    placement_id?: string;
+    assigned_at: string;
+    name?: string;
+};
+
+/**
+ * The type of deployment that determines how the deployment executes.
+ *
+ * - "default": Means that the deployment is long-running and will always maintain
+ * a single placement (aka container) running at the same time.
+ * It's the classic and default definition of a deployment in Cloudchamber.
+ * - "jobs": Means that the deployment will subscribe itself to a durable object control plane
+ * that receives jobs to run. It will prewarm a deployment in a metal to receive jobs
+ * and run them immediately.
+ * - "durable_object": Means that the deployment will back a single durable object instance.
+ * It's similar to jobs in the sense that the user decides when the container starts and ends.
+ *
+ * The default is long-running deployments with "default".
+ *
+ */
+declare enum DeploymentType {
+    DEFAULT = "default",
+    JOBS = "jobs",
+    DURABLE_OBJECT = "durable_object"
+}
+
+/**
+ * A monotonic version associated with a specific deployment. The version starts at 0 and increase by 1 every time a change is made.
+ */
+type DeploymentVersion = number;
+
+/**
+ * Represents the durable object status of a Placement. If empty, should be assumed that it's disconnected.
+ * - connected: The Placement is connected to a durable object.
+ * - disconnected: The Placement got disconnected from a durable object.
+ *
+ */
+declare enum DurableObjectStatusHealth {
+    CONNECTED = "connected",
+    DISCONNECTED = "disconnected"
+}
+
+/**
+ * Represents the 'status' of a Placement.
+ * - placed: The Placement has been created on a node.
+ * - stopping: The Placement is stopping.
+ * - running: The Placement is running.
+ * - failed: The Placement failed to run.
+ * - stopped: The Placement stopped.
+ * - unhealthy: The Placement has a failing healthcheck.
+ *
+ */
+declare enum PlacementStatusHealth {
+    PLACED = "placed",
+    STOPPING = "stopping",
+    RUNNING = "running",
+    FAILED = "failed",
+    STOPPED = "stopped",
+    UNHEALTHY = "unhealthy"
+}
+
+type PlacementStatus = {
+    /**
+     * Whether the deployment is healthy based on the configured health checks. If no health checks are configured for this deployment, this field is omitted from the response.
+     */
+    health: PlacementStatusHealth;
+    /**
+     * Whether the deployment is ready based on the configured readiness checks. If no readiness checks are configured for this deployment, this field has the same value as "healthy".
+     */
+    ready?: boolean;
+    /**
+     * The container runtime status. Preferred over `health` when deriving
+     * the displayed state in the Dash.
+     */
+    container_status?: string;
+    /**
+     * The status of the placement in relationship to a durable object.
+     * This only applies when the backing application is configured
+     * to connect with a durable object namespace.
+     *
+     */
+    durable_object?: DurableObjectStatusHealth;
+} & Record<string, any>;
+
+/**
+ * A Placement represents the lifetime of a single instance of a Deployment. Whereas a Deployment represents your intent to run one or many containers, a Placement represents these containers actually running. Every time you create or update a Deployment, a new Placement is created.
+ */
+type Placement = {
+    id: PlacementID;
+    created_at: ISO8601Timestamp;
+    deployment_id: DeploymentID;
+    deployment_version: DeploymentVersion;
+    terminate: boolean;
+    status: PlacementStatus;
+    last_update?: ISO8601Timestamp;
+    /**
+     * Set if it backed or is currently backing a durable object actor.
+     */
+    durable_object_actor_id?: string;
+};
+
+type DashApplicationInstance = {
+    id: string;
+    created_at: string;
+    current_placement?: Placement;
+    type?: DeploymentType;
+    location: string;
+    region?: string;
+    app_version: number;
+    name?: string;
+    image?: string;
+};
+
+type DashApplicationInstances = {
+    instances: DashApplicationInstance[];
+    durable_objects?: DashApplicationDurableObjectInstance[];
+};
+
+type DeleteDeploymentError = {
+    error: string;
+    request_id: string;
+};
+
+/**
+ * Response body after deleting an image registry.
+ */
+type DeleteImageRegistryResponse = {
+    domain: string;
+    secrets_store_ref?: string;
+};
+
+type DeploymentAlreadyExists = {
+    error: string;
+};
+
+/**
+ * Options for HTTP checks.
+ */
+type DeploymentCheckHTTP = {
+    method: HTTPMethod;
+    /**
+     * If the method is one of POST, PATCH or PUT, this is required. It's the body that will be passed to the HTTP healthcheck request.
+     */
+    body: string;
+    /**
+     * Path that will be used to perform the healthcheck.
+     */
+    path: string;
+    /**
+     * HTTP headers to include in the request.
+     */
+    headers: Record<string, any>;
+};
+
+type DeploymentCheck = DeploymentCheckRequestBody & {
+    /**
+     * Name of the check
+     */
+    name: string;
+    /**
+     * Options for HTTP checks. Only valid when "type" is "http"
+     */
+    http?: DeploymentCheckHTTP;
+    /**
+     * Connect to the port using TLS
+     */
+    tls: boolean;
+    /**
+     * Number of times to attempt the check before considering it to have failed
+     */
+    attempts_before_failure: number;
+};
+
+type DeploymentCreationError = {
+    error: string;
+    request_id: string;
+};
+
+type DeploymentListError = {
+    error: string;
+    request_id: string;
+};
+
+/**
+ * Represents some rich information about a location including it's enabled status
+ */
+type DeploymentLocation = {
+    name: LocationID;
+    /**
+     * Shows if the location is enabled to run deployments
+     */
+    enabled: boolean;
+    /**
+     * Shows the region of the location
+     */
+    region?: Region;
+};
+
+type DeploymentModificationError = {
+    error: string;
+    request_id: string;
+};
+
+/**
+ * Response when the deployment that is backing the resource is not found.
+ *
+ */
+type DeploymentNotFoundError = {
+    error: DeploymentNotFoundError.error;
+};
+declare namespace DeploymentNotFoundError {
+    enum error {
+        DEPLOYMENT_NOT_FOUND = "DEPLOYMENT_NOT_FOUND"
+    }
+}
+
+/**
+ * State of the deployment's current placement
+ */
+declare enum DeploymentPlacementState {
+    RUNNING = "running",
+    STOPPED = "stopped",
+    STARTING = "starting",
+    STOPPING = "stopping"
+}
+
+/**
+ * A reason on why the deployment cannot be placed
+ */
+declare enum DeploymentQueuedReason {
+    UNKNOWN = "unknown",
+    LOCATION_OVERPROVISIONED = "location_overprovisioned"
+}
+
+/**
+ * Details on each property that might make the deployment stuck in the queue
+ */
+type DeploymentQueuedDetails = {
+    gpu?: DeploymentQueuedReason;
+    cpu?: DeploymentQueuedReason;
+    memory?: DeploymentQueuedReason;
+    disk?: DeploymentQueuedReason;
+    unknown?: DeploymentQueuedReason;
+};
+
+type DeploymentReplacementError = {
+    error: string;
+    request_id: string;
+};
+
+/**
+ * Current scheduling state of the deployment
+ */
+declare enum DeploymentSchedulingState {
+    SCHEDULED = "scheduled",
+    PLACED = "placed"
+}
+
+type DeploymentState = {
+    current: DeploymentSchedulingState;
+    last_updated: ISO8601Timestamp;
+    queued_details?: DeploymentQueuedDetails;
+};
+
+/**
+ * IPv4 address assigned to this deployment
+ */
+type IPV4 = string;
+
+/**
+ * Network properties
+ */
+type Network = {
+    mode: ContainerNetworkMode;
+    ipv4?: IPV4;
+    ipv6?: string;
+};
+
+/**
+ * A link to the API endpoint providing full details about a specific object
+ */
+type Ref = string;
+
+/**
+ * A Deployment represents an intent to run one or many containers, with the same image, in a particular location or region.
+ */
+type DeploymentV2 = {
+    id: DeploymentID;
+    app_id?: ApplicationID;
+    app_version?: number;
+    created_at: ISO8601Timestamp;
+    account_id: AccountID;
+    version: DeploymentVersion;
+    type: DeploymentType;
+    image: Image;
+    location: DeploymentLocation;
+    wrangler_ssh?: WranglerSSHConfig;
+    authorized_keys?: Array<UserSSHPublicKey>;
+    /**
+     * A list of SSH public key IDs from the account
+     */
+    ssh_public_key_ids?: Array<SSHPublicKeyID>;
+    /**
+     * A list of objects with secret names and the their access types from the account
+     */
+    secrets?: Array<DeploymentSecretMap>;
+    /**
+     * Container environment variables
+     */
+    environment_variables?: Array<EnvironmentVariable>;
+    /**
+     * Deployment labels
+     */
+    labels?: Array<Label>;
+    current_placement?: Placement;
+    placements_ref: Ref;
+    instance_type?: InstanceType;
+    /**
+     * The vcpu of this deployment
+     */
+    vcpu: number;
+    /**
+     * Deprecated in favor of memory_mib
+     * @deprecated
+     */
+    memory: MemorySizeWithUnit;
+    /**
+     * The memory of this deployment, in MiB
+     */
+    memory_mib: number;
+    /**
+     * The node group of this deployment
+     */
+    node_group: NodeGroup;
+    /**
+     * The disk configuration for this deployment
+     */
+    disk?: Disk;
+    network: Network;
+    /**
+     * Deprecated in favor of gpu_memory_mib
+     * @deprecated
+     */
+    gpu_memory?: MemorySizeWithUnit;
+    /**
+     * The GPU memory of this deployment, in MiB. If deployment is not node_group 'gpu', this will be null
+     */
+    gpu_memory_mib?: number;
+    command?: Command;
+    entrypoint?: Entrypoint;
+    dns?: DNSConfiguration;
+    /**
+     * Health and readiness checks for this deployment.
+     */
+    checks?: Array<DeploymentCheck>;
+    state?: DeploymentState;
+    observability?: Observability;
+};
+
+/**
+ * An empty response body
+ */
+type EmptyResponse = Record<string, any>;
+
+/**
+ * Generic error details that might be filled depending on the error code.
+ */
+type GenericErrorDetails = Record<string, any>;
+
+type GenericErrorResponseWithRequestID = {
+    error: string;
+    request_id: string;
+};
+
+/**
+ * Generic response with a message field. Can be used to convey the result of an operation like deleting a resource.
+ */
+type GenericMessageResponse = {
+    message: string;
+};
+
+type GetDeploymentError = {
+    error: string;
+    request_id: string;
+};
+
+type GetPlacementError = {
+    error: string;
+    request_id: string;
+};
+
+/**
+ * The image registry already exists
+ */
+type ImageRegistryAlreadyExistsError = {
+    /**
+     * The domain of the registry already exists
+     */
+    error: ImageRegistryAlreadyExistsError.error;
+    /**
+     * Details that might be filled depending on the error code.
+     */
+    details?: Record<string, any>;
+};
+declare namespace ImageRegistryAlreadyExistsError {
+    /**
+     * The domain of the registry already exists
+     */
+    enum error {
+        IMAGE_REGISTRY_ALREADY_EXISTS = "IMAGE_REGISTRY_ALREADY_EXISTS"
+    }
+}
+
+declare enum ImageRegistryPermissions {
+    PULL = "pull",
+    PUSH = "push",
+    LIBRARY_PUSH = "library_push"
+}
+
+/**
+ * Configuration to create credentials to access an image registry
+ */
+type ImageRegistryCredentialsConfiguration = {
+    permissions: Array<ImageRegistryPermissions>;
+    expiration_minutes: number;
+};
+
+/**
+ * The image registry is configured to be public, so it does not have a public key
+ */
+type ImageRegistryIsPublic = {
+    error: ImageRegistryIsPublic.error;
+};
+declare namespace ImageRegistryIsPublic {
+    enum error {
+        IMAGE_REGISTRY_IS_PUBLIC = "IMAGE_REGISTRY_IS_PUBLIC"
+    }
+}
+
+/**
+ * The registry is not allowed to be modified
+ */
+type ImageRegistryNotAllowedError = {
+    /**
+     * The domain of the registry is not allowed to be modified
+     */
+    error: ImageRegistryNotAllowedError.error;
+    /**
+     * Details that might be filled depending on the error code.
+     */
+    details?: Record<string, any>;
+};
+declare namespace ImageRegistryNotAllowedError {
+    /**
+     * The domain of the registry is not allowed to be modified
+     */
+    enum error {
+        IMAGE_REGISTRY_NOT_ALLOWED = "IMAGE_REGISTRY_NOT_ALLOWED"
+    }
+}
+
+/**
+ * The image registry does not exist
+ */
+type ImageRegistryNotFoundError = {
+    error: ImageRegistryNotFoundError.error;
+};
+declare namespace ImageRegistryNotFoundError {
+    enum error {
+        IMAGE_REGISTRY_NOT_FOUND = "IMAGE_REGISTRY_NOT_FOUND"
+    }
+}
+
+/**
+ * The domain and path that the proto is going to resolve to when the Cloudchamber runtime tries to pull from it.
+ */
+type ImageRegistryProtoDomain = {
+    domain: Domain;
+    path: string;
+};
+
+/**
+ * An image registry protocol (`<proto>://<uri>`) is a concept useful so you can refer to multiple registries within the same image ref.
+ * In case you have multiple registries that are storing the same image, it will be highly available to Cloudchamber as it has multiple sources to pull from.
+ * For example, you might push your image to a registry in "my-registry.com/images/hello:1.0", and to Cloudchamber's registry
+ * "registry.cloudchamber.cfdata.org/hello:1.0".
+ * You could call this proto "cf", and it would resolve to both my-registry.com/images and registry.cloudchamber.cfdata.org.
+ * When you create a deployment/app with the format "cf://hello:1.0", the runtime will try to pull from "my-registry.com/images/hello:1.0"
+ * or "registry.cloudchamber.cfdata.org/hello:1.0", depending on availability. If one pull fails it will fallback to the next target.
+ * This is also useful to migrate to another registry progressively.
+ *
+ */
+type ImageRegistryProtocol = {
+    proto: string;
+    domains: Array<ImageRegistryProtoDomain>;
+};
+
+type ImageRegistryProtocolAlreadyExists = {
+    error: ImageRegistryProtocolAlreadyExists.error;
+};
+declare namespace ImageRegistryProtocolAlreadyExists {
+    enum error {
+        IMAGE_REGISTRY_PROTOCOL_ALREADY_EXISTS = "IMAGE_REGISTRY_PROTOCOL_ALREADY_EXISTS"
+    }
+}
+
+/**
+ * Returned when deleting an image registry protocol and it is referenced by a resource.
+ */
+type ImageRegistryProtocolIsReferencedError = {
+    error: ImageRegistryProtocolIsReferencedError.error;
+};
+declare namespace ImageRegistryProtocolIsReferencedError {
+    enum error {
+        IMAGE_REGISTRY_PROTO_IS_REFERENCED = "IMAGE_REGISTRY_PROTO_IS_REFERENCED"
+    }
+}
+
+/**
+ * The image registry protocol does not exist
+ */
+type ImageRegistryProtocolNotFound = {
+    error: ImageRegistryProtocolNotFound.error;
+};
+declare namespace ImageRegistryProtocolNotFound {
+    enum error {
+        IMAGE_REGISTRY_PROTOCOL_NOT_FOUND = "IMAGE_REGISTRY_PROTOCOL_NOT_FOUND"
+    }
+}
+
+type ImageRegistryProtocols = Array<ImageRegistryProtocol>;
+
+/**
+ * An internal error. Usually happens when Coordinator fails to perform some action with the database
+ */
+type InternalError = {
+    error: string;
+    request_id: string;
+};
+
+/**
+ * Configuration of an IP.
+ */
+type IPAllocationConfiguration = {
+    /**
+     * Will be filled when a created deployment is assigned to this IP.
+     */
+    deploymentId?: DeploymentID;
+    /**
+     * Will be filled when Cloudchamber assigns this IP to a specific account pool.
+     */
+    accountId?: AccountID;
+};
+
+/**
+ * An IP type is an enum that can be v4 or v6
+ */
+declare enum IPType {
+    V4 = "v4",
+    V6 = "v6"
+}
+
+/**
+ * Representation of a port range mapping in the Cloudchamber API.
+ * No two port range for the same IP address can overlap.
+ *
+ */
+type PortRangeAllocation = {
+    /**
+     * Starting port number of the port range. Inclusive
+     */
+    start: number;
+    /**
+     * Ending port number of the port range. Inclusive.
+     */
+    end: number;
+    allocation?: AddressAssignment;
+};
+
+/**
+ * Representation of an IP mapping in the Cloudchamber API. Contains all the necessary information to see if this IP belongs to a deployment or account IP pool, and if it's allocated.
+ */
+type IPAllocation = {
+    /**
+     * If not assigned to a deployment, or not belonging to a pool, will be undefined.
+     */
+    configuration?: IPAllocationConfiguration;
+    /**
+     * If not allocated, this will be undefined.
+     */
+    allocation?: AddressAssignment;
+    /**
+     * the subnet mask that this IP belongs to
+     */
+    subnetMask: number;
+    ip: IP;
+    ipType?: IPType;
+    portRanges?: Array<PortRangeAllocation>;
+};
+
+/**
+ * List of IPs with the filters that matched them
+ */
+type IPAllocationsWithFilter = {
+    ips: Array<IPAllocation>;
+    filters: Record<string, any>;
+};
+
+type JobNotFoundError = {
+    error: string;
+};
+
+/**
+ * A list of application objects
+ */
+type ListApplications = Array<Application>;
+
+/**
+ * List of deployments
+ */
+type ListDeploymentsV2 = Array<DeploymentV2>;
+
+/**
+ * Filter out ips that are not allocated
+ */
+type ListIPsIsAllocated = boolean;
+
+/**
+ * All events within a Placement
+ */
+type PlacementEvents = Array<PlacementEvent>;
+
+/**
+ * A Placement represents the lifetime of a single instance of a Deployment. This represents a specific placement along with its events.
+ */
+type PlacementWithEvents = {
+    id: PlacementID;
+    created_at: ISO8601Timestamp;
+    deployment_id: DeploymentID;
+    deployment_version: DeploymentVersion;
+    terminate: boolean;
+    status: PlacementStatus;
+    events: PlacementEvents;
+    last_update?: ISO8601Timestamp;
+    /**
+     * Set if it backed or is currently backing a durable object actor.
+     */
+    durable_object_actor_id?: string;
+};
+
+/**
+ * A list of placements along with its events under a deployment
+ */
+type ListPlacements = Array<PlacementWithEvents>;
+
+type ListPlacementsError = {
+    error: string;
+    request_id: string;
+};
+
+/**
+ * A secret item with its name and other metadata.
+ */
+type SecretMetadata = {
+    name: string;
+    version: number;
+    created_at: ISO8601Timestamp;
+    updated_at: ISO8601Timestamp;
+};
+
+/**
+ * A list of secret metdata.
+ */
+type ListSecretsMetadata = Array<SecretMetadata>;
+
+/**
+ * An SSH public key ID and the actual key itself. Useful when listing SSH public keys on an account.
+ */
+type SSHPublicKeyItem = {
+    id: SSHPublicKeyID;
+    name: string;
+    public_key?: SSHPublicKey;
+};
+
+/**
+ * List all SSH public keys in the account
+ */
+type ListSSHPublicKeys = Array<SSHPublicKeyItem>;
+
+type ListSSHPublicKeysError = {
+    error: string;
+    request_id: string;
+};
+
+type ModifyApplicationBadRequest = {
+    error: ApplicationMutationError;
+    /**
+     * Details that might be filled depending on the error code.
+     */
+    details?: Record<string, any>;
+};
+
+type ModifyApplicationJobBadRequest = {
+    error: ApplicationMutationError;
+    /**
+     * Details that might be filled depending on the error code.
+     */
+    details?: Record<string, any>;
+};
+
+/**
+ * Modify application job request body
+ */
+type ModifyApplicationJobRequest = {
+    terminate?: boolean;
+};
+
+/**
+ * Request body for modifying an application
+ */
+type ModifyApplicationRequestBody = {
+    /**
+     * The name for this application
+     */
+    name?: string;
+    /**
+     * Number of deployments to maintain within this applicaiton. This can be used to scale the appliation up/down.
+     */
+    instances?: number;
+    /**
+     * Maximum number of instances that the application will allow. This is relevant for applications that auto-scale.
+     * It will reduce the number of running instances if there are more than `max_instances`.
+     *
+     */
+    max_instances?: number;
+    affinities?: ApplicationAffinities;
+    priorities?: ApplicationPriorities;
+    scheduling_policy?: SchedulingPolicy;
+    constraints?: ApplicationConstraints;
+    rollout_active_grace_period?: ApplicationRolloutActiveGracePeriod;
+    observability?: ApplicationObservability;
+    /**
+     * The deployment configuration of all deployments created by this application.
+     * Right now, if you modify the application configuration, only new deployments
+     * created will have the new configuration. You can delete old deployments to
+     * release new instances.
+     *
+     */
+    configuration?: ModifyUserDeploymentConfiguration;
+};
+
+type ModifyDeploymentBadRequest = {
+    error: DeploymentMutationError;
+    /**
+     * Details that might be filled depending on the error code.
+     */
+    details?: Record<string, any>;
+};
+
+/**
+ * Request body modifying an existing deployment
+ */
+type ModifyDeploymentV2RequestBody = {
+    /**
+     * The new image that the deployment will have from now on
+     */
+    image?: string;
+    /**
+     * The new location that the deployment will have from now on
+     */
+    location?: string;
+    /**
+     * A list of SSH public key IDs from the account
+     */
+    ssh_public_key_ids?: Array<SSHPublicKeyID>;
+    /**
+     * A list of objects with secret names and the their access types from the account
+     */
+    secrets?: Array<DeploymentSecretMap>;
+    instance_type?: InstanceType;
+    /**
+     * The new vcpu that the deployment will have from now on
+     */
+    vcpu?: number;
+    /**
+     * Deprecated in favor of memory_mib
+     * @deprecated
+     */
+    memory?: MemorySizeWithUnit;
+    /**
+     * The new memory that the deployment will have from now on
+     */
+    memory_mib?: number;
+    /**
+     * The disk configuration for this deployment
+     */
+    disk?: Disk;
+    /**
+     * Container environment variables
+     */
+    environment_variables?: Array<EnvironmentVariable>;
+    /**
+     * Deployment labels
+     */
+    labels?: Array<Label>;
+    command?: Command;
+    entrypoint?: Entrypoint;
+    dns?: DNSConfiguration;
+    /**
+     * Health and readiness checks for this deployment.
+     */
+    checks?: Array<DeploymentCheckRequestBody>;
+    observability?: Observability;
+};
+
+/**
+ * Request body for modifying account defaults
+ */
+type ModifyMeRequestBody = {
+    defaults?: {
+        /**
+         * Deprecated in favor of memory_mib
+         * @deprecated
+         */
+        memory?: MemorySizeWithUnit;
+        memory_mib?: number;
+        vcpus?: number;
+        disk_mb?: number;
+    };
+};
+
+/**
+ * Request body for modifying an existing secret
+ */
+type ModifySecretRequestBody = {
+    value: PlainTextSecretValue;
+};
+
+type PlacementNotFoundError = {
+    error: string;
+};
+
+type PrepareContainerImageRequestBody = {
+    image: string;
+};
+
+/**
+ * Request body replacing an existing deployment
+ */
+type ReplaceDeploymentRequestBody = {
+    replace: boolean;
+};
+
+/**
+ * An object representing a secret with a name and value. Used when a user creates a new secret.
+ */
+type Secret = {
+    name: string;
+    value: PlainTextSecretValue;
+};
+
+/**
+ * The secret name already exists
+ */
+type SecretNameAlreadyExists = {
+    /**
+     * The secret name already exists in this account
+     */
+    error: SecretNameAlreadyExists.error;
+    details?: GenericErrorDetails;
+};
+declare namespace SecretNameAlreadyExists {
+    /**
+     * The secret name already exists in this account
+     */
+    enum error {
+        SECRET_NAME_ALREADY_EXISTS = "SECRET_NAME_ALREADY_EXISTS"
+    }
+}
+
+/**
+ * The secret name does not exist
+ */
+type SecretNotFound = {
+    error: SecretNotFound.error;
+};
+declare namespace SecretNotFound {
+    enum error {
+        SECRET_NAME_NOT_FOUND = "SECRET_NAME_NOT_FOUND"
+    }
+}
+
+/**
+ * The ssh public key does not exist
+ */
+type SSHPublicKeyNotFoundError = {
+    error: SSHPublicKeyNotFoundError.error;
+};
+declare namespace SSHPublicKeyNotFoundError {
+    enum error {
+        SSH_PUBLIC_KEY_NOT_FOUND = "SSH_PUBLIC_KEY_NOT_FOUND"
+    }
+}
+
+type UnAuthorizedError = {
+    error: string;
+};
+
+type UnknownAccount = {
+    error: string;
+};
+
+/**
+ * Request body to update a rollout within an application.
+ */
+type UpdateApplicationRolloutRequest = {
+    /**
+     * Action to perform on the rollout.
+     * - next: The rollout will go forward one step. It will succeed if the current step is finished.
+     * - previous: The rollout will go back one step.
+     * - revert: The rollout goes back to the first step in one go.
+     *
+     */
+    action: UpdateApplicationRolloutRequest.action;
+};
+declare namespace UpdateApplicationRolloutRequest {
+    /**
+     * Action to perform on the rollout.
+     * - next: The rollout will go forward one step. It will succeed if the current step is finished.
+     * - previous: The rollout will go back one step.
+     * - revert: The rollout goes back to the first step in one go.
+     *
+     */
+    enum action {
+        NEXT = "next",
+        PREVIOUS = "previous",
+        REVERT = "revert"
+    }
+}
+
+/**
+ * Response body when updating a rollout with a specific action.
+ */
+type UpdateRolloutResponse = {
+    /**
+     * Denotes whether the rollout action was successful
+     */
+    success: boolean;
+    /**
+     * Details of the rollout action. Includes the reason if this rollout action is not successful.
+     */
+    message: string;
+    rollout: ApplicationRollout;
+};
+
+type WranglerSSHResponse = {
+    url: string;
+    token: string;
+};
+
+declare class AccountService {
+    /**
+     * Get complete account details related to Cloudchamber
+     * Get complete account details related to Cloudchamber, like limits and available locations
+     * @returns CompleteAccountCustomer Complete account for the user
+     * @throws ApiError
+     */
+    static getMe(): CancelablePromise<CompleteAccountCustomer>;
+    /**
+     * Modify account details like defaults
+     * Modify account details like defaults
+     * @param requestBody
+     * @returns CompleteAccountCustomer Complete account for the user
+     * @throws ApiError
+     */
+    static modifyMe(requestBody: ModifyMeRequestBody): CancelablePromise<CompleteAccountCustomer>;
+}
+
+declare class ApplicationsService {
+    /**
+     * Create a new application
+     * Create a new application. An Application represents an intent to run one or more containers, with the same image, dynamically scheduled based on constraints
+     * @param requestBody
+     * @returns Application A newly created application
+     * @throws ApiError
+     */
+    static createApplication(requestBody: CreateApplicationRequest | CreateDurableObjectApplicationRequest): CancelablePromise<Application>;
+    /**
+     * List Applications associated with your account
+     * Lists all the applications that are associated with your account
+     * @param name Filter applications by name
+     * @param image Filter applications by image
+     * @param label Filter applications by label
+     * @returns ListApplications Get all application associated with your account
+     * @throws ApiError
+     */
+    static listApplications(name?: ApplicationName, image?: Image, label?: Array<string>): CancelablePromise<ListApplications>;
+    /**
+     * Get a single application by id
+     * Returns a single application by id
+     * @param applicationId
+     * @returns Application A single application
+     * @throws ApiError
+     */
+    static getApplication(applicationId: ApplicationID): CancelablePromise<Application>;
+    /**
+     * Modify an application
+     * Modifies a single application by id.
+     * @param applicationId
+     * @param requestBody
+     * @returns Application Modify application response
+     * @throws ApiError
+     */
+    static modifyApplication(applicationId: ApplicationID, requestBody: ModifyApplicationRequestBody): CancelablePromise<Application>;
+    /**
+     * Delete a single application by id
+     * Deletes a single application by id
+     * @param applicationId
+     * @returns EmptyResponse Delete application response
+     * @throws ApiError
+     */
+    static deleteApplication(applicationId: ApplicationID): CancelablePromise<EmptyResponse>;
+    /**
+     * Application queue status
+     * Get an application's queue status. Only works under an application with type jobs.
+     * @param applicationId
+     * @returns ApplicationStatus Application status with details about the job queue, instances and other metadata for introspection.
+     * @throws ApiError
+     */
+    static getApplicationStatus(applicationId: ApplicationID): CancelablePromise<ApplicationStatus>;
+    /**
+     * Create a new job within an application
+     * Returns the created job
+     * @param applicationId
+     * @param requestBody
+     * @returns ApplicationJob A single job within an application
+     * @throws ApiError
+     */
+    static createApplicationJob(applicationId: ApplicationID, requestBody: CreateApplicationJobRequest): CancelablePromise<ApplicationJob>;
+    /**
+     * Get an application job by application and job id
+     * Returns a single application job by id with its current status
+     * @param applicationId
+     * @param jobId
+     * @returns ApplicationJob A single application
+     * @throws ApiError
+     */
+    static getApplicationJob(applicationId: ApplicationID, jobId: JobID): CancelablePromise<ApplicationJob>;
+    /**
+     * Delete an application job by application and job id
+     * Cleans up the specific job from the Application and all its assoicated resources
+     * @param applicationId
+     * @param jobId
+     * @returns GenericMessageResponse Generic OK response
+     * @throws ApiError
+     */
+    static deleteApplicationJob(applicationId: ApplicationID, jobId: JobID): CancelablePromise<GenericMessageResponse>;
+    /**
+     * Modify an existing application job
+     * Modify an application job state
+     * @param applicationId
+     * @param jobId
+     * @param requestBody
+     * @returns ApplicationJob A modified job within an application
+     * @throws ApiError
+     */
+    static modifyApplicationJob(applicationId: ApplicationID, jobId: JobID, requestBody: ModifyApplicationJobRequest): CancelablePromise<ApplicationJob>;
+    /**
+     * Create a new rollout for an application
+     * A rollout can be used to update the application's configuration across instances with minimal downtime.
+     * @param applicationId
+     * @param requestBody
+     * @returns ApplicationRollout
+     * @throws ApiError
+     */
+    static createApplicationRollout(applicationId: ApplicationID, requestBody: CreateApplicationRolloutRequest): CancelablePromise<ApplicationRollout>;
+    /**
+     * List rollouts
+     * List all rollouts within an application
+     * @param applicationId
+     * @param limit The amount of rollouts to return. By default it is all of them.
+     * @param last The last rollout that was used to paginate
+     * @returns ApplicationRollout
+     * @throws ApiError
+     */
+    static listApplicationRollouts(applicationId: ApplicationID, limit?: number, last?: string): CancelablePromise<Array<ApplicationRollout>>;
+    /**
+     * Get a rollout by id within an application
+     * View rollout configurations and state for a specific rollout
+     * @param applicationId
+     * @param rolloutId
+     * @returns ApplicationRollout
+     * @throws ApiError
+     */
+    static getApplicationRollout(applicationId: ApplicationID, rolloutId: RolloutID): CancelablePromise<ApplicationRollout>;
+    /**
+     * Update a rollout within an application
+     * A rollout can be updated to modify its current state. Actions include - next, previous, rollback
+     * @param applicationId
+     * @param rolloutId
+     * @param requestBody
+     * @returns UpdateRolloutResponse
+     * @throws ApiError
+     */
+    static updateApplicationRollout(applicationId: ApplicationID, rolloutId: RolloutID, requestBody: UpdateApplicationRolloutRequest): CancelablePromise<UpdateRolloutResponse>;
+    /**
+     * Delete a rollout within an application by its rollout id
+     * Cleans up the specific rollout from the Application if it is not in use
+     * @param applicationId
+     * @param rolloutId
+     * @returns EmptyResponse
+     * @throws ApiError
+     */
+    static deleteApplicationRollout(applicationId: ApplicationID, rolloutId: RolloutID): CancelablePromise<EmptyResponse>;
+    /**
+     * Get a single applications deployments
+     * Returns a single applications deployments
+     * @param applicationId
+     * @returns ListDeploymentsV2 List of deployments with their corresponding placements
+     * @throws ApiError
+     */
+    static listDeploymentsByApplication(applicationId: ApplicationID): CancelablePromise<ListDeploymentsV2>;
+    /**
+     * Get a specific deployment within an application
+     * Get a deployment by its app and deployment IDs
+     * @param applicationId
+     * @param deploymentId
+     * @returns DeploymentV2 Get a specific deployment along with its respective placements
+     * @throws ApiError
+     */
+    static getApplicationsV3Deployment(applicationId: ApplicationID, deploymentId: DeploymentID): CancelablePromise<DeploymentV2>;
+    /**
+     * Recreate an existing deployment within an application.
+     * The given existing deployment is deleted and a replacement deployment is created. The latter retains some properties of the former that cannot be set by the client.
+     *
+     * @param applicationId
+     * @param deploymentId
+     * @param requestBody
+     * @returns DeploymentV2 Deployment created
+     * @throws ApiError
+     */
+    static recreateDeploymentV3(applicationId: ApplicationID, deploymentId: DeploymentID, requestBody: ModifyUserDeploymentConfiguration): CancelablePromise<DeploymentV2>;
+    /**
+     * List container applications with pagination (Dash endpoint)
+     * Returns summary application data suitable for list display
+     * @param perPage Number of results per page
+     * @param pageToken Token for fetching the next page
+     * @returns PaginatedResult<DashApplication[]> Paginated list of applications
+     * @throws ApiError
+     */
+    static listDashApplications(perPage?: number, pageToken?: string): CancelablePromise<PaginatedResult<DashApplication[]>>;
+    /**
+     * List container instances for a given application
+     * Returns instances and optional durable object instances with pagination support
+     * @param applicationId
+     * @param perPage Number of results per page
+     * @param pageToken Token for fetching the next page
+     * @returns PaginatedResult<DashApplicationInstances> Paginated list of instances
+     * @throws ApiError
+     */
+    static listDashApplicationInstances(applicationId: ApplicationID, perPage?: number, pageToken?: string): CancelablePromise<PaginatedResult<DashApplicationInstances>>;
+}
+
+declare class ContainerImagePreparationsService {
+    /**
+     * Prepare a digest-pinned managed image for the Containers runtime.
+     */
+    static prepareContainerImage(requestBody: PrepareContainerImageRequestBody): CancelablePromise<ContainerImagePreparation>;
+}
+
+declare class DeploymentsService {
+    /**
+     * Get a specific deployment within an application
+     * Get a deployment by its app and deployment IDs
+     * @param applicationId
+     * @param deploymentId
+     * @returns DeploymentV2 Get a specific deployment along with its respective placements
+     * @throws ApiError
+     */
+    static getApplicationsV3Deployment(applicationId: ApplicationID, deploymentId: DeploymentID): CancelablePromise<DeploymentV2>;
+    /**
+     * Recreate an existing deployment within an application.
+     * The given existing deployment is deleted and a replacement deployment is created. The latter retains some properties of the former that cannot be set by the client.
+     *
+     * @param applicationId
+     * @param deploymentId
+     * @param requestBody
+     * @returns DeploymentV2 Deployment created
+     * @throws ApiError
+     */
+    static recreateDeploymentV3(applicationId: ApplicationID, deploymentId: DeploymentID, requestBody: ModifyUserDeploymentConfiguration): CancelablePromise<DeploymentV2>;
+    /**
+     * Get credentials to SSH into a Container
+     * Get a JWT to hit the SSH port on a given container.
+     * @param instanceId
+     * @returns WranglerSSHResponse Credentials to SSH into a Container
+     * @throws ApiError
+     */
+    static containerWranglerSsh(instanceId: DeploymentID): CancelablePromise<WranglerSSHResponse>;
+    /**
+     * Create a new deployment
+     * Creates a new deployment. A Deployment represents an intent to run one container, with image, in a particular location
+     * @param requestBody
+     * @returns DeploymentV2 Deployment created
+     * @throws ApiError
+     */
+    static createDeploymentV2(requestBody: CreateDeploymentV2RequestBody): CancelablePromise<DeploymentV2>;
+    /**
+     * List deployments
+     * List all deployments in the current account. Optionally filter them
+     * @param appId Filter deployments by application id
+     * @param location Filter deployments by location
+     * @param image Filter deployments by image
+     * @param state Filter deployments by placement state
+     * @param ipv4 Filter deployments by ipv4 address
+     * @param label Filter deployments by label
+     * @returns ListDeploymentsV2 List of deployments with their corresponding placements
+     * @throws ApiError
+     */
+    static listDeploymentsV2(appId?: ApplicationID, location?: LocationID, image?: Image, state?: DeploymentPlacementState, ipv4?: IPV4, label?: Array<string>): CancelablePromise<ListDeploymentsV2>;
+    /**
+     * Get a specific deployment
+     * Get a deployment by its deployment
+     * @param deploymentId
+     * @returns DeploymentV2 Get a specific deployment along with its respective placements
+     * @throws ApiError
+     */
+    static getDeploymentV2(deploymentId: DeploymentID): CancelablePromise<DeploymentV2>;
+    /**
+     * Modify an existing deployment
+     * Change specific properties in an existing deployment
+     * @param deploymentId
+     * @param requestBody
+     * @returns DeploymentV2 Deployment modified
+     * @throws ApiError
+     */
+    static modifyDeploymentV2(deploymentId: DeploymentID, requestBody: ModifyDeploymentV2RequestBody): CancelablePromise<DeploymentV2>;
+    /**
+     * Delete a specific deployment
+     * Delete a deployment by its deployment ID
+     * @param deploymentId
+     * @returns EmptyResponse Delete a specific deployment along with its respective placements
+     * @throws ApiError
+     */
+    static deleteDeploymentV2(deploymentId: DeploymentID): CancelablePromise<EmptyResponse>;
+    /**
+     * Recreate an existing deployment.
+     * The given existing deployment is deleted and a replacement deployment is created. The latter retains some properties of the former that cannot be set by the client.
+     *
+     * @param deploymentId
+     * @param requestBody
+     * @returns DeploymentV2 Deployment created
+     * @throws ApiError
+     */
+    static recreateDeployment(deploymentId: DeploymentID, requestBody: CreateDeploymentV2RequestBody): CancelablePromise<DeploymentV2>;
+    /**
+     * Replace a deployment
+     * You can stop the current placement and create a new one. The new one will have the same durable properties of the deployment, but will otherwise be like new
+     * @param placementId
+     * @param requestBody
+     * @returns DeploymentV2 Deployment replaced
+     * @throws ApiError
+     */
+    static replaceDeployment(placementId: PlacementID, requestBody: ReplaceDeploymentRequestBody): CancelablePromise<DeploymentV2>;
+}
+
+declare class ImageRegistriesService {
+    /**
+     * Create an image registry protocol that resolves to multiple domains.
+     * @param requestBody
+     * @returns ImageRegistryProtocol The image registry protocol was created
+     * @throws ApiError
+     */
+    static createImageRegistryProtocol(requestBody: ImageRegistryProtocol): CancelablePromise<ImageRegistryProtocol>;
+    /**
+     * List all image registry protocols.
+     * @returns ImageRegistryProtocols The image registry protocols in the account
+     * @throws ApiError
+     */
+    static listImageRegistryProtocols(): CancelablePromise<ImageRegistryProtocols>;
+    /**
+     * Modify an image registry protocol. The previous list of domains will be replaced by the ones you specify in this endpoint.
+     * @param requestBody
+     * @returns ImageRegistryProtocol The image registry protocol was modified
+     * @throws ApiError
+     */
+    static modifyImageRegistryProtocol(requestBody: ImageRegistryProtocol): CancelablePromise<ImageRegistryProtocol>;
+    /**
+     * Delete an image registry protocol. Be careful, if there is deployments running referencing this protocol they won't be able to pull the image.
+     * @param proto
+     * @returns EmptyResponse Image registry protocol was deleted successfully
+     * @throws ApiError
+     */
+    static deleteImageRegistryProto(proto: string): CancelablePromise<EmptyResponse>;
+    /**
+     * Get a JWT to pull from the image registry
+     * Get a JWT to pull from the image registry specifying its domain
+     * @param domain
+     * @param requestBody
+     * @returns AccountRegistryToken Credentials with 'pull' or 'push' permissions to access the registry
+     * @throws ApiError
+     */
+    static generateImageRegistryCredentials(domain: string, requestBody: ImageRegistryCredentialsConfiguration): CancelablePromise<AccountRegistryToken>;
+    /**
+     * Delete a registry from the account
+     * Delete a registry from the account, this will make Cloudchamber unable to pull images from the registry
+     * @param domain
+     * @returns EmptyResponse The image registry is deleted
+     * @throws ApiError
+     */
+    static deleteImageRegistry(domain: string): CancelablePromise<DeleteImageRegistryResponse>;
+    /**
+     * Get the list of configured registries in the account
+     * Get the list of configured registries in the account
+     * @returns CustomerImageRegistry The list of registries that are added in the account
+     * @throws ApiError
+     */
+    static listImageRegistries(): CancelablePromise<Array<CustomerImageRegistry>>;
+    /**
+     * Add a new image registry configuration
+     * Add a new image registry into your account, so then Cloudflare can pull docker images with public key JWT authentication
+     * @param requestBody
+     * @returns CustomerImageRegistry Created a new image registry in the account
+     * @throws ApiError
+     */
+    static createImageRegistry(requestBody: CreateImageRegistryRequestBody): CancelablePromise<CustomerImageRegistry>;
+}
+
+declare class IPsService {
+    /**
+     * List IPs
+     * List IPs
+     * @param placementId Filter out ips that are not assigned to the specified placement, can also be known as 'alloc_id' in Nomad.
+     * @param allocated Filter out ips that are not allocated
+     * @param ipType Filter out ips by type
+     * @param deploymentId Filter out by deployment ID
+     * @returns IPAllocationsWithFilter Result of listing IPs
+     * @throws ApiError
+     */
+    static listIPs(placementId?: PlacementID, allocated?: ListIPsIsAllocated, ipType?: IPType, deploymentId?: DeploymentID): CancelablePromise<IPAllocationsWithFilter>;
+}
+
+declare class JobsService {
+    /**
+     * Application queue status
+     * Get an application's queue status. Only works under an application with type jobs.
+     * @param applicationId
+     * @returns ApplicationStatus Application status with details about the job queue, instances and other metadata for introspection.
+     * @throws ApiError
+     */
+    static getApplicationStatus(applicationId: ApplicationID): CancelablePromise<ApplicationStatus>;
+    /**
+     * Create a new job within an application
+     * Returns the created job
+     * @param applicationId
+     * @param requestBody
+     * @returns ApplicationJob A single job within an application
+     * @throws ApiError
+     */
+    static createApplicationJob(applicationId: ApplicationID, requestBody: CreateApplicationJobRequest): CancelablePromise<ApplicationJob>;
+    /**
+     * Get an application job by application and job id
+     * Returns a single application job by id with its current status
+     * @param applicationId
+     * @param jobId
+     * @returns ApplicationJob A single application
+     * @throws ApiError
+     */
+    static getApplicationJob(applicationId: ApplicationID, jobId: JobID): CancelablePromise<ApplicationJob>;
+    /**
+     * Delete an application job by application and job id
+     * Cleans up the specific job from the Application and all its assoicated resources
+     * @param applicationId
+     * @param jobId
+     * @returns GenericMessageResponse Generic OK response
+     * @throws ApiError
+     */
+    static deleteApplicationJob(applicationId: ApplicationID, jobId: JobID): CancelablePromise<GenericMessageResponse>;
+    /**
+     * Modify an existing application job
+     * Modify an application job state
+     * @param applicationId
+     * @param jobId
+     * @param requestBody
+     * @returns ApplicationJob A modified job within an application
+     * @throws ApiError
+     */
+    static modifyApplicationJob(applicationId: ApplicationID, jobId: JobID, requestBody: ModifyApplicationJobRequest): CancelablePromise<ApplicationJob>;
+}
+
+declare class PlacementsService {
+    /**
+     * List placements
+     * List all placements under a given deploymentID with all its events
+     * @param deploymentId
+     * @returns ListPlacements A list of placements along with its events under a deployment
+     * @throws ApiError
+     */
+    static listPlacements(deploymentId: DeploymentID): CancelablePromise<ListPlacements>;
+    /**
+     * Get placement
+     * A Placement represents the lifetime of a single instance of a Deployment
+     * @param placementId
+     * @returns PlacementWithEvents A specific placement along with its events
+     * @throws ApiError
+     */
+    static getPlacement(placementId: PlacementID): CancelablePromise<PlacementWithEvents>;
+    /**
+     * Replace a deployment
+     * You can stop the current placement and create a new one. The new one will have the same durable properties of the deployment, but will otherwise be like new
+     * @param placementId
+     * @param requestBody
+     * @returns DeploymentV2 Deployment replaced
+     * @throws ApiError
+     */
+    static replaceDeployment(placementId: PlacementID, requestBody: ReplaceDeploymentRequestBody): CancelablePromise<DeploymentV2>;
+}
+
+declare class RolloutsService {
+    /**
+     * Create a new rollout for an application
+     * A rollout can be used to update the application's configuration across instances with minimal downtime.
+     * @param applicationId
+     * @param requestBody
+     * @returns ApplicationRollout
+     * @throws ApiError
+     */
+    static createApplicationRollout(applicationId: ApplicationID, requestBody: CreateApplicationRolloutRequest): CancelablePromise<ApplicationRollout>;
+    /**
+     * List rollouts
+     * List all rollouts within an application
+     * @param applicationId
+     * @param limit The amount of rollouts to return. By default it is all of them.
+     * @param last The last rollout that was used to paginate
+     * @returns ApplicationRollout
+     * @throws ApiError
+     */
+    static listApplicationRollouts(applicationId: ApplicationID, limit?: number, last?: string): CancelablePromise<Array<ApplicationRollout>>;
+    /**
+     * Get a rollout by id within an application
+     * View rollout configurations and state for a specific rollout
+     * @param applicationId
+     * @param rolloutId
+     * @returns ApplicationRollout
+     * @throws ApiError
+     */
+    static getApplicationRollout(applicationId: ApplicationID, rolloutId: RolloutID): CancelablePromise<ApplicationRollout>;
+    /**
+     * Update a rollout within an application
+     * A rollout can be updated to modify its current state. Actions include - next, previous, rollback
+     * @param applicationId
+     * @param rolloutId
+     * @param requestBody
+     * @returns UpdateRolloutResponse
+     * @throws ApiError
+     */
+    static updateApplicationRollout(applicationId: ApplicationID, rolloutId: RolloutID, requestBody: UpdateApplicationRolloutRequest): CancelablePromise<UpdateRolloutResponse>;
+    /**
+     * Delete a rollout within an application by its rollout id
+     * Cleans up the specific rollout from the Application if it is not in use
+     * @param applicationId
+     * @param rolloutId
+     * @returns EmptyResponse
+     * @throws ApiError
+     */
+    static deleteApplicationRollout(applicationId: ApplicationID, rolloutId: RolloutID): CancelablePromise<EmptyResponse>;
+}
+
+declare class SecretsService {
+    /**
+     * Add a new secret to the account
+     * Add a new secret to the account that can be associated with an application/deployment.
+     * @param requestBody
+     * @returns SecretMetadata Secret created successfully
+     * @throws ApiError
+     */
+    static createSecret(requestBody: Secret): CancelablePromise<SecretMetadata>;
+    /**
+     * List Secrets
+     * List all secrets in an account with metadata
+     * @returns ListSecretsMetadata List Secrets response
+     * @throws ApiError
+     */
+    static listSecrets(): CancelablePromise<ListSecretsMetadata>;
+    /**
+     * Get secret metadata
+     * Get secret metadata by name
+     * @param secretName
+     * @returns SecretMetadata Get secret response
+     * @throws ApiError
+     */
+    static getSecret(secretName: string): CancelablePromise<SecretMetadata>;
+    /**
+     * Update an existing secret
+     * Update a secret within an account. This bumps its version field. Corresponding applications/deployments would get the updated secret in its next placement.
+     * @param secretName
+     * @param requestBody
+     * @returns SecretMetadata Modify Secrets response
+     * @throws ApiError
+     */
+    static modifySecret(secretName: string, requestBody: ModifySecretRequestBody): CancelablePromise<SecretMetadata>;
+    /**
+     * Delete an existing secret
+     * Delete a secret within an account.
+     * @param secretName
+     * @returns GenericMessageResponse Generic OK response
+     * @throws ApiError
+     */
+    static deleteSecret(secretName: string): CancelablePromise<GenericMessageResponse>;
+}
+
+declare class SshPublicKeysService {
+    /**
+     * Add SSH public key
+     * Adds a new ssh public key to an account. This can then be associated with a specific deployment during its creation or modification.
+     * @param requestBody
+     * @returns SSHPublicKeyItem SSH Public key added successfully
+     * @throws ApiError
+     */
+    static createSshPublicKey(requestBody: CreateSSHPublicKeyRequestBody): CancelablePromise<SSHPublicKeyItem>;
+    /**
+     * List SSH Public keys
+     * List all SSH Public keys in an account
+     * @returns ListSSHPublicKeys List SSH Public keys response
+     * @throws ApiError
+     */
+    static listSshPublicKeys(): CancelablePromise<ListSSHPublicKeys>;
+    /**
+     * Delete SSH public key from the account
+     * Delete an SSH public key from an account.
+     * @param sshPublicKeyName
+     * @returns EmptyResponse SSH Public key was removed successfully
+     * @throws ApiError
+     */
+    static deleteSshPublicKey(sshPublicKeyName: string): CancelablePromise<EmptyResponse>;
+}
+
+type DockerfileContainerConfig = Exclude<ContainerNormalizedConfig, ImageURIConfig>;
+type BuiltImage = {
+    localTag: string;
+    localTagCleaned?: boolean;
+};
+type BuiltContainerImage = BuiltImage & {
+    container: DockerfileContainerConfig;
+};
+declare function isDockerfileContainerConfig(container: ContainerNormalizedConfig): container is DockerfileContainerConfig;
+/**
+ * `{ remoteDigest: string }` implies the image was pushed to, or already exists in,
+ * the managed registry. Deployments should use this digest-pinned reference.
+ *
+ * `{ newTag: string }` implies the image was built locally without pushing.
+ */
+type ImageRef = {
+    remoteDigest: string;
+} | {
+    newTag: string;
+};
+type ContainerBuildCommandArgs = {
+    PATH: string;
+    tag: string;
+    pathToDocker?: string;
+    push: boolean;
+    platform?: string;
+};
+type ContainerPushCommandArgs = {
+    TAG: string;
+    pathToDocker?: string;
+};
+type StartedContainerBuild = Awaited<ReturnType<typeof dockerBuild>>;
+/**
+ * Builds a container image from the given container options.
+ *
+ * @param build - Container configuration including the Dockerfile path, build context, and image tag.
+ * @param pathToDocker - Path to the Docker CLI executable.
+ * @param verifyDockerIsRunning - When `true` (the default), verifies Docker is installed
+ *   and the daemon is running before building. Set to `false` when the caller has already
+ *   performed this check.
+ * @returns An object with an `abort` function and a `ready` promise.
+ */
+declare function startContainerBuild({ build, pathToDocker, verifyDockerIsRunning, }: {
+    build: BuildArgs;
+    pathToDocker: string;
+    verifyDockerIsRunning?: boolean;
+}): Promise<StartedContainerBuild>;
+/**
+ * Checks the remote manifest to see if there are changes, and only push if there are
+ */
+declare function pushImageIfChanged({ pathToDocker, sourceTag, targetTag, containerConfig, accountId, complianceConfig, cleanupSourceTag, }: {
+    pathToDocker: string;
+    sourceTag: string;
+    targetTag: string;
+    containerConfig?: DockerfileContainerConfig;
+    accountId?: string;
+    complianceConfig?: ComplianceConfig;
+    cleanupSourceTag?: boolean;
+}): Promise<ImageRef>;
+/**
+ * Builds an image from the container build command arguments and optionally
+ * pushes it to the Cloudflare managed registry.
+ *
+ * @param args - Parsed container build command arguments.
+ * @param complianceConfig - Compliance configuration used to select the managed registry.
+ * @returns A promise that resolves when the build and optional push complete.
+ */
+declare function buildCommand(args: ContainerBuildCommandArgs, complianceConfig?: ComplianceConfig): Promise<void>;
+declare function pushCommand(args: ContainerPushCommandArgs, accountId: string, complianceConfig?: ComplianceConfig): Promise<void>;
+/**
+ * Builds a Docker image and optionally pushes it to the Cloudflare managed
+ * registry.
+ *
+ * @param args - Build arguments including tag, Dockerfile path, build context, and platform.
+ * @param pathToDocker - Path to the Docker CLI executable.
+ * @param push - Whether to push the built image to the remote registry.
+ * @param containerConfig - Optional container configuration for limit validation.
+ * @param verifyDockerIsRunning - Whether to verify Docker before building.
+ * @param complianceConfig - Compliance configuration used to select the managed registry.
+ * @returns An {@link ImageRef} describing the built or pushed image.
+ */
+declare function buildAndMaybePush(args: BuildArgs, pathToDocker: string, push: boolean, containerConfig?: DockerfileContainerConfig, verifyDockerIsRunning?: boolean, complianceConfig?: ComplianceConfig): Promise<ImageRef>;
+/**
+ * Builds configured Dockerfile-based container images for deployment.
+ *
+ * @param containers - Normalized container configuration.
+ * @param pathToDocker - Path to the Docker CLI executable.
+ * @param verifyDockerIsRunning - Whether to verify Docker before building.
+ * @returns The built image metadata paired with each Dockerfile-based container.
+ */
+declare function buildContainerImages(containers: ContainerNormalizedConfig[], pathToDocker: string, verifyDockerIsRunning?: boolean): Promise<BuiltContainerImage[]>;
+/**
+ * Pushes a configured, already-built container image to the managed registry.
+ *
+ * @param builtImage - Built Dockerfile-based container image metadata.
+ * @param versionId - Version ID used to derive the pushed image tag.
+ * @param pathToDocker - Path to the Docker CLI executable.
+ * @param accountId - Account that owns the managed registry.
+ * @param complianceConfig - Compliance configuration used to select the managed registry.
+ * @returns An {@link ImageRef} describing the pushed image.
+ */
+declare function pushBuiltContainerImage(builtImage: BuiltContainerImage, versionId: string, pathToDocker: string, accountId: string, complianceConfig?: ComplianceConfig): Promise<ImageRef>;
+/**
+ * Removes local Docker image tags created during a build.
+ *
+ * @param builtImages - Built images to clean up.
+ * @param pathToDocker - Path to the Docker CLI executable.
+ */
+declare function cleanupBuiltImages<T extends BuiltImage>(builtImages: T[], pathToDocker: string): Promise<void>;
+declare function getContainerImageTag(containerConfig: DockerfileContainerConfig, imageTag: string): string;
+/**
+ * Spawns a Docker build process and returns a handle to abort or await the build.
+ *
+ * By default this function first verifies that the Docker daemon is reachable.
+ * Callers that have already performed this check (e.g. the dev and deploy flows)
+ * should pass `verifyDockerIsRunning: false` to avoid a redundant check.
+ *
+ * @param dockerPath - Path to the Docker CLI executable.
+ * @param options - Build options including the command arguments and Dockerfile content.
+ * @param options.buildCmd - The Docker build command arguments.
+ * @param options.dockerfile - The Dockerfile content to pipe into stdin.
+ * @param options.verifyDockerIsRunning - When `true` (the default), verifies Docker is installed
+ *   and the daemon is running before spawning the build. Set to `false` to skip the check.
+ *
+ * @returns An object with an `abort` function and a `ready` promise.
+ */
+declare function dockerBuild(dockerPath: string, options: {
+    buildCmd: string[];
+    dockerfile: string;
+    verifyDockerIsRunning?: boolean;
+}): Promise<{
+    abort: () => void;
+    ready: Promise<void>;
+}>;
+
+declare let logger: Logger;
+declare let fetchResult: FetchResultFetcher;
+declare let fetchPagedListResult: FetchPagedListResultFetcher;
+type ContainersSharedContext = {
+    logger: Logger;
+    fetchResult: FetchResultFetcher;
+    fetchPagedListResult?: FetchPagedListResultFetcher;
+};
+declare function initContainersSharedContext(ctx: ContainersSharedContext): void;
+
+type DeployContainersArgs = {
+    dispatchNamespace?: string;
+    versionId: string;
+    accountId: string;
+    scriptName: string;
+};
+type ObservabilityWriteTarget = "top-level" | "configuration";
+type ResolvedContainerDeployment = {
+    container: ContainerNormalizedConfig;
+    imageRef: ImageRef;
+};
+type DurableObjectNamespace = {
+    id: string;
+    class: string;
+    name: string;
+    script: string;
+    use_sqlite: boolean;
+    dispatch_namespace?: string;
+    /**
+     * Set when the namespace belongs to a Worker preview. For those, `script` is
+     * the parent Worker's name, so `preview.id` is what distinguishes a
+     * preview's namespace from the parent's and from other previews'.
+     */
+    preview?: {
+        id: string;
+        slug: string;
+        name: string;
+    };
+};
+declare function createDurableObjectNamespaceResolver(config: Config, { versionId, accountId, scriptName, dispatchNamespace }: DeployContainersArgs): (className: string) => Promise<string>;
+declare function deployContainers(config: Config, containerDeployments: ResolvedContainerDeployment[], { versionId, accountId, scriptName, dispatchNamespace }: DeployContainersArgs): Promise<void>;
+declare function listDurableObjects(complianceConfig: ComplianceConfig, accountId: string): Promise<DurableObjectNamespace[]>;
+declare function apply(args: {
+    imageRef: ImageRef;
+    durable_object_namespace_id: string;
+}, containerConfig: ContainerNormalizedConfig, config: Config, accountId: string): Promise<void>;
+declare function formatError(err: ApiError): string;
+/**
+ * clean up application object received from API so that we get a nicer diff when comparing it to the current config.
+ *
+ * @param prev - Previously deployed application returned by the API.
+ * @param currentConfig - Current normalized container configuration.
+ * @param accountId - Cloudflare account ID that owns managed-registry images.
+ * @param observabilityWriteTarget - API field used for observability updates.
+ * @param complianceConfig - Compliance configuration used to normalize managed-registry image references.
+ * @returns The cleaned application fields used to generate the deployment diff.
+ */
+declare function cleanApplicationFromAPI(prev: Application, currentConfig: ContainerNormalizedConfig, accountId: string, observabilityWriteTarget: ObservabilityWriteTarget, complianceConfig?: ComplianceConfig): Partial<ModifyApplicationRequestBody> & Pick<Application, "configuration">;
+declare const configRolloutStepsToAPI: (rolloutSteps: number | number[]) => {
+    step_percentage: number;
+    steps?: undefined;
+} | {
+    steps: RolloutStepRequest[];
+    step_percentage?: undefined;
+};
+
+/**
+ * @deprecated When trying to compute the difference between two json object use `diffJsonObjects` instead
+ *             (as it includes a more polished print representation and it also includes information regarding
+ *             the difference between the two objects)
+ *             (For diffing other values, such as TOMLs this class should still be used, hopefully we'll be
+ *              able to move away from TOML files at some point)
+ */
+declare class Diff {
+    #private;
+    get changes(): number;
+    constructor(a: string, b: string);
+    toString(options?: {
+        contextLines: number;
+    }): string;
+    print(options?: {
+        contextLines: number;
+    }): void;
+}
+
+declare function configureOpenAPIForContainerPull(accountId: string, apiToken: string, apiBase?: string): void;
+/**
+ * Gets push and pull credentials for a configured image registry
+ * and runs `docker login`, so subsequent image pushes or pulls are
+ * authenticated
+ */
+declare function dockerLoginImageRegistry(pathToDocker: string, domain: string): Promise<void>;
+
+declare function getCloudflareContainerRegistry(complianceConfig?: ComplianceConfig$1): string;
+/** Prefixes with the cloudflare-dev namespace. The name should be the container's DO classname, and the tag a build uuid. */
+declare const getDevContainerImageName: (name: string, tag: string) => string;
+/**
+ * Docker's FUSE requirements: expose the device, allow mounts through
+ * `SYS_ADMIN`, and disable the entire default AppArmor profile because it
+ * blocks FUSE mounts.
+ */
+declare const FUSE_CONTAINER_PRIVILEGES: {
+    capabilities: string[];
+    devices: {
+        pathOnHost: string;
+        pathInContainer: string;
+        cgroupPermissions: string;
+    }[];
+    securityOpt: string[];
+};
+
+declare function getInstanceTypeUsage(instanceType: InstanceType): {
+    vcpu: number;
+    memory_mib: number;
+    disk_mb: number;
+};
+declare function inferInstanceType(config: UserDeploymentConfiguration): InstanceType | undefined;
+/**
+ * Removes any disk, memory, or vCPU set in an object's configuration. Used by
+ * Cloudchamber apply to render diffs using the equivalent `instance_type`.
+ */
+declare function cleanForInstanceType(app: CreateApplicationRequest): ContainerApp;
+declare function ensureContainerLimits(options: {
+    pathToDocker: string;
+    imageTag: string;
+    account: CompleteAccountCustomer;
+    containerConfig?: ContainerNormalizedConfig;
+}): Promise<void>;
+declare function ensureImageFitsLimits(options: {
+    availableSizeInBytes: number;
+    pathToDocker: string;
+    imageTag: string;
+}): Promise<void>;
+declare function getContainerAccount(accountId?: string, complianceConfig?: ComplianceConfig): Promise<CompleteAccountCustomer>;
+
+/**
+ * Removes from the object every undefined property
+ */
+declare function stripUndefined<T = Record<string, unknown>>(r: T): T;
+/**
+ * Take an object and sort its keys in alphabetical order recursively.
+ * Useful to normalize objects so they can be compared when rendered.
+ * It will copy the object and not mutate it.
+ */
+declare function sortObjectRecursive<T = Record<string | number, unknown>>(object: Record<string | number, unknown> | Record<string | number, unknown>[]): T;
+
+/** helper for simple docker command call that don't require any io handling */
+declare const runDockerCmd: (dockerPath: string, args: string[], stdio?: StdioOptions) => {
+    abort: () => void;
+    ready: Promise<{
+        aborted: boolean;
+    }>;
+    then: (resolve: () => void, reject: () => void) => void;
+};
+declare const runDockerCmdWithOutput: (dockerPath: string, args: string[]) => string;
+/**
+ * Permit elevated container options only when the selected daemon adds an
+ * isolation boundary. Rootless Docker limits `SYS_ADMIN` to its user
+ * namespace. Local Docker engines on macOS and through WSL run their Linux
+ * daemon in a VM.
+ */
+declare function containerPrivilegesAllowed(dockerHost: string, dockerPath?: string): Promise<boolean>;
+/** Checks whether docker is running on the system */
+declare const isDockerRunning: (dockerPath: string) => Promise<boolean>;
+/** Options for verifying that Docker is installed and the daemon is running. */
+type VerifyDockerInstalledOptions = {
+    /** Path to the Docker CLI executable. */
+    dockerPath: string;
+    /**
+     * Human-readable description of the operation that requires Docker,
+     * e.g. `"running dev"`, `"deploying"`.
+     * When provided, the error headline reads "... before ${operation} ...".
+     * When omitted, the "before ..." clause is left out entirely.
+     */
+    operation?: string;
+    /**
+     * Noun describing what needs to be built, used in the error headline.
+     * For example `"the configured image"` or `"the configured images"`.
+     */
+    imageNoun: string;
+    /**
+     * Optional context-specific hint appended at the end of the error message.
+     * When omitted, no hint paragraph is included.
+     */
+    hint?: string;
+};
+/**
+ * Verifies that Docker is installed and the daemon is running.
+ *
+ * @throws {UserError} If the Docker CLI cannot be reached.
+ *
+ * @param options - Docker verification options.
+ * @param options.dockerPath - Path to the Docker CLI executable.
+ * @param options.operation - Optional human-readable operation description for the error message
+ *   headline. When provided, produces "before ${operation}". When omitted, the clause is skipped.
+ * @param options.imageNoun - Noun describing what needs to be built (e.g. "the configured image").
+ * @param options.hint - Optional context-specific hint appended to the error message.
+ */
+declare const verifyDockerInstalled: ({ dockerPath, operation, imageNoun, hint, }: VerifyDockerInstalledOptions) => Promise<void>;
+/**
+ * Kills and removes any containers which come from the given image tag
+ */
+declare const cleanupContainers: (dockerPath: string, imageTags: Set<string>) => boolean;
+/**
+ * See https://docs.docker.com/reference/cli/docker/container/ls/#ancestor
+ *
+ * @param dockerPath The path to the Docker executable
+ * @param imageTags A set of ancestor image tags
+ * @returns The ids of all containers that share the given image tags as ancestors.
+ */
+declare function getContainerIdsByImageTags(dockerPath: string, imageTags: Set<string>): string[];
+declare const getContainerIdsFromImage: (dockerPath: string, ancestorImage: string) => string[];
+/**
+ * While all ports are exposed in prod, a limitation of local dev with docker is that
+ * users will have to manually expose ports in their Dockerfile.
+ * We want to fail early and clearly if a user tries to develop with a container
+ * that has no ports exposed and is definitely not accessible.
+ *
+ * (A user could still use `getTCPPort()` on a port that is not exposed, but we leave that error for runtime.)
+ */
+declare function checkExposedPorts(dockerPath: string, options: ContainerDevOptions): Promise<void>;
+/**
+ * Generates a random container build id
+ */
+declare function generateContainerBuildId(): string;
+/**
+ * Run `docker context ls` to get the socket from the currently active Docker context
+ * @returns The socket path or null if we are not able to determine it
+ */
+declare function getDockerSocketFromContext(dockerPath: string): string | null;
+/**
+ * Resolve Docker host as follows:
+ * 1. Check WRANGLER_DOCKER_HOST environment variable
+ * 2. Check DOCKER_HOST environment variable
+ * 3. Try to get socket from active Docker context
+ * 4. Fall back to platform-specific defaults
+ */
+declare function resolveDockerHost(dockerPath: string): string;
+/**
+ *
+ * Get docker host from environment variables or platform defaults.
+ * Does not use the docker context ls command, so we
+ */
+declare const getDockerHostFromEnv: () => string;
+/**
+ * Get all repository tags for a given image
+ */
+declare function getImageRepoTags(dockerPath: string, imageTag: string): Promise<string[]>;
+/**
+ * Checks if the given image has any duplicate tags from previous dev sessions,
+ * and remove them if so.
+ */
+declare function cleanupDuplicateImageTags(dockerPath: string, imageTag: string): Promise<void>;
+
+declare function dockerImageInspect(dockerPath: string, options: {
+    imageTag: string;
+    formatString: string;
+}): Promise<string>;
+
+/**
+ * Adds the Cloudflare account namespace to an image tag in the managed registry.
+ *
+ * @param accountID - Cloudflare account ID that owns the image.
+ * @param tag - Image name and tag to namespace.
+ * @param complianceConfig - Compliance configuration used to select the managed registry.
+ * @returns The fully qualified managed-registry image reference.
+ */
+declare const getCloudflareRegistryWithAccountNamespace: (accountID: string, tag: string, complianceConfig?: ComplianceConfig$1) => string;
+declare const MF_DEV_CONTAINER_PREFIX = "cloudflare-dev";
+
+declare const DEFAULT_CONTAINER_EGRESS_INTERCEPTOR_IMAGE = "cloudflare/proxy-everything:3cb1195@sha256:0ef6716c52430096900b150d84a3302057d6cd2319dae7987128c85d0733e3c8";
+declare function getEgressInterceptorPlatform(): string | undefined;
+declare function getEgressInterceptorImage(): string;
+declare function pullEgressInterceptorImage(dockerPath: string): Promise<void>;
+/**
+ * Pulls a prebuilt image for local container development.
+ *
+ * @param dockerPath - Path to the Docker CLI executable.
+ * @param options - Container image and local development tag configuration.
+ * @param logger - Logger used for recoverable registry credential warnings.
+ * @param complianceConfig - Compliance configuration used to identify the managed registry.
+ * @returns An object with an `abort` function and a `ready` promise.
+ */
+declare function pullImage(dockerPath: string, options: Exclude<ContainerDevOptions, DockerfileConfig>, logger: WranglerLogger | ViteLogger, complianceConfig?: ComplianceConfig$1): Promise<{
+    abort: () => void;
+    ready: Promise<void>;
+}>;
+/**
+ *
+ * Builds or pulls the container images for local development. This
+ * will be called before starting the local development server, and by a rebuild
+ * hotkey during development.
+ *
+ * Because this runs when local dev starts, we also do some validation here,
+ * such as checking if the Docker CLI is installed, and if the container images
+ * expose any ports.
+ *
+ * @param args - Image preparation callbacks, Docker settings, and compliance configuration.
+ * @returns A promise that resolves when all configured images are ready.
+ */
+declare function prepareContainerImagesForDev(args: {
+    dockerPath: string;
+    containerOptions: ContainerDevOptions[];
+    onContainerImagePreparationStart: (args: {
+        containerOptions: ContainerDevOptions;
+        abort: () => void;
+    }) => void;
+    onContainerImagePreparationEnd: (args: {
+        containerOptions: ContainerDevOptions;
+    }) => void;
+    logger: WranglerLogger | ViteLogger;
+    complianceConfig?: ComplianceConfig$1;
+}): Promise<void>;
+/**
+ * Resolve an image name to the full unambiguous name.
+ *
+ * image:tag -> prepend registry.cloudflare.com/accountid/
+ * registry.cloudflare.com/image:tag -> registry.cloudflare.com/accountid/image:tag
+ * registry.cloudflare.com/accountid/image:tag -> no change
+ * anyother-registry.com/anything -> no change
+ *
+ * @param accountId - Cloudflare account ID that owns managed-registry images.
+ * @param image - Image reference to normalize.
+ * @param complianceConfig - Compliance configuration used to select the managed registry.
+ * @returns The normalized image reference.
+ */
+declare function resolveImageName(accountId: string, image: string, complianceConfig?: ComplianceConfig$1): string;
+/**
+ * Get type of container registry, and validate.
+ * We support the configured Cloudflare managed registry plus the external registries listed in
+ * `acceptedRegistries` below (currently AWS ECR, DockerHub, and Google Artifact Registry).
+ *
+ * @param domain - Registry hostname to validate.
+ * @param complianceConfig - Compliance configuration used to select the managed registry.
+ * @returns The matching registry type and credential metadata.
+ */
+declare const getAndValidateRegistryType: (domain: string, complianceConfig?: ComplianceConfig$1) => RegistryPattern;
+interface RegistryPattern {
+    type: ExternalRegistryKind | "cloudflare";
+    secretType?: string;
+    pattern: RegExp;
+    name: string;
+}
+/**
+ * Validates a Google service account JSON key and returns it base64-encoded for
+ * storage as the private credential.
+ *
+ * Accepts the raw JSON key contents or its base64-encoded form. Throws a
+ * `UserError` if the key is malformed, or if `expectedEmail` (the
+ * `--gar-email` public credential) does not match the `client_email` in the key.
+ */
+declare function validateAndEncodeGarKey(rawKey: string, expectedEmail: string): string;
+
+declare function promiseSpinner<T>(promise: Promise<T>, { message, }?: {
+    message: string;
+}): Promise<T>;
+
+export { type AccountDefaults, type AccountID, type AccountLimit, type AccountLocation, type AccountLocationLimits, type AccountLocationLimitsAsProperty, type AccountRegistryToken, AccountService, type AddressAssignment, ApiError, type Application, type ApplicationAffinities, ApplicationAffinityColocation, ApplicationAffinityHardwareGeneration, type ApplicationConstraintPop, type ApplicationConstraints, type ApplicationHealth, type ApplicationHealthInstances, type ApplicationID, type ApplicationJob, type ApplicationJobsConfig, ApplicationMutationError, type ApplicationName, type ApplicationNotFoundError, type ApplicationObservability, type ApplicationPriorities, type ApplicationPriority, ApplicationRollout, type ApplicationRolloutActiveGracePeriod, type ApplicationRolloutProgress, type ApplicationSchedulingHint, type ApplicationStatus, ApplicationsService, AssignIPv4, AssignIPv6, type BadRequestError, BadRequestWithCodeError, type BuildArgs, type BuiltContainerImage, type BuiltImage, CancelError, CancelablePromise, type City, type Command, type CompleteAccountCustomer, type CompleteAccountLocationCustomer, type ContainerBuildCommandArgs, type ContainerDevOptions, type ContainerImagePreparation, ContainerImagePreparationStatus, ContainerImagePreparationsService, ContainerNetworkMode, type ContainerNormalizedConfig, type ContainerPushCommandArgs, type ContainersSharedContext, type CreateApplicationBadRequest, type CreateApplicationJobBadRequest, type CreateApplicationJobRequest, type CreateApplicationRequest, CreateApplicationRolloutRequest, type CreateDeploymentBadRequest, type CreateDeploymentV2RequestBody, type CreateDurableObjectApplicationRequest, type CreateImageRegistryRequestBody, type CreateSSHPublicKeyError, type CreateSSHPublicKeyRequestBody, type CustomerImageRegistry, DEFAULT_CONTAINER_EGRESS_INTERCEPTOR_IMAGE, type DNSConfiguration, type DashApplication, type DashApplicationDurableObjectInstance, type DashApplicationInstance, type DashApplicationInstances, type DeleteDeploymentError, type DeleteImageRegistryResponse, type DeploymentAlreadyExists, type DeploymentCheck, type DeploymentCheckHTTP, type DeploymentCheckHTTPRequestBody, DeploymentCheckKind, type DeploymentCheckRequestBody, DeploymentCheckType, type DeploymentCreationError, type DeploymentID, type DeploymentListError, type DeploymentLocation, type DeploymentModificationError, DeploymentMutationError, DeploymentNotFoundError, DeploymentPlacementState, type DeploymentQueuedDetails, DeploymentQueuedReason, type DeploymentReplacementError, DeploymentSchedulingState, type DeploymentSecretMap, type DeploymentState, DeploymentType, type DeploymentV2, type DeploymentVersion, DeploymentsService, Diff, type Disk, type DiskMB, type DiskSizeWithUnit, type DockerfileConfig, type DockerfileContainerConfig, type Domain, type DurableObjectNamespace, DurableObjectStatusHealth, type DurableObjectsConfiguration, type Duration, type EmptyResponse, type Entrypoint, type EnvironmentVariable, type EnvironmentVariableName, type EnvironmentVariableValue, EventName, EventType, type ExecFormParam, ExternalRegistryKind, FUSE_CONTAINER_PRIVILEGES, type GenericErrorDetails, type GenericErrorResponseWithRequestID, type GenericMessageResponse, type GetDeploymentError, type GetPlacementError, HTTPMethod, type IP, type IPAllocation, type IPAllocationConfiguration, type IPAllocationsWithFilter, IPType, type IPV4, IPsService, type ISO8601Timestamp, type Identity, type Image, type ImageRef, ImageRegistriesService, ImageRegistryAlreadyExistsError, type ImageRegistryAuth, type ImageRegistryCredentialsConfiguration, ImageRegistryIsPublic, ImageRegistryNotAllowedError, ImageRegistryNotFoundError, ImageRegistryPermissions, type ImageRegistryProtoDomain, type ImageRegistryProtocol, ImageRegistryProtocolAlreadyExists, ImageRegistryProtocolIsReferencedError, ImageRegistryProtocolNotFound, type ImageRegistryProtocols, type ImageURIConfig, InstanceType, type InstanceTypeOrLimits, type InternalError, type JobEvents, type JobID, type JobNotFoundError, type JobSecretMap, type JobStatus, JobStatusHealth, type JobTimeoutSeconds, JobsService, type Label, type LabelName, type LabelValue, type ListApplications, type ListDeploymentsV2, type ListIPsIsAllocated, type ListPlacements, type ListPlacementsError, type ListSSHPublicKeys, type ListSSHPublicKeysError, type ListSecretsMetadata, type Location, type LocationID, MF_DEV_CONTAINER_PREFIX, type MemorySizeWithUnit, type ModifyApplicationBadRequest, type ModifyApplicationJobBadRequest, type ModifyApplicationJobRequest, type ModifyApplicationRequestBody, type ModifyDeploymentBadRequest, type ModifyDeploymentV2RequestBody, type ModifyMeRequestBody, type ModifySecretRequestBody, type ModifyUserDeploymentConfiguration, type Network, NetworkMode, type NetworkParameters, NodeGroup, type Observability, type ObservabilityLogs, OpenAPI, type OpenAPIConfig, type PaginatedResult, type Placement, type PlacementEvent, type PlacementEvents, type PlacementID, type PlacementNotFoundError, type PlacementStatus, PlacementStatusHealth, type PlacementWithEvents, PlacementsService, type PlainTextSecretValue, type Port, type PortRange, type PortRangeAllocation, type PrepareContainerImageRequestBody, ProvisionerConfiguration, type Ref, type Region, type ReplaceDeploymentRequestBody, type ResolvedContainerDeployment, type ResultInfo, type RolloutID, RolloutStep, type RolloutStepRequest, RolloutsService, type SSHPublicKey, type SSHPublicKeyID, type SSHPublicKeyItem, SSHPublicKeyNotFoundError, type SchedulerDeploymentConfiguration, SchedulingPolicy, type Secret, SecretAccessType, type SecretMap, type SecretMetadata, type SecretName, SecretNameAlreadyExists, SecretNotFound, SecretsService, type SecretsStoreRef, type SharedContainerConfig, SshPublicKeysService, type UnAuthorizedError, type UnixTimestamp, type UnknownAccount, UpdateApplicationRolloutRequest, type UpdateRolloutResponse, type UserDeploymentConfiguration, type UserSSHPublicKey, type VerifyDockerInstalledOptions, type ViteLogger, type WranglerLogger, type WranglerSSHConfig, type WranglerSSHResponse, apply, buildAndMaybePush, buildCommand, buildContainerImages, checkExposedPorts, cleanApplicationFromAPI, cleanForInstanceType, cleanupBuiltImages, cleanupContainers, cleanupDuplicateImageTags, configRolloutStepsToAPI, configureOpenAPIForContainerPull, containerPrivilegesAllowed, createDurableObjectNamespaceResolver, deployContainers, dockerBuild, dockerImageInspect, dockerLoginImageRegistry, ensureContainerLimits, ensureImageFitsLimits, fetchPagedListResult, fetchResult, formatError, generateContainerBuildId, getAndValidateRegistryType, getCloudflareContainerRegistry, getCloudflareRegistryWithAccountNamespace, getContainerAccount, getContainerIdsByImageTags, getContainerIdsFromImage, getContainerImageTag, getDevContainerImageName, getDockerHostFromEnv, getDockerSocketFromContext, getEgressInterceptorImage, getEgressInterceptorPlatform, getImageRepoTags, getInstanceTypeUsage, inferInstanceType, initContainersSharedContext, isDockerRunning, isDockerfileContainerConfig, listDurableObjects, logger, prepareContainerImagesForDev, promiseSpinner, pullEgressInterceptorImage, pullImage, pushBuiltContainerImage, pushCommand, pushImageIfChanged, request, requestPaginated, resolveDockerHost, resolveImageName, runDockerCmd, runDockerCmdWithOutput, sortObjectRecursive, startContainerBuild, stripUndefined, validateAndEncodeGarKey, verifyDockerInstalled };