@cloudflare/containers-shared 0.16.0

package/dist/index.mjs

@@ -0,0 +1,4967 @@
+import { spawn, execFileSync, execFile } from 'node:child_process';
+import crypto, { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getDockerPath } from '@cloudflare/workers-utils/docker-path';
+import { UserError, FatalError } from '@cloudflare/workers-utils/errors';
+import { isDirectory } from '@cloudflare/workers-utils/fs-helpers';
+import { COMPLIANCE_REGION_CONFIG_UNKNOWN, getComplianceRegionSubdomain } from '@cloudflare/workers-utils/compliance';
+import { release } from 'node:os';
+import assert from 'node:assert';
+import { setTimeout } from 'node:timers/promises';
+import { log, startSection, newline, endSection, updateStatus, success, shapes } from '@cloudflare/cli-shared-helpers';
+import { green, red, dim, brandColor, bold } from '@cloudflare/cli-shared-helpers/colors';
+import { formatConfigSnippet } from '@cloudflare/workers-utils';
+import { spinner } from '@cloudflare/cli-shared-helpers/interactive';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/client/core/ApiError.ts
+var ApiError = class extends Error {
+  static {
+    __name(this, "ApiError");
+  }
+  url;
+  status;
+  statusText;
+  body;
+  request;
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// src/client/core/CancelablePromise.ts
+var CancelError = class extends Error {
+  static {
+    __name(this, "CancelError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var CancelablePromise = class {
+  static {
+    __name(this, "CancelablePromise");
+  }
+  #isResolved;
+  #isRejected;
+  #isCancelled;
+  #cancelHandlers;
+  #promise;
+  #resolve;
+  #reject;
+  constructor(executor) {
+    this.#isResolved = false;
+    this.#isRejected = false;
+    this.#isCancelled = false;
+    this.#cancelHandlers = [];
+    this.#promise = new Promise((resolve2, reject) => {
+      this.#resolve = resolve2;
+      this.#reject = reject;
+      const onResolve = /* @__PURE__ */ __name((value) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isResolved = true;
+        this.#resolve?.(value);
+      }, "onResolve");
+      const onReject = /* @__PURE__ */ __name((reason) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isRejected = true;
+        this.#reject?.(reason);
+      }, "onReject");
+      const onCancel = /* @__PURE__ */ __name((cancelHandler) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#cancelHandlers.push(cancelHandler);
+      }, "onCancel");
+      Object.defineProperty(onCancel, "isResolved", {
+        get: /* @__PURE__ */ __name(() => this.#isResolved, "get")
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: /* @__PURE__ */ __name(() => this.#isRejected, "get")
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: /* @__PURE__ */ __name(() => this.#isCancelled, "get")
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return this.#promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this.#promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.#promise.finally(onFinally);
+  }
+  cancel() {
+    if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+      return;
+    }
+    this.#isCancelled = true;
+    if (this.#cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.#cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this.#cancelHandlers.length = 0;
+    this.#reject?.(new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this.#isCancelled;
+  }
+};
+
+// src/client/core/OpenAPI.ts
+var OpenAPI = {
+  BASE: "",
+  VERSION: "1.0.0",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0,
+  LOGGER: void 0
+};
+
+// src/client/core/request.ts
+var isDefined = /* @__PURE__ */ __name((value) => {
+  return value !== void 0 && value !== null;
+}, "isDefined");
+var isString = /* @__PURE__ */ __name((value) => {
+  return typeof value === "string";
+}, "isString");
+var isStringWithValue = /* @__PURE__ */ __name((value) => {
+  return isString(value) && value !== "";
+}, "isStringWithValue");
+var isBlob = /* @__PURE__ */ __name((value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+}, "isBlob");
+var isErrorResponse = /* @__PURE__ */ __name((value) => {
+  return typeof value === "object" && value !== null && "error" in value && typeof value.error === "string";
+}, "isErrorResponse");
+var base64 = /* @__PURE__ */ __name((str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+}, "base64");
+var getQueryString = /* @__PURE__ */ __name((params) => {
+  const qs = [];
+  const append = /* @__PURE__ */ __name((key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }, "append");
+  const process2 = /* @__PURE__ */ __name((key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process2(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process2(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  }, "process");
+  Object.entries(params).forEach(([key, value]) => {
+    process2(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+}, "getQueryString");
+var getUrl = /* @__PURE__ */ __name((config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+}, "getUrl");
+var getFormData = /* @__PURE__ */ __name((options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process2 = /* @__PURE__ */ __name(async (key, value) => {
+      if (isString(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    }, "process");
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process2(key, v));
+      } else {
+        process2(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+}, "getFormData");
+var resolve = /* @__PURE__ */ __name(async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+}, "resolve");
+var getHeaders = /* @__PURE__ */ __name(async (config, options) => {
+  const token = await resolve(options, config.TOKEN);
+  const username = await resolve(options, config.USERNAME);
+  const password = await resolve(options, config.PASSWORD);
+  const additionalHeaders = await resolve(options, config.HEADERS);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([_, value]) => isDefined(value)).reduce(
+    (headers2, [key, value]) => ({
+      ...headers2,
+      [key]: String(value)
+    }),
+    {}
+  );
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return new Headers(headers);
+}, "getHeaders");
+var getRequestBody = /* @__PURE__ */ __name((options) => {
+  if (options.body !== void 0) {
+    if (options.mediaType?.includes("/json")) {
+      return JSON.stringify(options.body);
+    } else if (isString(options.body) || isBlob(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return void 0;
+}, "getRequestBody");
+var isResponseSchemaV4 = /* @__PURE__ */ __name((config, _options) => {
+  return config.BASE.endsWith("/containers");
+}, "isResponseSchemaV4");
+var parseResponseSchemaV4 = /* @__PURE__ */ __name((url, response, responseHeader, responseBody) => {
+  const fetchResult2 = typeof responseBody === "object" ? responseBody : JSON.parse(responseBody);
+  const ok = response.ok && fetchResult2.success;
+  let result;
+  if (ok) {
+    if (fetchResult2.result !== void 0) {
+      result = fetchResult2.result;
+    } else {
+      result = {};
+    }
+  } else if (isErrorResponse(fetchResult2)) {
+    result = fetchResult2;
+  } else {
+    result = { error: fetchResult2.errors?.[0]?.message };
+  }
+  return {
+    url,
+    ok,
+    status: response.status,
+    statusText: response.statusText,
+    body: responseHeader ?? result
+  };
+}, "parseResponseSchemaV4");
+var sendRequest = /* @__PURE__ */ __name(async (config, options, url, body, formData, headers, onCancel) => {
+  const controller = new AbortController();
+  const request2 = {
+    headers,
+    body: body ?? formData,
+    method: options.method,
+    signal: controller.signal
+  };
+  if (config.WITH_CREDENTIALS) {
+    request2.credentials = config.CREDENTIALS;
+  }
+  onCancel(() => controller.abort());
+  return await fetch(url, request2);
+}, "sendRequest");
+var getResponseHeader = /* @__PURE__ */ __name((response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+}, "getResponseHeader");
+var getResponseBody = /* @__PURE__ */ __name(async (response) => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const jsonTypes = ["application/json", "application/problem+json"];
+        const isJSON = jsonTypes.some(
+          (type) => contentType.toLowerCase().startsWith(type)
+        );
+        if (isJSON) {
+          return await response.json();
+        } else {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return void 0;
+}, "getResponseBody");
+var catchErrorCodes = /* @__PURE__ */ __name((options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    throw new ApiError(options, result, "Generic Error");
+  }
+}, "catchErrorCodes");
+var executeRequest = /* @__PURE__ */ __name(async (config, options, onCancel) => {
+  const url = getUrl(config, options);
+  const formData = getFormData(options);
+  const body = getRequestBody(options);
+  const headers = await getHeaders(config, options);
+  debugLogRequest(config, url, headers, formData ?? body ?? {});
+  if (onCancel.isCancelled) {
+    return null;
+  }
+  const response = await sendRequest(
+    config,
+    options,
+    url,
+    body,
+    formData,
+    headers,
+    onCancel
+  );
+  const responseBody = await getResponseBody(response);
+  const responseHeader = getResponseHeader(response, options.responseHeader);
+  return { url, response, responseBody, responseHeader };
+}, "executeRequest");
+var buildApiResult = /* @__PURE__ */ __name((config, options, req) => {
+  if (isResponseSchemaV4(config, options)) {
+    return parseResponseSchemaV4(
+      req.url,
+      req.response,
+      req.responseHeader,
+      req.responseBody
+    );
+  }
+  return {
+    url: req.url,
+    ok: req.response.ok,
+    status: req.response.status,
+    statusText: req.response.statusText,
+    body: req.responseHeader ?? req.responseBody
+  };
+}, "buildApiResult");
+var request = /* @__PURE__ */ __name((config, options) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const req = await executeRequest(config, options, onCancel);
+      if (!req) {
+        return;
+      }
+      const result = buildApiResult(config, options, req);
+      debugLogResponse(config, result);
+      catchErrorCodes(options, result);
+      resolve2(result.body);
+    } catch (error) {
+      reject(error);
+    }
+  });
+}, "request");
+var requestPaginated = /* @__PURE__ */ __name((config, options) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const req = await executeRequest(config, options, onCancel);
+      if (!req) {
+        return;
+      }
+      const result = buildApiResult(config, options, req);
+      debugLogResponse(config, result);
+      catchErrorCodes(options, result);
+      let resultInfo;
+      if (isResponseSchemaV4(config, options)) {
+        const fetchResult2 = typeof req.responseBody === "object" ? req.responseBody : JSON.parse(req.responseBody);
+        resultInfo = fetchResult2.result_info;
+      }
+      resolve2({
+        data: result.body,
+        resultInfo
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}, "requestPaginated");
+var debugLogRequest = /* @__PURE__ */ __name(async (config, url, headers, body) => {
+  config.LOGGER?.debug(`-- START CF API REQUEST: ${url}`);
+  const logHeaders = new Headers(headers);
+  logHeaders.delete("Authorization");
+  config.LOGGER?.debugWithSanitization(
+    "HEADERS:",
+    JSON.stringify(logHeaders, null, 2)
+  );
+  config.LOGGER?.debugWithSanitization(
+    "BODY:",
+    JSON.stringify(
+      body instanceof FormData ? await new Response(body).text() : body,
+      null,
+      2
+    )
+  );
+  config.LOGGER?.debug("-- END CF API REQUEST");
+}, "debugLogRequest");
+var debugLogResponse = /* @__PURE__ */ __name((config, response) => {
+  config.LOGGER?.debug(
+    "-- START CF API RESPONSE:",
+    response.statusText,
+    response.status
+  );
+  config.LOGGER?.debugWithSanitization("RESPONSE:", response.body);
+  config.LOGGER?.debug("-- END CF API RESPONSE");
+}, "debugLogResponse");
+
+// src/client/models/ApplicationAffinityColocation.ts
+var ApplicationAffinityColocation = /* @__PURE__ */ ((ApplicationAffinityColocation2) => {
+  ApplicationAffinityColocation2["DATACENTER"] = "datacenter";
+  return ApplicationAffinityColocation2;
+})(ApplicationAffinityColocation || {});
+
+// src/client/models/ApplicationAffinityHardwareGeneration.ts
+var ApplicationAffinityHardwareGeneration = /* @__PURE__ */ ((ApplicationAffinityHardwareGeneration2) => {
+  ApplicationAffinityHardwareGeneration2["HIGHEST_OVERALL_PERFORMANCE"] = "highest-overall-performance";
+  return ApplicationAffinityHardwareGeneration2;
+})(ApplicationAffinityHardwareGeneration || {});
+
+// src/client/models/ApplicationMutationError.ts
+var ApplicationMutationError = /* @__PURE__ */ ((ApplicationMutationError2) => {
+  ApplicationMutationError2["IMAGE_REGISTRY_RETURNED_ERROR"] = "IMAGE_REGISTRY_RETURNED_ERROR";
+  ApplicationMutationError2["IMAGE_REGISTRY_DOESNT_CONTAIN_IMAGE"] = "IMAGE_REGISTRY_DOESNT_CONTAIN_IMAGE";
+  ApplicationMutationError2["VALIDATE_INPUT"] = "VALIDATE_INPUT";
+  ApplicationMutationError2["SURPASSED_BASE_LIMITS"] = "SURPASSED_BASE_LIMITS";
+  ApplicationMutationError2["SURPASSED_TOTAL_LIMITS"] = "SURPASSED_TOTAL_LIMITS";
+  ApplicationMutationError2["LOCATION_NOT_ALLOWED"] = "LOCATION_NOT_ALLOWED";
+  ApplicationMutationError2["LOCATION_SURPASSED_BASE_LIMITS"] = "LOCATION_SURPASSED_BASE_LIMITS";
+  ApplicationMutationError2["IMAGE_REGISTRY_NOT_CONFIGURED"] = "IMAGE_REGISTRY_NOT_CONFIGURED";
+  ApplicationMutationError2["JOB_CREATE_NOT_ALLOWED"] = "JOB_CREATE_NOT_ALLOWED";
+  ApplicationMutationError2["DURABLE_OBJECT_NOT_FOUND"] = "DURABLE_OBJECT_NOT_FOUND";
+  ApplicationMutationError2["DURABLE_OBJECT_NOT_CONTAINER_ENABLED"] = "DURABLE_OBJECT_NOT_CONTAINER_ENABLED";
+  ApplicationMutationError2["DURABLE_OBJECT_ALREADY_HAS_APPLICATION"] = "DURABLE_OBJECT_ALREADY_HAS_APPLICATION";
+  return ApplicationMutationError2;
+})(ApplicationMutationError || {});
+
+// src/client/models/ApplicationRollout.ts
+var ApplicationRollout;
+((ApplicationRollout2) => {
+  ((kind2) => {
+    kind2["FULL_AUTO"] = "full_auto";
+    kind2["FULL_MANUAL"] = "full_manual";
+    kind2["DURABLE_OBJECTS_AUTO"] = "durable_objects_auto";
+  })(ApplicationRollout2.kind || (ApplicationRollout2.kind = {}));
+  ((strategy2) => {
+    strategy2["ROLLING"] = "rolling";
+  })(ApplicationRollout2.strategy || (ApplicationRollout2.strategy = {}));
+  ((status2) => {
+    status2["PENDING"] = "pending";
+    status2["PROGRESSING"] = "progressing";
+    status2["COMPLETED"] = "completed";
+    status2["REVERTED"] = "reverted";
+    status2["REPLACED"] = "replaced";
+  })(ApplicationRollout2.status || (ApplicationRollout2.status = {}));
+})(ApplicationRollout || (ApplicationRollout = {}));
+
+// src/client/models/AssignIPv4.ts
+var AssignIPv4 = /* @__PURE__ */ ((AssignIPv42) => {
+  AssignIPv42["NONE"] = "none";
+  AssignIPv42["PREDEFINED"] = "predefined";
+  AssignIPv42["ACCOUNT"] = "account";
+  return AssignIPv42;
+})(AssignIPv4 || {});
+
+// src/client/models/AssignIPv6.ts
+var AssignIPv6 = /* @__PURE__ */ ((AssignIPv62) => {
+  AssignIPv62["NONE"] = "none";
+  AssignIPv62["PREDEFINED"] = "predefined";
+  AssignIPv62["ACCOUNT"] = "account";
+  return AssignIPv62;
+})(AssignIPv6 || {});
+
+// src/client/models/BadRequestWithCodeError.ts
+var BadRequestWithCodeError;
+((BadRequestWithCodeError2) => {
+  ((error2) => {
+    error2["VALIDATE_INPUT"] = "VALIDATE_INPUT";
+  })(BadRequestWithCodeError2.error || (BadRequestWithCodeError2.error = {}));
+})(BadRequestWithCodeError || (BadRequestWithCodeError = {}));
+
+// src/client/models/ContainerNetworkMode.ts
+var ContainerNetworkMode = /* @__PURE__ */ ((ContainerNetworkMode2) => {
+  ContainerNetworkMode2["PUBLIC"] = "public";
+  ContainerNetworkMode2["PUBLIC_BY_PORT"] = "public-by-port";
+  ContainerNetworkMode2["PRIVATE"] = "private";
+  return ContainerNetworkMode2;
+})(ContainerNetworkMode || {});
+
+// src/client/models/ContainerImagePreparationStatus.ts
+var ContainerImagePreparationStatus = /* @__PURE__ */ ((ContainerImagePreparationStatus2) => {
+  ContainerImagePreparationStatus2["PENDING"] = "pending";
+  ContainerImagePreparationStatus2["READY"] = "ready";
+  ContainerImagePreparationStatus2["ERROR"] = "error";
+  return ContainerImagePreparationStatus2;
+})(ContainerImagePreparationStatus || {});
+
+// src/client/models/CreateApplicationRolloutRequest.ts
+var CreateApplicationRolloutRequest;
+((CreateApplicationRolloutRequest2) => {
+  ((strategy2) => {
+    strategy2["ROLLING"] = "rolling";
+  })(CreateApplicationRolloutRequest2.strategy || (CreateApplicationRolloutRequest2.strategy = {}));
+  ((step_percentage2) => {
+    step_percentage2[step_percentage2["_5"] = 5] = "_5";
+    step_percentage2[step_percentage2["_10"] = 10] = "_10";
+    step_percentage2[step_percentage2["_20"] = 20] = "_20";
+    step_percentage2[step_percentage2["_25"] = 25] = "_25";
+    step_percentage2[step_percentage2["_50"] = 50] = "_50";
+    step_percentage2[step_percentage2["_100"] = 100] = "_100";
+  })(CreateApplicationRolloutRequest2.step_percentage || (CreateApplicationRolloutRequest2.step_percentage = {}));
+  ((kind2) => {
+    kind2["FULL_AUTO"] = "full_auto";
+    kind2["FULL_MANUAL"] = "full_manual";
+  })(CreateApplicationRolloutRequest2.kind || (CreateApplicationRolloutRequest2.kind = {}));
+})(CreateApplicationRolloutRequest || (CreateApplicationRolloutRequest = {}));
+
+// src/client/models/DeploymentCheckKind.ts
+var DeploymentCheckKind = /* @__PURE__ */ ((DeploymentCheckKind2) => {
+  DeploymentCheckKind2["HEALTH"] = "health";
+  DeploymentCheckKind2["READY"] = "ready";
+  return DeploymentCheckKind2;
+})(DeploymentCheckKind || {});
+
+// src/client/models/DeploymentCheckType.ts
+var DeploymentCheckType = /* @__PURE__ */ ((DeploymentCheckType2) => {
+  DeploymentCheckType2["HTTP"] = "http";
+  DeploymentCheckType2["TCP"] = "tcp";
+  return DeploymentCheckType2;
+})(DeploymentCheckType || {});
+
+// src/client/models/DeploymentMutationError.ts
+var DeploymentMutationError = /* @__PURE__ */ ((DeploymentMutationError2) => {
+  DeploymentMutationError2["VALIDATE_INPUT"] = "VALIDATE_INPUT";
+  DeploymentMutationError2["SURPASSED_BASE_LIMITS"] = "SURPASSED_BASE_LIMITS";
+  DeploymentMutationError2["SURPASSED_TOTAL_LIMITS"] = "SURPASSED_TOTAL_LIMITS";
+  DeploymentMutationError2["LOCATION_NOT_ALLOWED"] = "LOCATION_NOT_ALLOWED";
+  DeploymentMutationError2["LOCATION_SURPASSED_BASE_LIMITS"] = "LOCATION_SURPASSED_BASE_LIMITS";
+  DeploymentMutationError2["IMAGE_REGISTRY_NOT_CONFIGURED"] = "IMAGE_REGISTRY_NOT_CONFIGURED";
+  return DeploymentMutationError2;
+})(DeploymentMutationError || {});
+
+// src/client/models/DeploymentNotFoundError.ts
+var DeploymentNotFoundError;
+((DeploymentNotFoundError2) => {
+  ((error2) => {
+    error2["DEPLOYMENT_NOT_FOUND"] = "DEPLOYMENT_NOT_FOUND";
+  })(DeploymentNotFoundError2.error || (DeploymentNotFoundError2.error = {}));
+})(DeploymentNotFoundError || (DeploymentNotFoundError = {}));
+
+// src/client/models/DeploymentPlacementState.ts
+var DeploymentPlacementState = /* @__PURE__ */ ((DeploymentPlacementState2) => {
+  DeploymentPlacementState2["RUNNING"] = "running";
+  DeploymentPlacementState2["STOPPED"] = "stopped";
+  DeploymentPlacementState2["STARTING"] = "starting";
+  DeploymentPlacementState2["STOPPING"] = "stopping";
+  return DeploymentPlacementState2;
+})(DeploymentPlacementState || {});
+
+// src/client/models/DeploymentQueuedReason.ts
+var DeploymentQueuedReason = /* @__PURE__ */ ((DeploymentQueuedReason2) => {
+  DeploymentQueuedReason2["UNKNOWN"] = "unknown";
+  DeploymentQueuedReason2["LOCATION_OVERPROVISIONED"] = "location_overprovisioned";
+  return DeploymentQueuedReason2;
+})(DeploymentQueuedReason || {});
+
+// src/client/models/DeploymentSchedulingState.ts
+var DeploymentSchedulingState = /* @__PURE__ */ ((DeploymentSchedulingState2) => {
+  DeploymentSchedulingState2["SCHEDULED"] = "scheduled";
+  DeploymentSchedulingState2["PLACED"] = "placed";
+  return DeploymentSchedulingState2;
+})(DeploymentSchedulingState || {});
+
+// src/client/models/DeploymentType.ts
+var DeploymentType = /* @__PURE__ */ ((DeploymentType2) => {
+  DeploymentType2["DEFAULT"] = "default";
+  DeploymentType2["JOBS"] = "jobs";
+  DeploymentType2["DURABLE_OBJECT"] = "durable_object";
+  return DeploymentType2;
+})(DeploymentType || {});
+
+// src/client/models/DurableObjectStatusHealth.ts
+var DurableObjectStatusHealth = /* @__PURE__ */ ((DurableObjectStatusHealth2) => {
+  DurableObjectStatusHealth2["CONNECTED"] = "connected";
+  DurableObjectStatusHealth2["DISCONNECTED"] = "disconnected";
+  return DurableObjectStatusHealth2;
+})(DurableObjectStatusHealth || {});
+
+// src/client/models/EventName.ts
+var EventName = /* @__PURE__ */ ((EventName2) => {
+  EventName2["SCHEDULER_PLACED"] = "SchedulerPlaced";
+  EventName2["NETWORKING_IPASSIGNED"] = "NetworkingIPAssigned";
+  EventName2["VMSTARTED"] = "VMStarted";
+  EventName2["IMAGE_PULLED"] = "ImagePulled";
+  EventName2["IMAGE_PULL_ERROR"] = "ImagePullError";
+  EventName2["VMFAILED_TO_START"] = "VMFailedToStart";
+  EventName2["NETWORKING_IPASSIGNMENT_FAILED"] = "NetworkingIPAssignmentFailed";
+  EventName2["VMRUNNING"] = "VMRunning";
+  EventName2["VMSTOPPING"] = "VMStopping";
+  EventName2["VMSTOPPED"] = "VMStopped";
+  EventName2["VMFAILED"] = "VMFailed";
+  EventName2["RUNTIME_START_FAILED"] = "RuntimeStartFailed";
+  EventName2["SSHSTARTED"] = "SSHStarted";
+  EventName2["SERVICE_HEALTH_UPDATES"] = "ServiceHealthUpdates";
+  EventName2["CHECK_UPDATE"] = "CheckUpdate";
+  EventName2["DURABLE_OBJECT_CONNECTED"] = "DurableObjectConnected";
+  EventName2["CONTAINER_STARTED"] = "ContainerStarted";
+  return EventName2;
+})(EventName || {});
+
+// src/client/models/EventType.ts
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["INFO"] = "Info";
+  EventType2["ERROR"] = "Error";
+  EventType2["WARN"] = "Warn";
+  EventType2["USER_ERROR"] = "UserError";
+  EventType2["SYSTEM_ERROR"] = "SystemError";
+  return EventType2;
+})(EventType || {});
+
+// src/client/models/ExternalRegistryKind.ts
+var ExternalRegistryKind = /* @__PURE__ */ ((ExternalRegistryKind2) => {
+  ExternalRegistryKind2["ECR"] = "ECR";
+  ExternalRegistryKind2["DOCKER_HUB"] = "DockerHub";
+  ExternalRegistryKind2["GAR"] = "GAR";
+  return ExternalRegistryKind2;
+})(ExternalRegistryKind || {});
+
+// src/client/models/HTTPMethod.ts
+var HTTPMethod = /* @__PURE__ */ ((HTTPMethod2) => {
+  HTTPMethod2["GET"] = "GET";
+  HTTPMethod2["POST"] = "POST";
+  HTTPMethod2["PATCH"] = "PATCH";
+  HTTPMethod2["PUT"] = "PUT";
+  HTTPMethod2["OPTIONS"] = "OPTIONS";
+  HTTPMethod2["DELETE"] = "DELETE";
+  HTTPMethod2["HEAD"] = "HEAD";
+  return HTTPMethod2;
+})(HTTPMethod || {});
+
+// src/client/models/ImageRegistryAlreadyExistsError.ts
+var ImageRegistryAlreadyExistsError;
+((ImageRegistryAlreadyExistsError2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_ALREADY_EXISTS"] = "IMAGE_REGISTRY_ALREADY_EXISTS";
+  })(ImageRegistryAlreadyExistsError2.error || (ImageRegistryAlreadyExistsError2.error = {}));
+})(ImageRegistryAlreadyExistsError || (ImageRegistryAlreadyExistsError = {}));
+
+// src/client/models/ImageRegistryIsPublic.ts
+var ImageRegistryIsPublic;
+((ImageRegistryIsPublic2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_IS_PUBLIC"] = "IMAGE_REGISTRY_IS_PUBLIC";
+  })(ImageRegistryIsPublic2.error || (ImageRegistryIsPublic2.error = {}));
+})(ImageRegistryIsPublic || (ImageRegistryIsPublic = {}));
+
+// src/client/models/ImageRegistryNotAllowedError.ts
+var ImageRegistryNotAllowedError;
+((ImageRegistryNotAllowedError2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_NOT_ALLOWED"] = "IMAGE_REGISTRY_NOT_ALLOWED";
+  })(ImageRegistryNotAllowedError2.error || (ImageRegistryNotAllowedError2.error = {}));
+})(ImageRegistryNotAllowedError || (ImageRegistryNotAllowedError = {}));
+
+// src/client/models/ImageRegistryNotFoundError.ts
+var ImageRegistryNotFoundError;
+((ImageRegistryNotFoundError2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_NOT_FOUND"] = "IMAGE_REGISTRY_NOT_FOUND";
+  })(ImageRegistryNotFoundError2.error || (ImageRegistryNotFoundError2.error = {}));
+})(ImageRegistryNotFoundError || (ImageRegistryNotFoundError = {}));
+
+// src/client/models/ImageRegistryPermissions.ts
+var ImageRegistryPermissions = /* @__PURE__ */ ((ImageRegistryPermissions2) => {
+  ImageRegistryPermissions2["PULL"] = "pull";
+  ImageRegistryPermissions2["PUSH"] = "push";
+  ImageRegistryPermissions2["LIBRARY_PUSH"] = "library_push";
+  return ImageRegistryPermissions2;
+})(ImageRegistryPermissions || {});
+
+// src/client/models/ImageRegistryProtocolAlreadyExists.ts
+var ImageRegistryProtocolAlreadyExists;
+((ImageRegistryProtocolAlreadyExists2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_PROTOCOL_ALREADY_EXISTS"] = "IMAGE_REGISTRY_PROTOCOL_ALREADY_EXISTS";
+  })(ImageRegistryProtocolAlreadyExists2.error || (ImageRegistryProtocolAlreadyExists2.error = {}));
+})(ImageRegistryProtocolAlreadyExists || (ImageRegistryProtocolAlreadyExists = {}));
+
+// src/client/models/ImageRegistryProtocolIsReferencedError.ts
+var ImageRegistryProtocolIsReferencedError;
+((ImageRegistryProtocolIsReferencedError2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_PROTO_IS_REFERENCED"] = "IMAGE_REGISTRY_PROTO_IS_REFERENCED";
+  })(ImageRegistryProtocolIsReferencedError2.error || (ImageRegistryProtocolIsReferencedError2.error = {}));
+})(ImageRegistryProtocolIsReferencedError || (ImageRegistryProtocolIsReferencedError = {}));
+
+// src/client/models/ImageRegistryProtocolNotFound.ts
+var ImageRegistryProtocolNotFound;
+((ImageRegistryProtocolNotFound2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_PROTOCOL_NOT_FOUND"] = "IMAGE_REGISTRY_PROTOCOL_NOT_FOUND";
+  })(ImageRegistryProtocolNotFound2.error || (ImageRegistryProtocolNotFound2.error = {}));
+})(ImageRegistryProtocolNotFound || (ImageRegistryProtocolNotFound = {}));
+
+// src/client/models/InstanceType.ts
+var InstanceType = /* @__PURE__ */ ((InstanceType2) => {
+  InstanceType2["LITE"] = "lite";
+  InstanceType2["DEV"] = "dev";
+  InstanceType2["BASIC"] = "basic";
+  InstanceType2["STANDARD"] = "standard";
+  InstanceType2["STANDARD_1"] = "standard-1";
+  InstanceType2["STANDARD_2"] = "standard-2";
+  InstanceType2["STANDARD_3"] = "standard-3";
+  InstanceType2["STANDARD_4"] = "standard-4";
+  return InstanceType2;
+})(InstanceType || {});
+
+// src/client/models/IPType.ts
+var IPType = /* @__PURE__ */ ((IPType2) => {
+  IPType2["V4"] = "v4";
+  IPType2["V6"] = "v6";
+  return IPType2;
+})(IPType || {});
+
+// src/client/models/JobStatusHealth.ts
+var JobStatusHealth = /* @__PURE__ */ ((JobStatusHealth2) => {
+  JobStatusHealth2["QUEUED"] = "Queued";
+  JobStatusHealth2["SCHEDULED"] = "Scheduled";
+  JobStatusHealth2["PLACED"] = "Placed";
+  JobStatusHealth2["RUNNING"] = "Running";
+  JobStatusHealth2["STOPPED"] = "Stopped";
+  return JobStatusHealth2;
+})(JobStatusHealth || {});
+
+// src/client/models/NetworkMode.ts
+var NetworkMode = /* @__PURE__ */ ((NetworkMode2) => {
+  NetworkMode2["USO"] = "uso";
+  NetworkMode2["VHOST"] = "vhost";
+  NetworkMode2["XDP"] = "xdp";
+  return NetworkMode2;
+})(NetworkMode || {});
+
+// src/client/models/NodeGroup.ts
+var NodeGroup = /* @__PURE__ */ ((NodeGroup2) => {
+  NodeGroup2["METAL"] = "metal";
+  NodeGroup2["CLOUDCHAMBER"] = "cloudchamber";
+  return NodeGroup2;
+})(NodeGroup || {});
+
+// src/client/models/PlacementStatusHealth.ts
+var PlacementStatusHealth = /* @__PURE__ */ ((PlacementStatusHealth2) => {
+  PlacementStatusHealth2["PLACED"] = "placed";
+  PlacementStatusHealth2["STOPPING"] = "stopping";
+  PlacementStatusHealth2["RUNNING"] = "running";
+  PlacementStatusHealth2["FAILED"] = "failed";
+  PlacementStatusHealth2["STOPPED"] = "stopped";
+  PlacementStatusHealth2["UNHEALTHY"] = "unhealthy";
+  return PlacementStatusHealth2;
+})(PlacementStatusHealth || {});
+
+// src/client/models/ProvisionerConfiguration.ts
+var ProvisionerConfiguration;
+((ProvisionerConfiguration2) => {
+  ((type2) => {
+    type2["NONE"] = "none";
+    type2["CLOUDINIT"] = "cloudinit";
+  })(ProvisionerConfiguration2.type || (ProvisionerConfiguration2.type = {}));
+})(ProvisionerConfiguration || (ProvisionerConfiguration = {}));
+
+// src/client/models/RolloutStep.ts
+var RolloutStep;
+((RolloutStep2) => {
+  ((status2) => {
+    status2["PENDING"] = "pending";
+    status2["PROGRESSING"] = "progressing";
+    status2["REVERTING"] = "reverting";
+    status2["COMPLETED"] = "completed";
+    status2["REVERTED"] = "reverted";
+  })(RolloutStep2.status || (RolloutStep2.status = {}));
+})(RolloutStep || (RolloutStep = {}));
+
+// src/client/models/SchedulingPolicy.ts
+var SchedulingPolicy = /* @__PURE__ */ ((SchedulingPolicy2) => {
+  SchedulingPolicy2["DURABLE_OBJECT"] = "durable_object";
+  SchedulingPolicy2["MOON"] = "moon";
+  SchedulingPolicy2["GPU"] = "gpu";
+  SchedulingPolicy2["REGIONAL"] = "regional";
+  SchedulingPolicy2["FILL_METALS"] = "fill_metals";
+  SchedulingPolicy2["DEFAULT"] = "default";
+  return SchedulingPolicy2;
+})(SchedulingPolicy || {});
+
+// src/client/models/SecretAccessType.ts
+var SecretAccessType = /* @__PURE__ */ ((SecretAccessType2) => {
+  SecretAccessType2["ENV"] = "env";
+  return SecretAccessType2;
+})(SecretAccessType || {});
+
+// src/client/models/SecretNameAlreadyExists.ts
+var SecretNameAlreadyExists;
+((SecretNameAlreadyExists2) => {
+  ((error2) => {
+    error2["SECRET_NAME_ALREADY_EXISTS"] = "SECRET_NAME_ALREADY_EXISTS";
+  })(SecretNameAlreadyExists2.error || (SecretNameAlreadyExists2.error = {}));
+})(SecretNameAlreadyExists || (SecretNameAlreadyExists = {}));
+
+// src/client/models/SecretNotFound.ts
+var SecretNotFound;
+((SecretNotFound2) => {
+  ((error2) => {
+    error2["SECRET_NAME_NOT_FOUND"] = "SECRET_NAME_NOT_FOUND";
+  })(SecretNotFound2.error || (SecretNotFound2.error = {}));
+})(SecretNotFound || (SecretNotFound = {}));
+
+// src/client/models/SSHPublicKeyNotFoundError.ts
+var SSHPublicKeyNotFoundError;
+((SSHPublicKeyNotFoundError2) => {
+  ((error2) => {
+    error2["SSH_PUBLIC_KEY_NOT_FOUND"] = "SSH_PUBLIC_KEY_NOT_FOUND";
+  })(SSHPublicKeyNotFoundError2.error || (SSHPublicKeyNotFoundError2.error = {}));
+})(SSHPublicKeyNotFoundError || (SSHPublicKeyNotFoundError = {}));
+
+// src/client/models/UpdateApplicationRolloutRequest.ts
+var UpdateApplicationRolloutRequest;
+((UpdateApplicationRolloutRequest2) => {
+  ((action2) => {
+    action2["NEXT"] = "next";
+    action2["PREVIOUS"] = "previous";
+    action2["REVERT"] = "revert";
+  })(UpdateApplicationRolloutRequest2.action || (UpdateApplicationRolloutRequest2.action = {}));
+})(UpdateApplicationRolloutRequest || (UpdateApplicationRolloutRequest = {}));
+
+// src/client/services/AccountService.ts
+var AccountService = class {
+  static {
+    __name(this, "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() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/me",
+      errors: {
+        401: `Unauthorized`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * Modify account details like defaults
+   * Modify account details like defaults
+   * @param requestBody
+   * @returns CompleteAccountCustomer Complete account for the user
+   * @throws ApiError
+   */
+  static modifyMe(requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/me",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request that contains a specific constant code and details object about the error.`,
+        401: `Unauthorized`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+};
+
+// src/client/services/ApplicationsService.ts
+var ApplicationsService = class {
+  static {
+    __name(this, "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) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/applications",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Could not create the application because of input/limits reasons, more details in the error code`,
+        401: `Unauthorized`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, image, label) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications",
+      query: {
+        name,
+        image,
+        label
+      },
+      errors: {
+        401: `Unauthorized`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * Get a single application by id
+   * Returns a single application by id
+   * @param applicationId
+   * @returns Application A single application
+   * @throws ApiError
+   */
+  static getApplication(applicationId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}",
+      path: {
+        application_id: applicationId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * Modify an application
+   * Modifies a single application by id.
+   * @param applicationId
+   * @param requestBody
+   * @returns Application Modify application response
+   * @throws ApiError
+   */
+  static modifyApplication(applicationId, requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/applications/{application_id}",
+      path: {
+        application_id: applicationId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Could not modify the application because of input/limits reasons, more details in the error code`,
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * Delete a single application by id
+   * Deletes a single application by id
+   * @param applicationId
+   * @returns EmptyResponse Delete application response
+   * @throws ApiError
+   */
+  static deleteApplication(applicationId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/applications/{application_id}",
+      path: {
+        application_id: applicationId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/status",
+      path: {
+        application_id: applicationId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/applications/{application_id}/jobs",
+      path: {
+        application_id: applicationId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Can't create the application job because it has bad inputs`,
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, jobId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/jobs/{job_id}",
+      path: {
+        application_id: applicationId,
+        job_id: jobId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application/Job is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, jobId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/applications/{application_id}/jobs/{job_id}",
+      path: {
+        application_id: applicationId,
+        job_id: jobId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application/Job is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, jobId, requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/applications/{application_id}/jobs/{job_id}",
+      path: {
+        application_id: applicationId,
+        job_id: jobId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Can't modify the application job because it has bad inputs`,
+        401: `Unauthorized`,
+        404: `Response body when an Application/Job is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/applications/{application_id}/rollouts",
+      path: {
+        application_id: applicationId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Can't update the application rollout because it has bad inputs`,
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, limit, last) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/rollouts",
+      path: {
+        application_id: applicationId
+      },
+      query: {
+        limit,
+        last
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, rolloutId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/rollouts/{rollout_id}",
+      path: {
+        application_id: applicationId,
+        rollout_id: rolloutId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, rolloutId, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/applications/{application_id}/rollouts/{rollout_id}",
+      path: {
+        application_id: applicationId,
+        rollout_id: rolloutId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Can't create the application rollout because it has bad inputs`,
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, rolloutId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/applications/{application_id}/rollouts/{rollout_id}",
+      path: {
+        application_id: applicationId,
+        rollout_id: rolloutId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/deployments",
+      path: {
+        application_id: applicationId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, deploymentId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/deployments/{deployment_id}",
+      path: {
+        application_id: applicationId,
+        deployment_id: deploymentId
+      },
+      errors: {
+        400: `Unknown account`,
+        401: `Unauthorized`,
+        404: `Deployment not found`,
+        500: `Deployment Get Error`
+      }
+    });
+  }
+  /**
+   * 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, deploymentId, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/applications/{application_id}/deployments/{deployment_id}/recreate",
+      path: {
+        application_id: applicationId,
+        deployment_id: deploymentId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Could not create the deployment because of input/limits reasons, more details in the error code`,
+        401: `Unauthorized`,
+        404: `Deployment not found`,
+        500: `Deployment Creation Error`
+      }
+    });
+  }
+  /**
+   * 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, pageToken) {
+    return requestPaginated(OpenAPI, {
+      method: "GET",
+      url: "/dash/applications",
+      query: {
+        per_page: perPage,
+        page_token: pageToken
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, perPage, pageToken) {
+    return requestPaginated(OpenAPI, {
+      method: "GET",
+      url: "/dash/applications/{application_id}/instances",
+      path: {
+        application_id: applicationId
+      },
+      query: {
+        per_page: perPage,
+        page_token: pageToken
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Application not found`,
+        500: `Internal error`
+      }
+    });
+  }
+};
+
+// src/client/services/ContainerImagePreparationsService.ts
+var ContainerImagePreparationsService = class {
+  static {
+    __name(this, "ContainerImagePreparationsService");
+  }
+  /**
+   * Prepare a digest-pinned managed image for the Containers runtime.
+   */
+  static prepareContainerImage(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/image-preparations",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `The image is invalid or does not exist in this account`,
+        401: `Unauthorized`,
+        403: `Container image preparation is not enabled for this account`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+};
+
+// src/client/services/DeploymentsService.ts
+var DeploymentsService = class {
+  static {
+    __name(this, "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, deploymentId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/deployments/{deployment_id}",
+      path: {
+        application_id: applicationId,
+        deployment_id: deploymentId
+      },
+      errors: {
+        400: `Unknown account`,
+        401: `Unauthorized`,
+        404: `Deployment not found`,
+        500: `Deployment Get Error`
+      }
+    });
+  }
+  /**
+   * 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, deploymentId, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/applications/{application_id}/deployments/{deployment_id}/recreate",
+      path: {
+        application_id: applicationId,
+        deployment_id: deploymentId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Could not create the deployment because of input/limits reasons, more details in the error code`,
+        401: `Unauthorized`,
+        404: `Deployment not found`,
+        500: `Deployment Creation Error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/instances/{instance_id}/ssh",
+      path: {
+        instance_id: instanceId
+      },
+      errors: {
+        400: `Unknown account`,
+        401: `Unauthorized`,
+        404: `Deployment not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/deployments/v2",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Could not create the deployment because of input/limits reasons, more details in the error code`,
+        401: `Unauthorized`,
+        409: `Deployment already exists`,
+        500: `Deployment Creation Error`
+      }
+    });
+  }
+  /**
+   * 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, location, image, state, ipv4, label) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/deployments/v2",
+      query: {
+        app_id: appId,
+        location,
+        image,
+        state,
+        ipv4,
+        label
+      },
+      errors: {
+        400: `Unknown account`,
+        401: `Unauthorized`,
+        500: `Deployment List Error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/deployments/{deployment_id}/v2",
+      path: {
+        deployment_id: deploymentId
+      },
+      errors: {
+        400: `Unknown account`,
+        401: `Unauthorized`,
+        404: `Deployment not found`,
+        500: `Deployment Get Error`
+      }
+    });
+  }
+  /**
+   * Modify an existing deployment
+   * Change specific properties in an existing deployment
+   * @param deploymentId
+   * @param requestBody
+   * @returns DeploymentV2 Deployment modified
+   * @throws ApiError
+   */
+  static modifyDeploymentV2(deploymentId, requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/deployments/{deployment_id}/v2",
+      path: {
+        deployment_id: deploymentId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Can't modify the deployment because it surpasses limits or it has bad input`,
+        401: `Unauthorized`,
+        404: `Deployment not found`,
+        500: `Deployment Modification Error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/deployments/{deployment_id}/v2",
+      path: {
+        deployment_id: deploymentId
+      },
+      errors: {
+        400: `Unknown account`,
+        401: `Unauthorized`,
+        404: `Deployment not found`,
+        500: `Deployment Delete Error`
+      }
+    });
+  }
+  /**
+   * 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, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/deployments/{deployment_id}/recreate",
+      path: {
+        deployment_id: deploymentId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Could not create the deployment because of input/limits reasons, more details in the error code`,
+        401: `Unauthorized`,
+        404: `Deployment not found`,
+        500: `Deployment Creation Error`
+      }
+    });
+  }
+  /**
+   * 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, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/placements/{placement_id}",
+      path: {
+        placement_id: placementId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Responses with 400 status code`,
+        401: `Unauthorized`,
+        404: `Placement not found`,
+        500: `Deployment Replacement Error`
+      }
+    });
+  }
+};
+
+// src/client/services/ImageRegistriesService.ts
+var ImageRegistriesService = class {
+  static {
+    __name(this, "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) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/registries/protos",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request that contains a specific constant code and details object about the error.`,
+        403: `The registry that is being added is not allowed`,
+        409: `Image registry protocol already exists`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * List all image registry protocols.
+   * @returns ImageRegistryProtocols The image registry protocols in the account
+   * @throws ApiError
+   */
+  static listImageRegistryProtocols() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/registries/protos",
+      errors: {
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/registries/protos",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request that contains a specific constant code and details object about the error.`,
+        403: `The registry that is being added is not allowed`,
+        404: `Image registry protocol doesn't exist`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/registries/protos/{proto}",
+      path: {
+        proto
+      },
+      errors: {
+        400: `The image registry protocol couldn't be deleted because it's referenced by a deployment or application`,
+        404: `Image registry protocol doesn't exist`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/registries/{domain}/credentials",
+      path: {
+        domain
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request that contains a specific constant code and details object about the error.`,
+        404: `The image registry does not exist`,
+        409: `The registry was configured as public, so credentials can not be generated`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/registries/{domain}",
+      path: {
+        domain
+      },
+      errors: {
+        404: `The image registry does not exist`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/registries",
+      errors: {
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/registries",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Image registry input is malformed, see the error details`,
+        403: `The registry that is being added is not allowed`,
+        409: `The image registry already exists in the account`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+};
+
+// src/client/services/IPsService.ts
+var IPsService = class {
+  static {
+    __name(this, "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, allocated, ipType, deploymentId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/ips",
+      query: {
+        placement_id: placementId,
+        allocated,
+        ipType,
+        deployment_id: deploymentId
+      },
+      errors: {
+        400: `Unknown account`,
+        401: `Unauthorized`
+      }
+    });
+  }
+};
+
+// src/client/services/JobsService.ts
+var JobsService = class {
+  static {
+    __name(this, "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) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/status",
+      path: {
+        application_id: applicationId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/applications/{application_id}/jobs",
+      path: {
+        application_id: applicationId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Can't create the application job because it has bad inputs`,
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, jobId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/jobs/{job_id}",
+      path: {
+        application_id: applicationId,
+        job_id: jobId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application/Job is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, jobId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/applications/{application_id}/jobs/{job_id}",
+      path: {
+        application_id: applicationId,
+        job_id: jobId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application/Job is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, jobId, requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/applications/{application_id}/jobs/{job_id}",
+      path: {
+        application_id: applicationId,
+        job_id: jobId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Can't modify the application job because it has bad inputs`,
+        401: `Unauthorized`,
+        404: `Response body when an Application/Job is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+};
+
+// src/client/services/PlacementsService.ts
+var PlacementsService = class {
+  static {
+    __name(this, "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) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/deployments/{deployment_id}/placements",
+      path: {
+        deployment_id: deploymentId
+      },
+      errors: {
+        400: `Unknown account`,
+        401: `Unauthorized`,
+        404: `Deployment not found`,
+        500: `List Placements Error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/placements/{placement_id}",
+      path: {
+        placement_id: placementId
+      },
+      errors: {
+        400: `Unknown account`,
+        401: `Unauthorized`,
+        404: `Placement not found`,
+        500: `Get Placement Error`
+      }
+    });
+  }
+  /**
+   * 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, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/placements/{placement_id}",
+      path: {
+        placement_id: placementId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Responses with 400 status code`,
+        401: `Unauthorized`,
+        404: `Placement not found`,
+        500: `Deployment Replacement Error`
+      }
+    });
+  }
+};
+
+// src/client/services/RolloutsService.ts
+var RolloutsService = class {
+  static {
+    __name(this, "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, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/applications/{application_id}/rollouts",
+      path: {
+        application_id: applicationId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Can't update the application rollout because it has bad inputs`,
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, limit, last) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/rollouts",
+      path: {
+        application_id: applicationId
+      },
+      query: {
+        limit,
+        last
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, rolloutId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/applications/{application_id}/rollouts/{rollout_id}",
+      path: {
+        application_id: applicationId,
+        rollout_id: rolloutId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, rolloutId, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/applications/{application_id}/rollouts/{rollout_id}",
+      path: {
+        application_id: applicationId,
+        rollout_id: rolloutId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Can't create the application rollout because it has bad inputs`,
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * 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, rolloutId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/applications/{application_id}/rollouts/{rollout_id}",
+      path: {
+        application_id: applicationId,
+        rollout_id: rolloutId
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when an Application is not found`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+};
+
+// src/client/services/SecretsService.ts
+var SecretsService = class {
+  static {
+    __name(this, "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) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/secrets",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        409: `Secret with this name already exists in this account`,
+        500: `Generic error response`
+      }
+    });
+  }
+  /**
+   * List Secrets
+   * List all secrets in an account with metadata
+   * @returns ListSecretsMetadata List Secrets response
+   * @throws ApiError
+   */
+  static listSecrets() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/secrets",
+      errors: {
+        500: `Generic error response`
+      }
+    });
+  }
+  /**
+   * Get secret metadata
+   * Get secret metadata by name
+   * @param secretName
+   * @returns SecretMetadata Get secret response
+   * @throws ApiError
+   */
+  static getSecret(secretName) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/secrets/{secretName}",
+      path: {
+        secretName
+      },
+      errors: {
+        404: `Secret not found error`,
+        500: `Generic error response`
+      }
+    });
+  }
+  /**
+   * 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, requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/secrets/{secretName}",
+      path: {
+        secretName
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        404: `Secret not found error`,
+        500: `Generic error response`
+      }
+    });
+  }
+  /**
+   * Delete an existing secret
+   * Delete a secret within an account.
+   * @param secretName
+   * @returns GenericMessageResponse Generic OK response
+   * @throws ApiError
+   */
+  static deleteSecret(secretName) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/secrets/{secretName}",
+      path: {
+        secretName
+      },
+      errors: {
+        404: `Secret not found error`,
+        500: `Generic error response`
+      }
+    });
+  }
+};
+
+// src/client/services/SshPublicKeysService.ts
+var SshPublicKeysService = class {
+  static {
+    __name(this, "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) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/ssh-public-keys",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Unauthorized`,
+        500: `Create SSH Public key error`
+      }
+    });
+  }
+  /**
+   * List SSH Public keys
+   * List all SSH Public keys in an account
+   * @returns ListSSHPublicKeys List SSH Public keys response
+   * @throws ApiError
+   */
+  static listSshPublicKeys() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/ssh-public-keys",
+      errors: {
+        401: `Unauthorized`,
+        500: `List SSH Public keys error`
+      }
+    });
+  }
+  /**
+   * 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) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/ssh-public-keys/{sshPublicKeyName}",
+      path: {
+        sshPublicKeyName
+      },
+      errors: {
+        401: `Unauthorized`,
+        404: `Response body when the SSH public key that is trying to be found does not exist`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+};
+
+// src/context.ts
+var noop = /* @__PURE__ */ __name(() => {
+}, "noop");
+var logger = {
+  debug: noop,
+  log: noop,
+  info: noop,
+  warn: noop,
+  error: noop
+};
+var fetchResult = /* @__PURE__ */ __name(() => {
+  throw new Error("initContainersSharedContext() must be called first");
+}, "fetchResult");
+var fetchPagedListResult = /* @__PURE__ */ __name(() => {
+  throw new Error("initContainersSharedContext() must be called first");
+}, "fetchPagedListResult");
+function initContainersSharedContext(ctx) {
+  logger = ctx.logger;
+  fetchResult = ctx.fetchResult;
+  if (ctx.fetchPagedListResult !== void 0) {
+    fetchPagedListResult = ctx.fetchPagedListResult;
+  }
+}
+__name(initContainersSharedContext, "initContainersSharedContext");
+
+// src/registry.ts
+var getCloudflareRegistryWithAccountNamespace = /* @__PURE__ */ __name((accountID, tag, complianceConfig) => {
+  return `${getCloudflareContainerRegistry(complianceConfig)}/${accountID}/${tag}`;
+}, "getCloudflareRegistryWithAccountNamespace");
+var MF_DEV_CONTAINER_PREFIX = "cloudflare-dev";
+
+// src/knobs.ts
+function getCloudflareContainerRegistry(complianceConfig = COMPLIANCE_REGION_CONFIG_UNKNOWN) {
+  if (process.env.CLOUDFLARE_CONTAINER_REGISTRY) {
+    return process.env.CLOUDFLARE_CONTAINER_REGISTRY;
+  }
+  const environmentPrefix = process.env.WRANGLER_API_ENVIRONMENT === "staging" ? "staging." : "";
+  const complianceRegionSubdomain = getComplianceRegionSubdomain(complianceConfig);
+  return `${environmentPrefix}registry${complianceRegionSubdomain}.cloudflare.com`;
+}
+__name(getCloudflareContainerRegistry, "getCloudflareContainerRegistry");
+var getDevContainerImageName = /* @__PURE__ */ __name((name, tag) => {
+  return `${MF_DEV_CONTAINER_PREFIX}/${name.toLowerCase()}:${tag}`;
+}, "getDevContainerImageName");
+var FUSE_CONTAINER_PRIVILEGES = {
+  capabilities: ["SYS_ADMIN"],
+  devices: [
+    {
+      pathOnHost: "/dev/fuse",
+      pathInContainer: "/dev/fuse",
+      cgroupPermissions: "rwm"
+    }
+  ],
+  securityOpt: ["apparmor:unconfined"]
+};
+function configureOpenAPIForContainerPull(accountId, apiToken, apiBase = "https://api.cloudflare.com/client/v4") {
+  OpenAPI.BASE = `${apiBase}/accounts/${accountId}/containers`;
+  OpenAPI.CREDENTIALS = "omit";
+  const existingHeaders = typeof OpenAPI.HEADERS === "object" ? OpenAPI.HEADERS : {};
+  OpenAPI.HEADERS = {
+    ...existingHeaders,
+    Authorization: `Bearer ${apiToken}`
+  };
+}
+__name(configureOpenAPIForContainerPull, "configureOpenAPIForContainerPull");
+async function dockerLoginImageRegistry(pathToDocker, domain) {
+  const expirationMinutes = 15;
+  const credentials = await ImageRegistriesService.generateImageRegistryCredentials(domain, {
+    expiration_minutes: expirationMinutes,
+    permissions: [
+      "push" /* PUSH */,
+      "pull" /* PULL */
+    ]
+  });
+  const child = spawn(
+    pathToDocker,
+    ["login", "--password-stdin", "--username", credentials.username, domain],
+    { stdio: ["pipe", "inherit", "inherit"] }
+  ).on("error", (err) => {
+    throw err;
+  });
+  child.stdin.write(credentials.password);
+  child.stdin.end();
+  await new Promise((resolve2, reject) => {
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(
+          new UserError(`Login failed with code: ${code}`, {
+            telemetryMessage: false
+          })
+        );
+      }
+    });
+  });
+}
+__name(dockerLoginImageRegistry, "dockerLoginImageRegistry");
+async function dockerImageInspect(dockerPath, options) {
+  return new Promise((resolve2, reject) => {
+    const proc = spawn(
+      dockerPath,
+      ["image", "inspect", options.imageTag, "--format", options.formatString],
+      {
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => stdout += chunk);
+    proc.stderr.on("data", (chunk) => stderr += chunk);
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        return reject(
+          new UserError(`failed inspecting image locally: ${stderr.trim()}`, {
+            telemetryMessage: false
+          })
+        );
+      }
+      resolve2(stdout.trim());
+    });
+    proc.on("error", (err) => reject(err));
+  });
+}
+__name(dockerImageInspect, "dockerImageInspect");
+
+// src/utils.ts
+var runDockerCmd = /* @__PURE__ */ __name((dockerPath, args, stdio) => {
+  let aborted = false;
+  let resolve2;
+  let reject;
+  const ready = new Promise((res, rej) => {
+    resolve2 = res;
+    reject = rej;
+  });
+  const child = spawn(dockerPath, args, {
+    stdio: stdio ?? "inherit",
+    // We need to set detached to true so that the child process
+    // will control all of its child processes and we can kill
+    // all of them in case we need to abort the build process.
+    // On Windows, detached: true opens a new console window per child
+    // process, so we only set it on non-Windows platforms.
+    detached: process.platform !== "win32",
+    // Prevent child processes from opening visible console windows on Windows.
+    // This is a no-op on non-Windows platforms.
+    windowsHide: true
+  });
+  let errorHandled = false;
+  child.on("close", (code) => {
+    if (code === 0 || aborted) {
+      resolve2({ aborted });
+    } else if (!errorHandled) {
+      errorHandled = true;
+      reject(
+        new UserError(`Docker command exited with code: ${code}`, {
+          telemetryMessage: false
+        })
+      );
+    }
+  });
+  child.on("error", (err) => {
+    if (!errorHandled) {
+      errorHandled = true;
+      reject(
+        new UserError(`Docker command failed: ${err.message}`, {
+          telemetryMessage: false
+        })
+      );
+    }
+  });
+  return {
+    abort: /* @__PURE__ */ __name(() => {
+      aborted = true;
+      child.unref();
+      if (child.pid !== void 0) {
+        if (process.platform === "win32") {
+          child.kill();
+        } else {
+          process.kill(-child.pid);
+        }
+      }
+    }, "abort"),
+    ready,
+    then: /* @__PURE__ */ __name(async (onResolve, onReject) => ready.then(onResolve).catch(onReject), "then")
+  };
+}, "runDockerCmd");
+var runDockerCmdWithOutput = /* @__PURE__ */ __name((dockerPath, args) => {
+  try {
+    const stdout = execFileSync(dockerPath, args, { encoding: "utf8" });
+    return stdout.trim();
+  } catch (error) {
+    throw new UserError(
+      `Failed running docker command: ${error.message}. Command: ${dockerPath} ${args.join(" ")}`,
+      { telemetryMessage: false }
+    );
+  }
+}, "runDockerCmdWithOutput");
+async function containerPrivilegesAllowed(dockerHost, dockerPath = "docker") {
+  const platform = process.platform;
+  if (!isLocalDockerEndpoint(dockerHost) || platform !== "darwin" && platform !== "linux") {
+    return false;
+  }
+  const securityOptions = await getDockerSecurityOptions(
+    dockerPath,
+    dockerHost
+  );
+  const rootless = Array.isArray(securityOptions) && securityOptions.some(
+    (option) => option === "name=rootless" || option === "rootless"
+  );
+  const localVm = platform === "darwin" || platform === "linux" && detectWsl();
+  const localRootlessLinux = platform === "linux" && existsSync("/dev/fuse") && rootless;
+  return localVm || localRootlessLinux;
+}
+__name(containerPrivilegesAllowed, "containerPrivilegesAllowed");
+function isLocalDockerEndpoint(dockerHost) {
+  try {
+    const url = new URL(dockerHost);
+    return url.protocol === "unix:" && url.hostname === "" && url.pathname.startsWith("/");
+  } catch {
+    return false;
+  }
+}
+__name(isLocalDockerEndpoint, "isLocalDockerEndpoint");
+async function getDockerSecurityOptions(dockerPath, dockerHost) {
+  const output = await new Promise((resolve2, reject) => {
+    execFile(
+      dockerPath,
+      ["--host", dockerHost, "info", "--format", "{{json .SecurityOptions}}"],
+      { encoding: "utf8", timeout: 5e3 },
+      (error, stdout) => {
+        if (error === null) {
+          resolve2(stdout);
+        } else {
+          reject(error);
+        }
+      }
+    );
+  });
+  return JSON.parse(output);
+}
+__name(getDockerSecurityOptions, "getDockerSecurityOptions");
+function detectWsl() {
+  return process.platform === "linux" && release().toLowerCase().includes("microsoft");
+}
+__name(detectWsl, "detectWsl");
+var isDockerRunning = /* @__PURE__ */ __name(async (dockerPath) => {
+  try {
+    await runDockerCmd(dockerPath, ["info"], ["inherit", "pipe", "pipe"]);
+  } catch {
+    return false;
+  }
+  return true;
+}, "isDockerRunning");
+var verifyDockerInstalled = /* @__PURE__ */ __name(async ({
+  dockerPath,
+  operation,
+  imageNoun,
+  hint
+}) => {
+  const dockerIsRunning = await isDockerRunning(dockerPath);
+  if (!dockerIsRunning) {
+    throw new UserError(
+      getFailedToRunDockerErrorMessage({
+        operation,
+        imageNoun,
+        hint
+      }),
+      {
+        telemetryMessage: false
+      }
+    );
+  }
+}, "verifyDockerInstalled");
+function getFailedToRunDockerErrorMessage({
+  operation,
+  imageNoun,
+  hint
+}) {
+  const beforeOperation = operation ? ` before ${operation}` : "";
+  const headline = `The Docker CLI is needed to build ${imageNoun}${beforeOperation} but could not be launched.`;
+  let daemonHint;
+  if (process.platform === "darwin") {
+    daemonHint = "open the Docker Desktop app or run `open -a Docker`";
+  } else if (process.platform === "win32") {
+    daemonHint = "open the Docker Desktop app";
+  } else {
+    daemonHint = "run `sudo systemctl start docker`";
+  }
+  const steps = `To fix this, try the following:
+  - If Docker is not installed, download it from https://docs.docker.com/get-started/get-docker/
+  - If Docker is installed but the daemon is not running,
+    ${daemonHint}.
+  - If you use an alternative Docker-compatible CLI (e.g. Podman),
+    set the WRANGLER_DOCKER_BIN environment variable to its path and DOCKER_HOST to its socket.`;
+  const alternatives = "Note: Other container tooling that is compatible with the Docker CLI and engine may work, but is not yet guaranteed to do so.";
+  let message = `${headline}
+${steps}
+
+${alternatives}`;
+  if (hint) {
+    message += `
+
+${hint}`;
+  }
+  return message;
+}
+__name(getFailedToRunDockerErrorMessage, "getFailedToRunDockerErrorMessage");
+var cleanupContainers = /* @__PURE__ */ __name((dockerPath, imageTags) => {
+  try {
+    const containerIds = getContainerIdsByImageTags(dockerPath, imageTags);
+    if (containerIds.length === 0) {
+      return true;
+    }
+    runDockerCmdWithOutput(dockerPath, ["rm", "--force", ...containerIds]);
+    return true;
+  } catch {
+    return false;
+  }
+}, "cleanupContainers");
+function getContainerIdsByImageTags(dockerPath, imageTags) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const imageTag of imageTags) {
+    const containerIdsFromImage = getContainerIdsFromImage(
+      dockerPath,
+      imageTag
+    );
+    containerIdsFromImage.forEach((id) => ids.add(id));
+  }
+  return Array.from(ids);
+}
+__name(getContainerIdsByImageTags, "getContainerIdsByImageTags");
+var getContainerIdsFromImage = /* @__PURE__ */ __name((dockerPath, ancestorImage) => {
+  const output = runDockerCmdWithOutput(dockerPath, [
+    "ps",
+    "-a",
+    "--filter",
+    `ancestor=${ancestorImage}`,
+    "--format",
+    "{{.ID}}"
+  ]);
+  return output.split("\n").filter((line) => line.trim());
+}, "getContainerIdsFromImage");
+async function checkExposedPorts(dockerPath, options) {
+  const output = await dockerImageInspect(dockerPath, {
+    imageTag: options.image_tag,
+    formatString: "{{ len .Config.ExposedPorts }}"
+  });
+  if (output === "0") {
+    throw new UserError(
+      `The container "${options.class_name}" does not expose any ports. In your Dockerfile, please expose any ports you intend to connect to.
+For additional information please see: https://developers.cloudflare.com/containers/local-dev/#exposing-ports.
+`,
+      { telemetryMessage: false }
+    );
+  }
+}
+__name(checkExposedPorts, "checkExposedPorts");
+function generateContainerBuildId() {
+  return randomUUID().slice(0, 8);
+}
+__name(generateContainerBuildId, "generateContainerBuildId");
+function getDockerSocketFromContext(dockerPath) {
+  try {
+    const output = runDockerCmdWithOutput(dockerPath, [
+      "context",
+      "ls",
+      "--format",
+      "json"
+    ]);
+    const lines = output.trim().split("\n");
+    const contexts = lines.map((line) => JSON.parse(line));
+    const currentContext = contexts.find((context) => context.Current === true);
+    if (currentContext && currentContext.DockerEndpoint) {
+      return currentContext.DockerEndpoint;
+    }
+  } catch {
+  }
+  return null;
+}
+__name(getDockerSocketFromContext, "getDockerSocketFromContext");
+function resolveDockerHost(dockerPath) {
+  if (process.env.WRANGLER_DOCKER_HOST) {
+    return process.env.WRANGLER_DOCKER_HOST;
+  }
+  if (process.env.DOCKER_HOST) {
+    return process.env.DOCKER_HOST;
+  }
+  const contextSocket = getDockerSocketFromContext(dockerPath);
+  if (contextSocket) {
+    return contextSocket;
+  }
+  return process.platform === "win32" ? "//./pipe/docker_engine" : "unix:///var/run/docker.sock";
+}
+__name(resolveDockerHost, "resolveDockerHost");
+var getDockerHostFromEnv = /* @__PURE__ */ __name(() => {
+  const fromEnv = process.env.WRANGLER_DOCKER_HOST ?? process.env.DOCKER_HOST;
+  return fromEnv ?? process.platform === "win32" ? "//./pipe/docker_engine" : "unix:///var/run/docker.sock";
+}, "getDockerHostFromEnv");
+async function getImageRepoTags(dockerPath, imageTag) {
+  try {
+    const output = await dockerImageInspect(dockerPath, {
+      imageTag,
+      formatString: "{{ range .RepoTags }}{{ . }}\n{{ end }}"
+    });
+    return output.split("\n").filter((tag) => tag.trim() !== "");
+  } catch {
+    return [];
+  }
+}
+__name(getImageRepoTags, "getImageRepoTags");
+async function cleanupDuplicateImageTags(dockerPath, imageTag) {
+  try {
+    const repoTags = await getImageRepoTags(dockerPath, imageTag);
+    const currentBuildId = getImageTag(imageTag);
+    const tagsToRemove = repoTags.filter(
+      (tag) => tag.startsWith("cloudflare-dev") && getImageTag(tag) !== currentBuildId
+    );
+    if (tagsToRemove.length > 0) {
+      runDockerCmdWithOutput(dockerPath, ["rmi", ...tagsToRemove]);
+    }
+  } catch {
+  }
+}
+__name(cleanupDuplicateImageTags, "cleanupDuplicateImageTags");
+function getImageTag(imageTag) {
+  const tagSeparatorIndex = imageTag.lastIndexOf(":");
+  return tagSeparatorIndex === -1 ? void 0 : imageTag.slice(tagSeparatorIndex + 1);
+}
+__name(getImageTag, "getImageTag");
+
+// src/images.ts
+var DEFAULT_CONTAINER_EGRESS_INTERCEPTOR_IMAGE = "cloudflare/proxy-everything:3cb1195@sha256:0ef6716c52430096900b150d84a3302057d6cd2319dae7987128c85d0733e3c8";
+function getEgressInterceptorPlatform() {
+  return process.env.MINIFLARE_CONTAINER_EGRESS_IMAGE_PLATFORM;
+}
+__name(getEgressInterceptorPlatform, "getEgressInterceptorPlatform");
+function getEgressInterceptorImage() {
+  return process.env.MINIFLARE_CONTAINER_EGRESS_IMAGE ?? DEFAULT_CONTAINER_EGRESS_INTERCEPTOR_IMAGE;
+}
+__name(getEgressInterceptorImage, "getEgressInterceptorImage");
+async function pullEgressInterceptorImage(dockerPath) {
+  const image = getEgressInterceptorImage();
+  const platform = getEgressInterceptorPlatform();
+  const args = ["pull", image];
+  if (platform !== void 0) {
+    args.push("--platform", platform);
+  }
+  await runDockerCmd(dockerPath, args);
+}
+__name(pullEgressInterceptorImage, "pullEgressInterceptorImage");
+async function pullImage(dockerPath, options, logger2, complianceConfig) {
+  const domain = new URL(`http://${options.image_uri}`).hostname;
+  const isExternalRegistry = domain !== getCloudflareContainerRegistry(complianceConfig);
+  try {
+    await dockerLoginImageRegistry(dockerPath, domain);
+  } catch (e) {
+    if (!isExternalRegistry) {
+      throw e;
+    }
+    logger2?.warn(
+      "Unable to retrieve configured registry credentials from Cloudflare.\nUnless this is a public image, you will need to run `wrangler containers registries configure` before deploying.\nAttempting to pull image anyway..."
+    );
+  }
+  const pull = runDockerCmd(dockerPath, [
+    "pull",
+    options.image_uri,
+    // All containers running on our platform need to be built for amd64 architecture, but by default docker pull seems to look for an image matching the host system, so we need to specify this here
+    "--platform",
+    "linux/amd64"
+  ]);
+  const ready = pull.ready.then(async ({ aborted }) => {
+    if (!aborted) {
+      await runDockerCmd(dockerPath, [
+        "tag",
+        options.image_uri,
+        options.image_tag
+      ]);
+    }
+  });
+  return {
+    abort: /* @__PURE__ */ __name(() => {
+      pull.abort();
+    }, "abort"),
+    ready
+  };
+}
+__name(pullImage, "pullImage");
+async function prepareContainerImagesForDev(args) {
+  const {
+    dockerPath,
+    containerOptions,
+    onContainerImagePreparationStart,
+    onContainerImagePreparationEnd
+  } = args;
+  let aborted = false;
+  if (process.platform === "win32") {
+    throw new UserError(
+      "Local development with containers is currently not supported on Windows. You should use WSL instead. You can also set `enable_containers` to false if you do not need to develop the container part of your application.",
+      { telemetryMessage: false }
+    );
+  }
+  await verifyDockerInstalled({
+    dockerPath,
+    operation: "running dev",
+    imageNoun: containerOptions.length !== 1 ? "the configured images" : "the configured image",
+    hint: "To suppress this error if you do not intend on triggering any container instances, set dev.enable_containers to false in your Wrangler config or pass --enable-containers=false."
+  });
+  for (const options of containerOptions) {
+    if ("dockerfile" in options) {
+      const build = await startContainerBuild({
+        pathToDocker: dockerPath,
+        verifyDockerIsRunning: false,
+        build: {
+          tag: options.image_tag,
+          pathToDockerfile: options.dockerfile,
+          buildContext: options.image_build_context,
+          args: options.image_vars,
+          platform: "linux/amd64"
+        }
+      });
+      onContainerImagePreparationStart({
+        containerOptions: options,
+        abort: /* @__PURE__ */ __name(() => {
+          aborted = true;
+          build.abort();
+        }, "abort")
+      });
+      await build.ready;
+      onContainerImagePreparationEnd({
+        containerOptions: options
+      });
+    } else {
+      const pull = await pullImage(
+        dockerPath,
+        options,
+        args.logger,
+        args.complianceConfig
+      );
+      onContainerImagePreparationStart({
+        containerOptions: options,
+        abort: /* @__PURE__ */ __name(() => {
+          aborted = true;
+          pull.abort();
+        }, "abort")
+      });
+      await pull.ready;
+      onContainerImagePreparationEnd({
+        containerOptions: options
+      });
+    }
+    if (!aborted) {
+      await cleanupDuplicateImageTags(dockerPath, options.image_tag);
+      await checkExposedPorts(dockerPath, options);
+    }
+  }
+  if (!aborted) {
+    await pullEgressInterceptorImage(dockerPath);
+  }
+}
+__name(prepareContainerImagesForDev, "prepareContainerImagesForDev");
+function resolveImageName(accountId, image, complianceConfig) {
+  let url;
+  try {
+    url = new URL(`http://${image}`);
+  } catch {
+  }
+  if (url === void 0 || !url.host.match(/[:.]/) && url.hostname !== "localhost") {
+    return getCloudflareRegistryWithAccountNamespace(
+      accountId,
+      image,
+      complianceConfig
+    );
+  }
+  if (url.hostname !== getCloudflareContainerRegistry(complianceConfig)) {
+    return image;
+  }
+  if (url.pathname.startsWith(`/${accountId}`)) {
+    return image;
+  }
+  const accountIdPattern = /^\/([a-f0-9]{32})\//;
+  const match = accountIdPattern.exec(url.pathname);
+  if (match) {
+    const foundAccountId = match[1];
+    if (foundAccountId !== accountId) {
+      throw new Error(
+        `Image "${image}" does not belong to your account
+Image appears to belong to account: "${foundAccountId}"
+Current account: "${accountId}"`
+      );
+    }
+    return image;
+  }
+  return `${url.hostname}/${accountId}${url.pathname}`;
+}
+__name(resolveImageName, "resolveImageName");
+var getAndValidateRegistryType = /* @__PURE__ */ __name((domain, complianceConfig) => {
+  if (domain.includes("://")) {
+    throw new Error(
+      `${domain} is invalid:
+Image reference should not include the protocol part (e.g: registry.cloudflare.com rather than https://registry.cloudflare.com)`
+    );
+  }
+  let url;
+  try {
+    url = new URL(`http://${domain}`);
+  } catch (e) {
+    if (e instanceof Error) {
+      throw new Error(`${domain} is invalid:
+${e.message}`);
+    }
+    throw e;
+  }
+  const acceptedRegistries = [
+    {
+      type: "ECR" /* ECR */,
+      pattern: /^[0-9]{12}\.dkr\.ecr\.[a-z0-9-]+\.amazonaws\.com$/,
+      name: "AWS ECR",
+      secretType: "AWS Secret Access Key"
+    },
+    {
+      type: "DockerHub" /* DOCKER_HUB */,
+      pattern: /^docker\.io$/,
+      name: "DockerHub",
+      secretType: "DockerHub PAT Token"
+    },
+    {
+      type: "GAR" /* GAR */,
+      pattern: /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?-docker\.pkg\.dev$/,
+      name: "Google Artifact Registry",
+      secretType: "Google Service Account JSON Key"
+    },
+    {
+      type: "cloudflare",
+      pattern: new RegExp(
+        `^${getCloudflareContainerRegistry(complianceConfig).replace(/[\\.]/g, "\\$&")}$`
+      ),
+      name: "Cloudflare Containers Managed Registry"
+    }
+  ];
+  const match = acceptedRegistries.find(
+    (registry) => registry.pattern.test(url.hostname)
+  );
+  if (!match) {
+    const supportedRegistries = acceptedRegistries.filter((r) => r.type !== "cloudflare").map((r) => r.name).join(", ");
+    throw new UserError(
+      `${url.hostname} is not a supported image registry.
+Currently we support the following non-Cloudflare registries: ${supportedRegistries}.
+To use an existing image from another repository, see https://developers.cloudflare.com/containers/platform-details/image-management/#using-pre-built-container-images`,
+      { telemetryMessage: false }
+    );
+  }
+  return match;
+}, "getAndValidateRegistryType");
+function invalidGarCredentialError() {
+  return new UserError(
+    "The Google service account key must be a JSON key file or its base64-encoded form.",
+    {
+      telemetryMessage: "containers registries configure invalid gar credential"
+    }
+  );
+}
+__name(invalidGarCredentialError, "invalidGarCredentialError");
+function tryParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+__name(tryParseJson, "tryParseJson");
+function assertJsonObject(parsed) {
+  if (typeof parsed !== "object" || parsed === null) {
+    throw invalidGarCredentialError();
+  }
+  return parsed;
+}
+__name(assertJsonObject, "assertJsonObject");
+function validateServiceAccountKey(accountKey) {
+  const privateKey = accountKey.private_key;
+  const clientEmail = accountKey.client_email;
+  const rawPrivateKeyId = accountKey.private_key_id;
+  if (typeof privateKey !== "string" || typeof clientEmail !== "string") {
+    throw new UserError(
+      "The Google service account key is missing required fields (private_key, client_email).",
+      {
+        telemetryMessage: "containers registries configure gar credential missing fields"
+      }
+    );
+  }
+  if (privateKey.length === 0 || clientEmail.length === 0) {
+    throw new UserError(
+      "The Google service account key has an empty private_key or client_email.",
+      {
+        telemetryMessage: "containers registries configure gar credential empty fields"
+      }
+    );
+  }
+  let privateKeyId;
+  if (rawPrivateKeyId === void 0) {
+    privateKeyId = void 0;
+  } else if (typeof rawPrivateKeyId === "string" && rawPrivateKeyId.length > 0) {
+    privateKeyId = rawPrivateKeyId;
+  } else {
+    throw new UserError(
+      "The Google service account key has an empty or invalid private_key_id.",
+      {
+        telemetryMessage: "containers registries configure gar credential invalid private key id"
+      }
+    );
+  }
+  return {
+    private_key: privateKey,
+    client_email: clientEmail,
+    private_key_id: privateKeyId
+  };
+}
+__name(validateServiceAccountKey, "validateServiceAccountKey");
+function validateAndEncodeGarKey(rawKey, expectedEmail) {
+  const trimmed = rawKey.trim();
+  let base64Key;
+  let json;
+  const rawJson = tryParseJson(trimmed);
+  if (rawJson !== void 0) {
+    json = assertJsonObject(rawJson);
+    base64Key = Buffer.from(trimmed, "utf8").toString("base64");
+  } else {
+    if (trimmed.startsWith("-----BEGIN")) {
+      throw new UserError(
+        "The provided key appears to be a PEM private key. Provide the full Google service-account JSON key file, not just the private key.",
+        {
+          telemetryMessage: "containers registries configure gar credential pem key"
+        }
+      );
+    }
+    base64Key = trimmed.replace(/\s+/g, "");
+    const decodedJson = tryParseJson(
+      Buffer.from(base64Key, "base64").toString("utf8")
+    );
+    if (decodedJson === void 0) {
+      throw invalidGarCredentialError();
+    }
+    json = assertJsonObject(decodedJson);
+  }
+  const key = validateServiceAccountKey(json);
+  if (key.client_email !== expectedEmail) {
+    throw new UserError(
+      `The provided --gar-email "${expectedEmail}" does not match the service account email "${key.client_email}" in the key.`,
+      {
+        telemetryMessage: "containers registries configure gar email mismatch"
+      }
+    );
+  }
+  return base64Key;
+}
+__name(validateAndEncodeGarKey, "validateAndEncodeGarKey");
+var MB = 1e3 * 1e3;
+var MiB = 1024 * 1024;
+var instanceTypes = {
+  // lite is the default instance type when REQUIRE_INSTANCE_TYPE is set
+  lite: {
+    vcpu: 0.0625,
+    memory_mib: 256,
+    disk_mb: 2e3
+  },
+  dev: {
+    vcpu: 0.0625,
+    memory_mib: 256,
+    disk_mb: 2e3
+  },
+  basic: {
+    vcpu: 0.25,
+    memory_mib: 1024,
+    disk_mb: 4e3
+  },
+  standard: {
+    vcpu: 0.5,
+    memory_mib: 4096,
+    disk_mb: 8e3
+  },
+  "standard-1": {
+    vcpu: 0.5,
+    memory_mib: 4096,
+    disk_mb: 8e3
+  },
+  "standard-2": {
+    vcpu: 1,
+    memory_mib: 6144,
+    disk_mb: 12e3
+  },
+  "standard-3": {
+    vcpu: 2,
+    memory_mib: 8192,
+    disk_mb: 16e3
+  },
+  "standard-4": {
+    vcpu: 4,
+    memory_mib: 12288,
+    disk_mb: 2e4
+  }
+};
+var LEGACY_TO_CANONICAL = {
+  dev: "lite" /* LITE */,
+  standard: "standard-1" /* STANDARD_1 */
+};
+function configToUsage(containerConfig) {
+  if ("instance_type" in containerConfig) {
+    return getInstanceTypeUsage(containerConfig.instance_type);
+  }
+  return {
+    vcpu: containerConfig.vcpu,
+    memory_mib: containerConfig.memory_mib,
+    disk_mb: containerConfig.disk_bytes / MB
+  };
+}
+__name(configToUsage, "configToUsage");
+function accountToLimits(account) {
+  return {
+    vcpu: account.limits.vcpu_per_deployment,
+    memory_mib: account.limits.memory_mib_per_deployment,
+    disk_mb: account.limits.disk_mb_per_deployment
+  };
+}
+__name(accountToLimits, "accountToLimits");
+function getInstanceTypeUsage(instanceType) {
+  return instanceTypes[instanceType];
+}
+__name(getInstanceTypeUsage, "getInstanceTypeUsage");
+function inferInstanceType(config) {
+  for (const [instanceType, configuration] of Object.entries(instanceTypes)) {
+    if (config.vcpu === configuration.vcpu && config.memory_mib === configuration.memory_mib && config.disk?.size_mb === configuration.disk_mb) {
+      const canonical = instanceType in LEGACY_TO_CANONICAL ? LEGACY_TO_CANONICAL[instanceType] : void 0;
+      return canonical ?? instanceType;
+    }
+  }
+}
+__name(inferInstanceType, "inferInstanceType");
+function cleanForInstanceType(app) {
+  if (!("configuration" in app)) {
+    return app;
+  }
+  const instance_type = inferInstanceType(app.configuration);
+  if (instance_type !== void 0) {
+    app.configuration.instance_type = instance_type;
+  }
+  delete app.configuration.disk;
+  delete app.configuration.memory;
+  delete app.configuration.memory_mib;
+  delete app.configuration.vcpu;
+  return app;
+}
+__name(cleanForInstanceType, "cleanForInstanceType");
+async function ensureContainerLimits(options) {
+  const limits = accountToLimits(options.account);
+  if (!options.containerConfig) {
+    await ensureImageFitsLimits({
+      availableSizeInBytes: limits.disk_mb * MB,
+      pathToDocker: options.pathToDocker,
+      imageTag: options.imageTag
+    });
+    return;
+  }
+  const usage = configToUsage(options.containerConfig);
+  const errors = [];
+  if (usage.vcpu > limits.vcpu) {
+    errors.push(
+      `Your container configuration uses ${usage.vcpu} vCPU which exceeds the account limit of ${limits.vcpu} vCPU.`
+    );
+  }
+  if (usage.memory_mib > limits.memory_mib) {
+    errors.push(
+      `Your container configuration uses ${usage.memory_mib} MiB of memory which exceeds the account limit of ${limits.memory_mib} MiB.`
+    );
+  }
+  if (usage.disk_mb > limits.disk_mb) {
+    errors.push(
+      `Your container configuration uses ${usage.disk_mb} MB of disk which exceeds the account limit of ${limits.disk_mb} MB.`
+    );
+  }
+  if (errors.length > 0) {
+    throw new UserError(`Exceeded account limits: ${errors.join(" ")}`, {
+      telemetryMessage: "cloudchamber limits account limit exceeded"
+    });
+  }
+  await ensureImageFitsLimits({
+    availableSizeInBytes: usage.disk_mb * MB,
+    pathToDocker: options.pathToDocker,
+    imageTag: options.imageTag
+  });
+}
+__name(ensureContainerLimits, "ensureContainerLimits");
+async function ensureImageFitsLimits(options) {
+  const inspectOutput = await dockerImageInspect(options.pathToDocker, {
+    imageTag: options.imageTag,
+    formatString: "{{ .Size }} {{ len .RootFS.Layers }}"
+  });
+  const [sizeStr, layerStr] = inspectOutput.split(" ");
+  if (sizeStr === void 0 || layerStr === void 0) {
+    throw new Error(
+      `Expected docker image inspect output to include image size and layer count, got ${inspectOutput}`
+    );
+  }
+  const size = parseInt(sizeStr, 10);
+  const layers = parseInt(layerStr, 10);
+  const requiredSizeInBytes = Math.ceil(size * 1.1 + layers * 16 * MiB);
+  logger.debug(
+    `Disk size limits when building container image: availableSize=${Math.ceil(options.availableSizeInBytes / MB)}MB, requiredSize=${Math.ceil(requiredSizeInBytes / MB)}MB`
+  );
+  if (options.availableSizeInBytes < requiredSizeInBytes) {
+    throw new UserError(
+      `Image too large: needs ${Math.ceil(requiredSizeInBytes / MB)}MB, but your app is limited to images with size ${options.availableSizeInBytes / MB}MB. You need more disk for this image.`,
+      { telemetryMessage: "cloudchamber limits image too large" }
+    );
+  }
+}
+__name(ensureImageFitsLimits, "ensureImageFitsLimits");
+async function getContainerAccount(accountId, complianceConfig) {
+  if (accountId === void 0) {
+    return await AccountService.getMe();
+  }
+  return await fetchResult(
+    complianceConfig ?? {},
+    `/accounts/${accountId}/containers/me`
+  );
+}
+__name(getContainerAccount, "getContainerAccount");
+
+// src/build.ts
+function isDockerfileContainerConfig(container) {
+  return "dockerfile" in container;
+}
+__name(isDockerfileContainerConfig, "isDockerfileContainerConfig");
+async function constructBuildCommand(options) {
+  const platform = options.platform ?? "linux/amd64";
+  const buildCmd = [
+    "build",
+    "--load",
+    "-t",
+    options.tag,
+    "--platform",
+    platform,
+    "--provenance=false"
+  ];
+  if (options.args) {
+    for (const arg in options.args) {
+      buildCmd.push("--build-arg", `${arg}=${options.args[arg]}`);
+    }
+  }
+  if (process.env.WRANGLER_CI_OVERRIDE_NETWORK_MODE_HOST) {
+    buildCmd.push("--network", "host");
+  }
+  const dockerfile = readFileSync(options.pathToDockerfile, "utf-8");
+  buildCmd.push("-f", "-");
+  buildCmd.push(options.buildContext);
+  logger?.debug(`Building image with command: ${buildCmd.join(" ")}`);
+  return { buildCmd, dockerfile };
+}
+__name(constructBuildCommand, "constructBuildCommand");
+async function startContainerBuild({
+  build,
+  pathToDocker,
+  verifyDockerIsRunning
+}) {
+  const { buildCmd, dockerfile } = await constructBuildCommand(build);
+  return await dockerBuild(pathToDocker, {
+    buildCmd,
+    dockerfile,
+    verifyDockerIsRunning
+  });
+}
+__name(startContainerBuild, "startContainerBuild");
+var DIGEST_SUFFIX_REGEXP = /@[A-Za-z][A-Za-z0-9]*(?:[-_+.][A-Za-z][A-Za-z0-9]*)*:[a-fA-F0-9]{32,}$/;
+var DIGEST_VALUE_REGEXP = /^[A-Za-z][A-Za-z0-9]*(?:[-_+.][A-Za-z][A-Za-z0-9]*)*:[a-fA-F0-9]{32,}$/;
+var TAG_SUFFIX_REGEXP = /:[\w][\w.-]{0,127}$/;
+function getRepositoryOnly(externalAccountId, imageTag, complianceConfig) {
+  return resolveImageName(externalAccountId, imageTag, complianceConfig).replace(DIGEST_SUFFIX_REGEXP, "").replace(TAG_SUFFIX_REGEXP, "");
+}
+__name(getRepositoryOnly, "getRepositoryOnly");
+function imageRefWithDigest(externalAccountId, imageTag, digest, complianceConfig) {
+  if (!DIGEST_VALUE_REGEXP.test(digest)) {
+    throw new Error(
+      `Expected image digest to match algorithm:hex format, got ${digest}`
+    );
+  }
+  return `${getRepositoryOnly(externalAccountId, imageTag, complianceConfig)}@${digest}`;
+}
+__name(imageRefWithDigest, "imageRefWithDigest");
+function findManifestDigest(manifestOutput) {
+  const parsedManifest = JSON.parse(manifestOutput);
+  const digest = parsedManifest?.Descriptor?.digest;
+  if (typeof digest !== "string" || digest.length === 0) {
+    throw new Error(
+      `Expected docker manifest inspect output to include Descriptor.digest, got ${manifestOutput}`
+    );
+  }
+  return digest;
+}
+__name(findManifestDigest, "findManifestDigest");
+function findRemoteDigest(repoDigestsJson, externalAccountId, imageTag, complianceConfig) {
+  const parsedDigests = JSON.parse(repoDigestsJson);
+  if (!Array.isArray(parsedDigests)) {
+    throw new Error(
+      `Expected RepoDigests from docker inspect to be an array but got ${JSON.stringify(parsedDigests)}`
+    );
+  }
+  const repositoryOnly = getRepositoryOnly(
+    externalAccountId,
+    imageTag,
+    complianceConfig
+  );
+  logger.debug("respositoryOnly:", repositoryOnly);
+  const digest = parsedDigests.find((d) => {
+    if (typeof d !== "string" || !d.includes("@")) {
+      return false;
+    }
+    const resolved = resolveImageName(externalAccountId, d, complianceConfig);
+    logger.debug(`Comparing ${resolved.split("@")[0]} to ${repositoryOnly}`);
+    return resolved.split("@")[0] === repositoryOnly;
+  });
+  if (!digest) {
+    throw new Error(
+      `Could not find a digest for the image ${repositoryOnly}. Found digests: ${parsedDigests.join(", ")}`
+    );
+  }
+  const [, hash] = digest.split("@");
+  assertString(hash, `Expected digest "${digest}" to include a hash`);
+  return imageRefWithDigest(
+    externalAccountId,
+    imageTag,
+    hash,
+    complianceConfig
+  );
+}
+__name(findRemoteDigest, "findRemoteDigest");
+function assertString(value, message) {
+  if (value === void 0) {
+    throw new Error(message);
+  }
+}
+__name(assertString, "assertString");
+async function tagAndPushImage({
+  pathToDocker,
+  sourceTag,
+  targetTag,
+  externalAccountId,
+  complianceConfig,
+  cleanupSourceTag
+}) {
+  const namespacedImageTag = resolveImageName(
+    externalAccountId,
+    targetTag,
+    complianceConfig
+  );
+  await runDockerCmd(pathToDocker, ["tag", sourceTag, namespacedImageTag]);
+  if (cleanupSourceTag) {
+    logger.debug(`Untagging built image: ${sourceTag}.`);
+    await runDockerCmd(pathToDocker, ["image", "rm", sourceTag]);
+  }
+  await runDockerCmd(pathToDocker, ["push", namespacedImageTag]);
+  return namespacedImageTag;
+}
+__name(tagAndPushImage, "tagAndPushImage");
+async function pushImageIfChanged({
+  pathToDocker,
+  sourceTag,
+  targetTag,
+  containerConfig,
+  accountId,
+  complianceConfig,
+  cleanupSourceTag
+}) {
+  const imageInfo = await dockerImageInspect(pathToDocker, {
+    imageTag: sourceTag,
+    formatString: "{{ json .RepoDigests }}"
+  });
+  logger.debug(`'docker image inspect ${sourceTag}':`, imageInfo);
+  const account = await getContainerAccount(accountId, complianceConfig);
+  await ensureContainerLimits({
+    pathToDocker,
+    imageTag: sourceTag,
+    account,
+    containerConfig
+  });
+  await dockerLoginImageRegistry(
+    pathToDocker,
+    // Won't be an external registry since this is building from a Dockerfile
+    // rather than specifying an image URI.
+    getCloudflareContainerRegistry(complianceConfig)
+  );
+  try {
+    const remoteDigest2 = findRemoteDigest(
+      imageInfo,
+      account.external_account_id,
+      targetTag,
+      complianceConfig
+    );
+    const [, hash] = remoteDigest2.split("@");
+    logger.debug(
+      `'docker manifest inspect -v ${resolveImageName(account.external_account_id, remoteDigest2, complianceConfig)}:`
+    );
+    const remoteManifest = runDockerCmdWithOutput(pathToDocker, [
+      "manifest",
+      "inspect",
+      "-v",
+      resolveImageName(
+        account.external_account_id,
+        remoteDigest2,
+        complianceConfig
+      )
+    ]);
+    const parsedRemoteManifest = JSON.parse(remoteManifest);
+    if (parsedRemoteManifest.Descriptor.digest === hash) {
+      logger.log("Image already exists remotely, skipping push");
+      logger.debug(
+        `Untagging built image: ${sourceTag} since there was no change.`
+      );
+      await runDockerCmd(pathToDocker, ["image", "rm", sourceTag]);
+      return { remoteDigest: remoteDigest2 };
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.debug(
+        `Checking for local image ${sourceTag} failed with error: ${error.message}`
+      );
+    }
+  }
+  logger.log(
+    `Image does not exist remotely, pushing: ${resolveImageName(
+      account.external_account_id,
+      targetTag,
+      complianceConfig
+    )}`
+  );
+  const namespacedImageTag = await tagAndPushImage({
+    pathToDocker,
+    sourceTag,
+    targetTag,
+    externalAccountId: account.external_account_id,
+    complianceConfig,
+    cleanupSourceTag
+  });
+  let remoteDigest;
+  try {
+    const pushedImageInfo = await dockerImageInspect(pathToDocker, {
+      imageTag: namespacedImageTag,
+      formatString: "{{ json .RepoDigests }}"
+    });
+    remoteDigest = findRemoteDigest(
+      pushedImageInfo,
+      account.external_account_id,
+      namespacedImageTag,
+      complianceConfig
+    );
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.debug(
+        `Inspecting pushed image ${namespacedImageTag} failed with error: ${error.message}`
+      );
+    }
+    const remoteManifest = runDockerCmdWithOutput(pathToDocker, [
+      "manifest",
+      "inspect",
+      "-v",
+      namespacedImageTag
+    ]);
+    remoteDigest = imageRefWithDigest(
+      account.external_account_id,
+      namespacedImageTag,
+      findManifestDigest(remoteManifest),
+      complianceConfig
+    );
+  }
+  return { remoteDigest };
+}
+__name(pushImageIfChanged, "pushImageIfChanged");
+async function buildCommand(args, complianceConfig) {
+  if (existsSync(args.PATH) && !isDirectory(args.PATH)) {
+    throw new UserError(
+      `${args.PATH} is not a directory. Please specify a valid directory path.`,
+      { telemetryMessage: "container build invalid path" }
+    );
+  }
+  if (args.platform !== void 0 && args.platform !== "linux/amd64") {
+    throw new UserError(
+      `Unsupported platform: Platform "${args.platform}" is unsupported. Please use "linux/amd64" instead.`,
+      { telemetryMessage: "container build unsupported platform" }
+    );
+  }
+  const pathToDockerfile = join(args.PATH, "Dockerfile");
+  const pathToDocker = args.pathToDocker ?? getDockerPath();
+  try {
+    const build = await startContainerBuild({
+      pathToDocker,
+      build: {
+        tag: args.tag,
+        pathToDockerfile,
+        buildContext: args.PATH,
+        platform: args.platform
+        // No option to add env vars at build time...?
+      }
+    });
+    await build.ready;
+    if (args.push) {
+      await pushImageIfChanged({
+        pathToDocker,
+        sourceTag: args.tag,
+        targetTag: args.tag,
+        complianceConfig
+      });
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new UserError(error.message, {
+        cause: error,
+        telemetryMessage: "container build image operation failed"
+      });
+    }
+    throw new UserError("An unknown error occurred", {
+      telemetryMessage: "container build unknown error"
+    });
+  }
+}
+__name(buildCommand, "buildCommand");
+async function pushCommand(args, accountId, complianceConfig) {
+  try {
+    const dockerPath = args.pathToDocker ?? getDockerPath();
+    await dockerLoginImageRegistry(
+      dockerPath,
+      getCloudflareContainerRegistry(complianceConfig)
+    );
+    await checkImagePlatform(dockerPath, args.TAG);
+    const newTag = await tagAndPushImage({
+      pathToDocker: dockerPath,
+      sourceTag: args.TAG,
+      targetTag: args.TAG,
+      externalAccountId: accountId,
+      complianceConfig
+    });
+    logger.log(`Pushed image: ${newTag}`);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new UserError(error.message, {
+        telemetryMessage: "container push failed"
+      });
+    }
+    throw new UserError("An unknown error occurred", {
+      telemetryMessage: "container push unknown error"
+    });
+  }
+}
+__name(pushCommand, "pushCommand");
+async function checkImagePlatform(pathToDocker, imageTag, expectedPlatform = "linux/amd64") {
+  const platform = await dockerImageInspect(pathToDocker, {
+    imageTag,
+    formatString: "{{ .Os }}/{{ .Architecture }}"
+  });
+  if (platform !== expectedPlatform) {
+    throw new Error(
+      `Unsupported platform: Image platform (${platform}) does not match the expected platform (${expectedPlatform})`
+    );
+  }
+}
+__name(checkImagePlatform, "checkImagePlatform");
+async function buildAndMaybePush(args, pathToDocker, push, containerConfig, verifyDockerIsRunning, complianceConfig) {
+  try {
+    const build = await startContainerBuild({
+      pathToDocker,
+      verifyDockerIsRunning,
+      build: args
+    });
+    await build.ready;
+    if (!push) {
+      return { newTag: args.tag };
+    }
+    return await pushImageIfChanged({
+      pathToDocker,
+      sourceTag: args.tag,
+      targetTag: args.tag,
+      containerConfig,
+      complianceConfig,
+      cleanupSourceTag: true
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new UserError(error.message, {
+        cause: error,
+        telemetryMessage: "container build image operation failed"
+      });
+    }
+    throw new UserError("An unknown error occurred", {
+      telemetryMessage: "container build unknown error"
+    });
+  }
+}
+__name(buildAndMaybePush, "buildAndMaybePush");
+async function buildContainerImage(containerConfig, pathToDocker, verifyDockerIsRunning) {
+  const localTag = `${getContainerImageRepositoryName(
+    containerConfig
+  )}:wrangler-${crypto.randomUUID()}`;
+  logger.log("Building image", localTag);
+  try {
+    const build = await startContainerBuild({
+      pathToDocker,
+      verifyDockerIsRunning,
+      build: {
+        tag: localTag,
+        pathToDockerfile: containerConfig.dockerfile,
+        buildContext: containerConfig.image_build_context,
+        args: containerConfig.image_vars
+      }
+    });
+    await build.ready;
+    return { container: containerConfig, localTag };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new UserError(error.message, {
+        cause: error,
+        telemetryMessage: "container build image operation failed"
+      });
+    }
+    throw new UserError("An unknown error occurred", {
+      telemetryMessage: "container build unknown error"
+    });
+  }
+}
+__name(buildContainerImage, "buildContainerImage");
+async function buildContainerImages(containers, pathToDocker, verifyDockerIsRunning) {
+  const builtImages = [];
+  try {
+    for (const container of containers.filter(isDockerfileContainerConfig)) {
+      builtImages.push(
+        await buildContainerImage(
+          container,
+          pathToDocker,
+          verifyDockerIsRunning
+        )
+      );
+    }
+  } catch (error) {
+    await cleanupBuiltImages(builtImages, pathToDocker);
+    throw error;
+  }
+  return builtImages;
+}
+__name(buildContainerImages, "buildContainerImages");
+async function pushBuiltContainerImage(builtImage, versionId, pathToDocker, accountId, complianceConfig) {
+  try {
+    const imageRef = await pushImageIfChanged({
+      pathToDocker,
+      sourceTag: builtImage.localTag,
+      targetTag: getContainerImageTag(builtImage.container, versionId),
+      containerConfig: builtImage.container,
+      accountId,
+      complianceConfig,
+      cleanupSourceTag: true
+    });
+    builtImage.localTagCleaned = true;
+    return imageRef;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new UserError(error.message, {
+        cause: error,
+        telemetryMessage: "container build image operation failed"
+      });
+    }
+    throw new UserError("An unknown error occurred", {
+      telemetryMessage: "container build unknown error"
+    });
+  }
+}
+__name(pushBuiltContainerImage, "pushBuiltContainerImage");
+async function cleanupBuiltImages(builtImages, pathToDocker) {
+  for (const builtImage of builtImages) {
+    if (builtImage.localTagCleaned) {
+      continue;
+    }
+    try {
+      logger.debug(`Untagging built image: ${builtImage.localTag}.`);
+      await runDockerCmd(pathToDocker, ["image", "rm", builtImage.localTag]);
+      builtImage.localTagCleaned = true;
+    } catch (error) {
+      if (error instanceof Error) {
+        logger.debug(
+          `Cleaning up built image ${builtImage.localTag} failed with error: ${error.message}`
+        );
+      }
+    }
+  }
+}
+__name(cleanupBuiltImages, "cleanupBuiltImages");
+function getContainerImageTag(containerConfig, imageTag) {
+  return `${getContainerImageRepositoryName(containerConfig)}:${imageTag.split("-")[0]}`;
+}
+__name(getContainerImageTag, "getContainerImageTag");
+function getContainerImageRepositoryName(containerConfig) {
+  return containerConfig.name.toLowerCase();
+}
+__name(getContainerImageRepositoryName, "getContainerImageRepositoryName");
+async function dockerBuild(dockerPath, options) {
+  if (options.verifyDockerIsRunning !== false) {
+    await verifyDockerInstalled({
+      dockerPath,
+      imageNoun: "the image"
+    });
+  }
+  let errorHandled = false;
+  let resolve2;
+  let reject;
+  const ready = new Promise((res, rej) => {
+    resolve2 = res;
+    reject = rej;
+  });
+  const child = spawn(dockerPath, options.buildCmd, {
+    stdio: ["pipe", "inherit", "inherit"],
+    // We need to set detached to true so that the child process
+    // will control all of its child processes and we can kill
+    // all of them in case we need to abort the build process.
+    // On Windows, detached: true opens a new console window per child
+    // process, so we only set it on non-Windows platforms.
+    detached: process.platform !== "win32",
+    // Prevent child processes from opening visible console windows on Windows.
+    // This is a no-op on non-Windows platforms.
+    windowsHide: true
+  });
+  if (child.stdin !== null) {
+    child.stdin.write(options.dockerfile);
+    child.stdin.end();
+  }
+  child.on("exit", (code) => {
+    if (code === 0) {
+      resolve2();
+    } else if (!errorHandled) {
+      errorHandled = true;
+      reject(
+        new UserError(`Docker build exited with code: ${code}`, {
+          telemetryMessage: false
+        })
+      );
+    }
+  });
+  child.on("error", (err) => {
+    if (!errorHandled) {
+      errorHandled = true;
+      reject(err);
+    }
+  });
+  return {
+    abort: /* @__PURE__ */ __name(() => {
+      child.unref();
+      if (child.pid !== void 0) {
+        if (process.platform === "win32") {
+          child.kill();
+        } else {
+          process.kill(-child.pid);
+        }
+      }
+    }, "abort"),
+    ready
+  };
+}
+__name(dockerBuild, "dockerBuild");
+var Diff = class {
+  static {
+    __name(this, "Diff");
+  }
+  #results = [];
+  get changes() {
+    return this.#results.filter((r) => r.added || r.removed).length;
+  }
+  constructor(a, b) {
+    const oldString = tokenize(a);
+    const newString = tokenize(b);
+    const newLen = newString.length;
+    const oldLen = oldString.length;
+    let editLength = 1;
+    const bestPath = [
+      { oldPos: -1, lastComponent: void 0 }
+    ];
+    const initialPath = bestPath[0];
+    if (initialPath === void 0) {
+      throw new Error("unreachable");
+    }
+    let newPos = this.#extractCommon(initialPath, newString, oldString, 0);
+    if (initialPath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      this.#results = this.#buildValues(
+        initialPath.lastComponent,
+        newString,
+        oldString,
+        false
+      );
+      return;
+    }
+    let minDiagonalToConsider = -Infinity;
+    let maxDiagonalToConsider = Infinity;
+    let done = false;
+    while (!done) {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1];
+        const addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (addPath && (!canRemove || canAdd && (removePath?.oldPos ?? 0) < (addPath?.oldPos ?? 0))) {
+          basePath = this.#addToPath(addPath, true, false, 0);
+        } else if (removePath) {
+          basePath = this.#addToPath(removePath, false, true, 1);
+        } else {
+          throw new Error("unreachable");
+        }
+        newPos = this.#extractCommon(
+          basePath,
+          newString,
+          oldString,
+          diagonalPath
+        );
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          this.#results = this.#buildValues(
+            basePath.lastComponent,
+            newString,
+            oldString,
+            false
+          );
+          done = true;
+          break;
+        }
+        bestPath[diagonalPath] = basePath;
+        if (basePath.oldPos + 1 >= oldLen) {
+          maxDiagonalToConsider = Math.min(
+            maxDiagonalToConsider,
+            diagonalPath - 1
+          );
+        }
+        if (newPos + 1 >= newLen) {
+          minDiagonalToConsider = Math.max(
+            minDiagonalToConsider,
+            diagonalPath + 1
+          );
+        }
+      }
+      editLength++;
+    }
+  }
+  /**
+   * Results but refined to be printed/stringified.
+   *
+   * In particular the results returned here are ordered to try to avoid cases
+   * in which an addition/removal is incorrectly split.
+   *
+   * For example, the standard results can produce something like:
+   * ```
+   *  ...
+   * - "vars": {
+   * + "vars": {},
+   * -   "MY_VAR": "variable set in the dash"
+   * - },
+   *  ...
+   * ```
+   * (notice how the first removal is separated from the last two,
+   * making the diff much less readable).
+   * Such change in the refined results will instead look like:
+   * ```
+   *  ...
+   * + "vars": {},
+   * - "vars": {
+   * -   "MY_VAR": "variable set in the dash"
+   * - },
+   *  ...
+   * ```
+   */
+  get #resultsForPrint() {
+    const results = [
+      ...this.#results.filter((r) => !!r.value && r.value !== "\n")
+    ];
+    const swapLines = /* @__PURE__ */ __name((i, j) => {
+      const current = results[i];
+      const adjacent = results[j];
+      if (current === void 0 || adjacent === void 0) {
+        return;
+      }
+      results[i] = adjacent;
+      results[j] = current;
+    }, "swapLines");
+    const numOfLines = /* @__PURE__ */ __name((str) => str.split("\n").length, "numOfLines");
+    const isLoneResult = /* @__PURE__ */ __name((index, target) => {
+      const currentIdx = index;
+      const adjacentIdx = currentIdx + target;
+      const nextIdx = currentIdx + target + target;
+      const current = results[currentIdx];
+      const adjacent = results[adjacentIdx];
+      const next = results[nextIdx];
+      if (!current || !adjacent || !next) {
+        return false;
+      }
+      const previousIdx = index - target;
+      const isAlternation = /* @__PURE__ */ __name((type) => current[type] === true && results[previousIdx]?.[type] !== current[type] && adjacent[type === "added" ? "removed" : "added"] === true && next[type] === true, "isAlternation");
+      if (!isAlternation("added") && !isAlternation("removed")) {
+        return false;
+      }
+      return numOfLines(current.value ?? "") === 1 && numOfLines(adjacent.value ?? "") === 1 && numOfLines(next.value ?? "") > 1;
+    }, "isLoneResult");
+    for (let i = 0; i < results.length; i++) {
+      if (isLoneResult(i, 1)) {
+        swapLines(i, i + 1);
+        continue;
+      }
+      if (isLoneResult(i, -1)) {
+        swapLines(i, i - 1);
+        continue;
+      }
+    }
+    return results;
+  }
+  toString(options = {
+    contextLines: 3
+  }) {
+    let output = "";
+    let state = "init";
+    const context = [];
+    for (const result of this.#resultsForPrint) {
+      if (result.value === void 0) {
+        continue;
+      }
+      if (result.added || result.removed) {
+        if (state === "diff") {
+          context.splice(0, options.contextLines).filter(Boolean).forEach((c) => {
+            output += `  ${c}
+`;
+          });
+          if (context.length > options.contextLines) {
+            output += "\n  ...\n\n";
+          }
+        }
+        context.splice(0, context.length - options.contextLines);
+        if (state === "init") {
+          while (context[0]?.trim() === "") {
+            context.shift();
+          }
+        }
+        context.filter(Boolean).forEach((c) => {
+          output += `  ${c}
+`;
+        });
+        context.length = 0;
+        for (const l of result.value.split("\n")) {
+          if (l) {
+            output += `${result.added ? green("+") : red("-")} ${l}
+`;
+          }
+        }
+        state = "diff";
+      } else {
+        const lines = result.value.replace(/^\n|\n$/g, "").split("\n");
+        context.push(...lines);
+      }
+    }
+    if (state === "diff") {
+      context.splice(options.contextLines);
+      while (context[context.length - 1]?.trim() === "") {
+        context.pop();
+      }
+      context.filter(Boolean).forEach((c) => {
+        output += `  ${c}
+`;
+      });
+    }
+    return output.replace(/\n$/, "");
+  }
+  print(options = {
+    contextLines: 3
+  }) {
+    log(this.toString(options));
+  }
+  #addToPath(path, added, removed, oldPosInc) {
+    const last = path.lastComponent;
+    if (last && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: {
+          count: last.count + 1,
+          added,
+          removed,
+          previousComponent: last.previousComponent
+        }
+      };
+    }
+    return {
+      oldPos: path.oldPos + oldPosInc,
+      lastComponent: {
+        count: 1,
+        added,
+        removed,
+        previousComponent: last
+      }
+    };
+  }
+  #extractCommon(basePath, newString, oldString, diagonalPath) {
+    const newLen = newString.length;
+    const oldLen = oldString.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && oldString[oldPos + 1] === newString[newPos + 1]) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+    }
+    if (commonCount) {
+      basePath.lastComponent = {
+        count: commonCount,
+        previousComponent: basePath.lastComponent,
+        added: false,
+        removed: false
+      };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  #buildValues(lastComponent, newString, oldString, useLongestToken) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (component === void 0) {
+        throw new Error("unreachable");
+      }
+      if (!component.removed) {
+        if (!component.added && useLongestToken) {
+          let value = newString.slice(newPos, newPos + component.count);
+          value = value.map((el, i) => {
+            const oldValue = oldString[oldPos + i];
+            if (oldValue !== void 0 && oldValue.length > el.length) {
+              return oldValue;
+            }
+            return el;
+          });
+          component.value = value.join("");
+        } else {
+          component.value = newString.slice(newPos, newPos + component.count).join("");
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = oldString.slice(oldPos, oldPos + component.count).join("");
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+function tokenize(value) {
+  const retLines = [];
+  const linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (line !== void 0) {
+      retLines.push(line);
+    }
+  }
+  return retLines.filter((s) => s !== "");
+}
+__name(tokenize, "tokenize");
+
+// src/object.ts
+function stripUndefined(r) {
+  for (const k in r) {
+    if (r[k] === void 0) {
+      delete r[k];
+    }
+  }
+  return r;
+}
+__name(stripUndefined, "stripUndefined");
+function sortObjectKeys(unordered) {
+  if (Array.isArray(unordered)) {
+    return unordered;
+  }
+  return Object.keys(unordered).sort().reduce(
+    (obj, key) => {
+      obj[key] = unordered[key];
+      return obj;
+    },
+    {}
+  );
+}
+__name(sortObjectKeys, "sortObjectKeys");
+function sortObjectRecursive(object) {
+  if (typeof object !== "object") {
+    return object;
+  }
+  if (Array.isArray(object)) {
+    return object.map((obj) => sortObjectRecursive(obj));
+  }
+  const objectCopy = { ...object };
+  for (const [key, value] of Object.entries(object)) {
+    if (typeof value === "object") {
+      if (value === null) {
+        continue;
+      }
+      objectCopy[key] = sortObjectRecursive(
+        value
+      );
+    }
+  }
+  return sortObjectKeys(objectCopy);
+}
+__name(sortObjectRecursive, "sortObjectRecursive");
+async function promiseSpinner(promise, {
+  message
+} = {
+  message: "Loading"
+}) {
+  if (process.env.CI || !process.stdin.isTTY) {
+    return promise;
+  }
+  const { start, stop } = spinner();
+  start(message);
+  const t = await promise.catch((err) => {
+    stop();
+    throw err;
+  });
+  stop();
+  return t;
+}
+__name(promiseSpinner, "promiseSpinner");
+
+// src/deploy.ts
+function createDurableObjectNamespaceResolver(config, { versionId, accountId, scriptName, dispatchNamespace }) {
+  const boundDOs = new Set(
+    config.durable_objects.bindings.map((binding) => binding.class_name)
+  );
+  let maybeVersionInfo;
+  let maybeAllDurableObjects;
+  return async (className) => {
+    if (boundDOs.has(className) && dispatchNamespace === void 0) {
+      maybeVersionInfo ??= await fetchUploadedVersion(
+        config,
+        accountId,
+        scriptName,
+        versionId
+      );
+      const targetDurableObject2 = maybeVersionInfo.resources.bindings.find(
+        (binding) => binding.type === "durable_object_namespace" && binding.class_name === className && (binding.script_name === void 0 || binding.script_name === scriptName) && binding.namespace_id !== void 0
+      );
+      if (!targetDurableObject2?.namespace_id) {
+        throw new UserError(
+          "Could not deploy container configuration as durable object was not found in list of bindings",
+          {
+            telemetryMessage: "containers deploy durable object binding missing"
+          }
+        );
+      }
+      return targetDurableObject2.namespace_id;
+    }
+    maybeAllDurableObjects ??= await listDurableObjects(config, accountId);
+    const targetDurableObject = maybeAllDurableObjects.find(
+      (durableObject) => durableObject.class === className && durableObject.script === scriptName && durableObject.preview === void 0 && durableObject.dispatch_namespace === dispatchNamespace
+    );
+    if (!targetDurableObject) {
+      throw new UserError(
+        "Could not deploy container configuration as durable object was not found in the account namespace list",
+        {
+          telemetryMessage: "containers deploy durable object namespace missing"
+        }
+      );
+    }
+    return targetDurableObject.id;
+  };
+}
+__name(createDurableObjectNamespaceResolver, "createDurableObjectNamespaceResolver");
+async function deployContainers(config, containerDeployments, { versionId, accountId, scriptName, dispatchNamespace }) {
+  const resolveNamespaceId = createDurableObjectNamespaceResolver(config, {
+    versionId,
+    accountId,
+    scriptName,
+    dispatchNamespace
+  });
+  for (const { container, imageRef } of containerDeployments) {
+    const namespaceId = await resolveNamespaceId(container.class_name);
+    await apply(
+      {
+        imageRef,
+        durable_object_namespace_id: namespaceId
+      },
+      container,
+      config,
+      accountId
+    );
+  }
+}
+__name(deployContainers, "deployContainers");
+async function fetchUploadedVersion(config, accountId, scriptName, versionId) {
+  for (let attempt = 0; attempt < 5; attempt++) {
+    try {
+      return await fetchResult(
+        config,
+        `/accounts/${accountId}/workers/scripts/${scriptName}/versions/${versionId}`
+      );
+    } catch (error) {
+      if (!isUploadedVersionNotReadyError(error) || attempt === 4) {
+        throw error;
+      }
+      await setTimeout(500);
+    }
+  }
+  throw new Error("Unable to fetch uploaded Worker version");
+}
+__name(fetchUploadedVersion, "fetchUploadedVersion");
+function isUploadedVersionNotReadyError(error) {
+  return error instanceof Error && "code" in error && error.code === 100146;
+}
+__name(isUploadedVersionNotReadyError, "isUploadedVersionNotReadyError");
+async function listDurableObjects(complianceConfig, accountId) {
+  return await fetchPagedListResult(
+    complianceConfig,
+    `/accounts/${accountId}/workers/durable_objects/namespaces`,
+    {},
+    new URLSearchParams({ per_page: "1000" })
+  );
+}
+__name(listDurableObjects, "listDurableObjects");
+function mergeDeep(target, source) {
+  if (typeof target !== "object" || target === null) {
+    return source;
+  }
+  if (typeof source !== "object" || source === null) {
+    return target;
+  }
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+    if (isObject(tgtVal) && isObject(srcVal)) {
+      result[key] = mergeDeep(tgtVal, srcVal);
+    } else {
+      result[key] = srcVal;
+    }
+  }
+  return result;
+}
+__name(mergeDeep, "mergeDeep");
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObject, "isObject");
+function createApplicationToModifyApplication(req) {
+  return {
+    configuration: req.configuration,
+    observability: req.observability,
+    max_instances: req.max_instances,
+    constraints: req.constraints,
+    affinities: req.affinities,
+    scheduling_policy: req.scheduling_policy,
+    rollout_active_grace_period: req.rollout_active_grace_period
+  };
+}
+__name(createApplicationToModifyApplication, "createApplicationToModifyApplication");
+function isLegacyObservabilityEnabled(observability) {
+  return observability?.logs?.enabled === true;
+}
+__name(isLegacyObservabilityEnabled, "isLegacyObservabilityEnabled");
+function hasLegacyRolloutObservabilityEnabled(app) {
+  return isLegacyObservabilityEnabled(app?.configuration.observability) || isLegacyObservabilityEnabled(
+    app?.scheduling_hint?.target.configuration.observability
+  );
+}
+__name(hasLegacyRolloutObservabilityEnabled, "hasLegacyRolloutObservabilityEnabled");
+function getLatestLegacyObservabilityState(app) {
+  return app?.scheduling_hint?.target.configuration.observability ?? app?.configuration.observability;
+}
+__name(getLatestLegacyObservabilityState, "getLatestLegacyObservabilityState");
+function usesTopLevelObservability(app) {
+  return app?.observability !== void 0;
+}
+__name(usesTopLevelObservability, "usesTopLevelObservability");
+function hasTopLevelOnlyObservabilityFields(observability) {
+  return observability.target_instance_percentage !== void 0 || observability.target_instance_count !== void 0;
+}
+__name(hasTopLevelOnlyObservabilityFields, "hasTopLevelOnlyObservabilityFields");
+function selectObservabilityWriteTarget(prevApp) {
+  if (prevApp === void 0) {
+    return "top-level";
+  }
+  if (hasLegacyRolloutObservabilityEnabled(prevApp)) {
+    return "configuration";
+  }
+  return "top-level";
+}
+__name(selectObservabilityWriteTarget, "selectObservabilityWriteTarget");
+function hasMixedEnabledObservability(app) {
+  return app.observability?.logs?.enabled === true && isLegacyObservabilityEnabled(app.configuration.observability);
+}
+__name(hasMixedEnabledObservability, "hasMixedEnabledObservability");
+function requiresObservabilityMigration(app, observability) {
+  return hasLegacyRolloutObservabilityEnabled(app) && (app.observability?.logs?.enabled === true || usesTopLevelObservability(app) && observability.logs_enabled);
+}
+__name(requiresObservabilityMigration, "requiresObservabilityMigration");
+function buildLegacyObservabilityMigrationPatch(app) {
+  const observability = app.configuration.observability;
+  assert(observability?.logs?.enabled === true);
+  return { logs: observability.logs };
+}
+__name(buildLegacyObservabilityMigrationPatch, "buildLegacyObservabilityMigrationPatch");
+function migrateLegacyObservabilityState(app, observability) {
+  const configuration = { ...app.configuration };
+  delete configuration.observability;
+  return {
+    ...app,
+    configuration,
+    observability
+  };
+}
+__name(migrateLegacyObservabilityState, "migrateLegacyObservabilityState");
+function buildTopLevelObservability(observability) {
+  return stripUndefined({
+    logs: { enabled: observability.logs_enabled },
+    target_instance_percentage: observability.target_instance_percentage,
+    target_instance_count: observability.target_instance_count
+  });
+}
+__name(buildTopLevelObservability, "buildTopLevelObservability");
+function buildConfigurationObservability(observability) {
+  return {
+    logs: {
+      enabled: observability.logs_enabled
+    }
+  };
+}
+__name(buildConfigurationObservability, "buildConfigurationObservability");
+function isSameApplicationObservability(left, right) {
+  return left?.logs?.enabled === right?.logs?.enabled && left?.target_instance_percentage === right?.target_instance_percentage && left?.target_instance_count === right?.target_instance_count;
+}
+__name(isSameApplicationObservability, "isSameApplicationObservability");
+function buildTopLevelObservabilityPatch(observability, prevApp, writeTarget) {
+  if (writeTarget === "configuration" && !usesTopLevelObservability(prevApp)) {
+    return void 0;
+  }
+  const shouldWriteDisabledTopLevelObservability = prevApp?.observability !== void 0 && (prevApp.observability.logs?.enabled === true || prevApp.observability.target_instance_percentage !== void 0 || prevApp.observability.target_instance_count !== void 0);
+  if (!observability.logs_enabled && !hasTopLevelOnlyObservabilityFields(observability)) {
+    return shouldWriteDisabledTopLevelObservability ? buildTopLevelObservability(observability) : void 0;
+  }
+  const nextObservability = buildTopLevelObservability(observability);
+  return isSameApplicationObservability(
+    nextObservability,
+    prevApp?.observability
+  ) ? void 0 : nextObservability;
+}
+__name(buildTopLevelObservabilityPatch, "buildTopLevelObservabilityPatch");
+function buildConfigurationObservabilityPatch(observability, prevApp) {
+  const latestLegacyLogsEnabled = getLatestLegacyObservabilityState(prevApp)?.logs?.enabled;
+  if (observability.logs_enabled === latestLegacyLogsEnabled) {
+    return void 0;
+  }
+  if (!observability.logs_enabled && latestLegacyLogsEnabled === void 0) {
+    return void 0;
+  }
+  return buildConfigurationObservability(observability);
+}
+__name(buildConfigurationObservabilityPatch, "buildConfigurationObservabilityPatch");
+function buildApplicationObservabilityPatch(observability, writeTarget, prevApp) {
+  const nextTopLevelObservability = buildTopLevelObservabilityPatch(
+    observability,
+    prevApp,
+    writeTarget
+  );
+  if (writeTarget === "configuration") {
+    const nextConfigurationObservability = buildConfigurationObservabilityPatch(
+      observability,
+      prevApp
+    );
+    return {
+      ...nextTopLevelObservability !== void 0 ? { observability: nextTopLevelObservability } : {},
+      ...nextConfigurationObservability !== void 0 ? {
+        configurationObservability: nextConfigurationObservability
+      } : {}
+    };
+  }
+  return nextTopLevelObservability !== void 0 ? { observability: nextTopLevelObservability } : {};
+}
+__name(buildApplicationObservabilityPatch, "buildApplicationObservabilityPatch");
+function assertCanUseApplicationObservabilityTargeting(prevApp, containerConfig) {
+  if (!hasTopLevelOnlyObservabilityFields(containerConfig.observability)) {
+    return;
+  }
+  if (!hasLegacyRolloutObservabilityEnabled(prevApp)) {
+    return;
+  }
+  throw new UserError(
+    `Application-level observability targeting cannot be enabled for container ${containerConfig.name} while it still uses legacy rollout-based observability. Set containers[].observability.enabled = false in your Wrangler config and deploy once, then deploy again with target_instance_percentage or target_instance_count.`,
+    {
+      telemetryMessage: "containers deploy observability migration blocked"
+    }
+  );
+}
+__name(assertCanUseApplicationObservabilityTargeting, "assertCanUseApplicationObservabilityTargeting");
+function hasRolloutDiff(prevApp, nextApp) {
+  const normalizedPrevApp = stripUndefined({ ...prevApp });
+  const normalizedNextApp = stripUndefined({ ...nextApp });
+  delete normalizedPrevApp.observability;
+  delete normalizedNextApp.observability;
+  return JSON.stringify(sortObjectRecursive(normalizedPrevApp)) !== JSON.stringify(sortObjectRecursive(normalizedNextApp));
+}
+__name(hasRolloutDiff, "hasRolloutDiff");
+function containerConfigToCreateRequest(accountId, containerApp, imageRef, durableObjectNamespaceId, complianceConfig, observabilityWriteTarget, prevApp) {
+  const { observability, configurationObservability } = buildApplicationObservabilityPatch(
+    containerApp.observability,
+    observabilityWriteTarget,
+    prevApp
+  );
+  return {
+    name: containerApp.name,
+    scheduling_policy: containerApp.scheduling_policy,
+    ...observability !== void 0 ? { observability } : {},
+    configuration: {
+      // De-sugar image name
+      image: resolveImageName(accountId, imageRef, complianceConfig),
+      // if disk/memory/vcpu is not defined in config, AND instance_type is also not defined, this will already have been defaulted to 'dev'
+      ..."instance_type" in containerApp ? { instance_type: containerApp.instance_type } : {
+        disk: { size_mb: containerApp.disk_bytes / (1e3 * 1e3) },
+        memory_mib: containerApp.memory_mib,
+        vcpu: containerApp.vcpu
+      },
+      ...configurationObservability !== void 0 ? { observability: configurationObservability } : {},
+      wrangler_ssh: containerApp.wrangler_ssh,
+      authorized_keys: containerApp.authorized_keys,
+      trusted_user_ca_keys: containerApp.trusted_user_ca_keys
+    },
+    // deprecated in favour of max_instances
+    instances: 0,
+    max_instances: containerApp.max_instances,
+    constraints: containerApp.constraints,
+    affinities: containerApp.affinities,
+    durable_objects: {
+      namespace_id: durableObjectNamespaceId
+    },
+    rollout_active_grace_period: containerApp.rollout_active_grace_period
+  };
+}
+__name(containerConfigToCreateRequest, "containerConfigToCreateRequest");
+function formatContainerSnippetForDisplay(container, configPath) {
+  const configurationForDisplay = container.configuration === void 0 ? void 0 : Object.fromEntries(
+    Object.entries(container.configuration).map(([key, value]) => [
+      key === "wrangler_ssh" ? "ssh" : key,
+      value
+    ])
+  );
+  const snippet = {
+    containers: [
+      {
+        ...container,
+        configuration: configurationForDisplay
+      }
+    ]
+  };
+  return formatConfigSnippet(snippet, configPath);
+}
+__name(formatContainerSnippetForDisplay, "formatContainerSnippetForDisplay");
+async function apply(args, containerConfig, config, accountId) {
+  if (!config.containers || config.containers.length === 0) {
+    return;
+  }
+  startSection(
+    "Deploy a container application",
+    "deploy changes to your application"
+  );
+  const existingApplications = await promiseSpinner(
+    ApplicationsService.listApplications(),
+    { message: "Loading applications" }
+  );
+  let prevApp = existingApplications.find(
+    (app) => app.name === containerConfig.name
+  );
+  const imageRef = "remoteDigest" in args.imageRef ? args.imageRef.remoteDigest : args.imageRef.newTag;
+  log(dim("Container application changes\n"));
+  let migratedLegacyObservability = false;
+  if (prevApp !== void 0) {
+    if (!prevApp.durable_objects?.namespace_id) {
+      throw new FatalError(
+        "The previous deploy of this container application was not associated with a durable object",
+        {
+          telemetryMessage: "containers deploy previous durable object missing"
+        }
+      );
+    }
+    if (prevApp.durable_objects.namespace_id !== args.durable_object_namespace_id) {
+      throw new UserError(
+        `There is already an application with the name ${containerConfig.name} deployed that is associated with a different durable object namespace (${prevApp.durable_objects.namespace_id}). Either change the container name or delete the existing application first.`,
+        {
+          telemetryMessage: "trying to redeploy container to different durable object"
+        }
+      );
+    }
+    if (containerConfig.rollout_kind !== "none") {
+      if (requiresObservabilityMigration(
+        prevApp,
+        containerConfig.observability
+      ) && (prevApp.active_rollout_id !== void 0 || isLegacyObservabilityEnabled(
+        prevApp.scheduling_hint?.target.configuration.observability
+      ))) {
+        throw new UserError(
+          `Cannot migrate observability configuration for container ${containerConfig.name} while an application rollout is active. Wait for the rollout to finish, then deploy again.`,
+          {
+            telemetryMessage: "containers deploy observability migration rollout active"
+          }
+        );
+      }
+      if (hasMixedEnabledObservability(prevApp)) {
+        const migrationObservability = buildLegacyObservabilityMigrationPatch(prevApp);
+        await doAction({
+          action: "modify",
+          application: { observability: migrationObservability },
+          id: prevApp.id,
+          name: prevApp.name,
+          successMessage: `Migrated observability configuration for ${brandColor(prevApp.name)} (Application ID: ${prevApp.id})`
+        });
+        prevApp = migrateLegacyObservabilityState(
+          prevApp,
+          migrationObservability
+        );
+        migratedLegacyObservability = true;
+      }
+    }
+  }
+  const observabilityWriteTarget = selectObservabilityWriteTarget(prevApp);
+  if (prevApp !== void 0) {
+    assertCanUseApplicationObservabilityTargeting(prevApp, containerConfig);
+  }
+  const appConfig = stripUndefined(
+    mergeIfUnsafe(
+      config,
+      containerConfigToCreateRequest(
+        accountId,
+        containerConfig,
+        imageRef,
+        args.durable_object_namespace_id,
+        config,
+        observabilityWriteTarget,
+        prevApp
+      ),
+      containerConfig.name
+    )
+  );
+  if (prevApp !== void 0 && prevApp !== null) {
+    const normalisedPrevApp = sortObjectRecursive(
+      stripUndefined(
+        cleanApplicationFromAPI(
+          prevApp,
+          containerConfig,
+          accountId,
+          observabilityWriteTarget,
+          config
+        )
+      )
+    );
+    const modifyReq = stripUndefined(
+      mergeIfUnsafe(
+        config,
+        createApplicationToModifyApplication(appConfig),
+        appConfig.name
+      )
+    );
+    const normalizedModifyReq = sortObjectRecursive(modifyReq);
+    const nowContainer = mergeDeep(normalisedPrevApp, normalizedModifyReq);
+    if (normalizedModifyReq.observability !== void 0) {
+      nowContainer.observability = normalizedModifyReq.observability;
+    }
+    const shouldCreateRollout = hasRolloutDiff(normalisedPrevApp, nowContainer);
+    const prev = formatContainerSnippetForDisplay(
+      normalisedPrevApp,
+      config.configPath
+    );
+    const now = formatContainerSnippetForDisplay(
+      nowContainer,
+      config.configPath
+    );
+    const diff = new Diff(prev, now);
+    if (diff.changes === 0) {
+      if (migratedLegacyObservability) {
+        newline();
+        endSection("Applied changes");
+        return;
+      }
+      updateStatus(`no changes ${brandColor(prevApp.name)}`);
+      endSection("No changes to be made");
+      return;
+    }
+    updateStatus(`${brandColor.underline("EDIT")} ${prevApp.name}`, false);
+    newline();
+    diff.print();
+    newline();
+    if (containerConfig.rollout_kind !== "none") {
+      await doAction({
+        action: "modify",
+        application: modifyReq,
+        id: prevApp.id,
+        name: prevApp.name,
+        ...shouldCreateRollout ? {
+          rollout_step_percentage: containerConfig.rollout_step_percentage,
+          rollout_kind: containerConfig.rollout_kind == "full_manual" ? CreateApplicationRolloutRequest.kind.FULL_MANUAL : CreateApplicationRolloutRequest.kind.FULL_AUTO
+        } : {}
+      });
+    } else {
+      log("Skipping application rollout");
+      newline();
+    }
+  } else {
+    updateStatus(bold.underline(green.underline("NEW")) + ` ${appConfig.name}`);
+    const configStr = formatContainerSnippetForDisplay(
+      appConfig,
+      config.configPath
+    );
+    configStr.trimEnd().split("\n").forEach((el) => log(`  ${el}`));
+    newline();
+    await doAction({
+      action: "create",
+      application: appConfig
+    });
+  }
+  newline();
+  endSection("Applied changes");
+}
+__name(apply, "apply");
+function mergeIfUnsafe(fullConfig, containerConfig, name) {
+  const unsafeContainerConfig = fullConfig.containers?.find((original) => {
+    return original.name === name && original.unsafe !== void 0;
+  });
+  if (unsafeContainerConfig) {
+    return mergeDeep(
+      containerConfig,
+      unsafeContainerConfig.unsafe
+    );
+  } else {
+    return containerConfig;
+  }
+}
+__name(mergeIfUnsafe, "mergeIfUnsafe");
+function formatError(err) {
+  try {
+    const maybeError = JSON.parse(err.body.error);
+    if (maybeError.error !== void 0) {
+      const message = [];
+      message.push(`${maybeError.error}`);
+      if (maybeError.details !== void 0 && typeof maybeError.details === "object") {
+        for (const key in maybeError.details) {
+          message.push(`${brandColor(key)} ${maybeError.details[key]}`);
+        }
+      }
+      return message.join("\n");
+    }
+  } catch {
+  }
+  return JSON.stringify(err.body);
+}
+__name(formatError, "formatError");
+var doAction = /* @__PURE__ */ __name(async (action) => {
+  if (action.action === "create") {
+    let application;
+    try {
+      application = await promiseSpinner(
+        ApplicationsService.createApplication(action.application),
+        { message: `Creating "${action.application.name}"` }
+      );
+    } catch (err) {
+      if (!(err instanceof Error)) {
+        throw err;
+      }
+      if (!(err instanceof ApiError)) {
+        throw new FatalError(
+          `Unexpected error creating application: ${err.message}`,
+          { telemetryMessage: "containers deploy create unexpected error" }
+        );
+      }
+      if (err.status === 400) {
+        throw new UserError(
+          `Error creating application due to a misconfiguration:
+${formatError(err)}`,
+          { telemetryMessage: "containers deploy create misconfiguration" }
+        );
+      }
+      throw new UserError(`Error creating application:
+${formatError(err)}`, {
+        telemetryMessage: "containers deploy create request failed"
+      });
+    }
+    success(
+      `Created application ${brandColor(action.application.name)} (Application ID: ${application.id})`,
+      {
+        shape: shapes.bar
+      }
+    );
+  }
+  if (action.action === "modify") {
+    try {
+      await promiseSpinner(
+        ApplicationsService.modifyApplication(action.id, action.application),
+        { message: `Modifying ${action.application.name}` }
+      );
+    } catch (err) {
+      if (!(err instanceof Error)) {
+        throw err;
+      }
+      if (!(err instanceof ApiError)) {
+        throw new UserError(
+          `Unexpected error modifying application "${action.name}": ${err.message}`,
+          { telemetryMessage: "containers deploy modify unexpected error" }
+        );
+      }
+      if (err.status === 400) {
+        throw new UserError(
+          `Error modifying application "${action.name}" due to a misconfiguration:
+
+	${formatError(err)}`,
+          { telemetryMessage: "containers deploy modify misconfiguration" }
+        );
+      }
+      throw new UserError(
+        `Error modifying application "${action.name}":
+${formatError(err)}`,
+        { telemetryMessage: "containers deploy modify request failed" }
+      );
+    }
+    if (action.rollout_step_percentage !== void 0 && action.rollout_kind !== void 0) {
+      try {
+        await promiseSpinner(
+          RolloutsService.createApplicationRollout(action.id, {
+            description: "Progressive update",
+            strategy: CreateApplicationRolloutRequest.strategy.ROLLING,
+            target_configuration: action.application.configuration ?? {},
+            ...configRolloutStepsToAPI(action.rollout_step_percentage),
+            kind: action.rollout_kind
+          }),
+          {
+            message: `rolling out container version ${action.name}`
+          }
+        );
+      } catch (err) {
+        if (!(err instanceof Error)) {
+          throw err;
+        }
+        if (!(err instanceof ApiError)) {
+          throw new UserError(
+            `Unexpected error rolling out application "${action.name}":
+${err.message}`,
+            { telemetryMessage: "containers deploy rollout unexpected error" }
+          );
+        }
+        if (err.status === 400) {
+          throw new UserError(
+            `Error rolling out application "${action.name}" due to a misconfiguration:
+
+	${formatError(err)}`,
+            { telemetryMessage: "containers deploy rollout misconfiguration" }
+          );
+        }
+        throw new UserError(
+          `Error rolling out application "${action.name}":
+${formatError(err)}`,
+          { telemetryMessage: "containers deploy rollout request failed" }
+        );
+      }
+    }
+    success(
+      action.successMessage ?? `Modified application ${brandColor(action.name)} (Application ID: ${action.id})`,
+      {
+        shape: shapes.bar
+      }
+    );
+  }
+}, "doAction");
+function cleanApplicationFromAPI(prev, currentConfig, accountId, observabilityWriteTarget, complianceConfig) {
+  const configuration = {
+    ...prev.configuration,
+    image: resolveImageName(
+      accountId,
+      prev.configuration.image,
+      complianceConfig
+    )
+  };
+  if (observabilityWriteTarget === "top-level") {
+    delete configuration.observability;
+  }
+  const cleanedPreviousApp = {
+    configuration,
+    constraints: prev.constraints,
+    max_instances: prev.max_instances,
+    name: prev.name,
+    scheduling_policy: prev.scheduling_policy,
+    affinities: prev.affinities,
+    rollout_active_grace_period: prev.rollout_active_grace_period
+  };
+  if (observabilityWriteTarget === "configuration" && getLatestLegacyObservabilityState(prev) !== void 0) {
+    cleanedPreviousApp.configuration.observability = getLatestLegacyObservabilityState(prev);
+  }
+  if (prev.observability !== void 0) {
+    cleanedPreviousApp.observability = prev.observability;
+  }
+  if ("instance_type" in currentConfig) {
+    const instance_type = inferInstanceType(cleanedPreviousApp.configuration);
+    if (!instance_type) {
+      return cleanedPreviousApp;
+    }
+    cleanedPreviousApp.configuration.instance_type = instance_type;
+    delete cleanedPreviousApp.configuration.disk;
+    delete cleanedPreviousApp.configuration.memory;
+    delete cleanedPreviousApp.configuration.memory_mib;
+    delete cleanedPreviousApp.configuration.vcpu;
+  }
+  return cleanedPreviousApp;
+}
+__name(cleanApplicationFromAPI, "cleanApplicationFromAPI");
+var configRolloutStepsToAPI = /* @__PURE__ */ __name((rolloutSteps) => {
+  if (typeof rolloutSteps === "number") {
+    return { step_percentage: rolloutSteps };
+  } else {
+    const output = [];
+    let index = 1;
+    for (const step of rolloutSteps) {
+      output.push({
+        step_size: { percentage: step },
+        description: `Step ${index} of ${rolloutSteps.length} - rollout at ${step}% of instances`
+      });
+      index++;
+    }
+    return { steps: output };
+  }
+}, "configRolloutStepsToAPI");
+
+export { AccountService, ApiError, ApplicationAffinityColocation, ApplicationAffinityHardwareGeneration, ApplicationMutationError, ApplicationRollout, ApplicationsService, AssignIPv4, AssignIPv6, BadRequestWithCodeError, CancelError, CancelablePromise, ContainerImagePreparationStatus, ContainerImagePreparationsService, ContainerNetworkMode, CreateApplicationRolloutRequest, DEFAULT_CONTAINER_EGRESS_INTERCEPTOR_IMAGE, DeploymentCheckKind, DeploymentCheckType, DeploymentMutationError, DeploymentNotFoundError, DeploymentPlacementState, DeploymentQueuedReason, DeploymentSchedulingState, DeploymentType, DeploymentsService, Diff, DurableObjectStatusHealth, EventName, EventType, ExternalRegistryKind, FUSE_CONTAINER_PRIVILEGES, HTTPMethod, IPType, IPsService, ImageRegistriesService, ImageRegistryAlreadyExistsError, ImageRegistryIsPublic, ImageRegistryNotAllowedError, ImageRegistryNotFoundError, ImageRegistryPermissions, ImageRegistryProtocolAlreadyExists, ImageRegistryProtocolIsReferencedError, ImageRegistryProtocolNotFound, InstanceType, JobStatusHealth, JobsService, MF_DEV_CONTAINER_PREFIX, NetworkMode, NodeGroup, OpenAPI, PlacementStatusHealth, PlacementsService, ProvisionerConfiguration, RolloutStep, RolloutsService, SSHPublicKeyNotFoundError, SchedulingPolicy, SecretAccessType, SecretNameAlreadyExists, SecretNotFound, SecretsService, SshPublicKeysService, UpdateApplicationRolloutRequest, 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 };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map