@pantechdynamic/sdk 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1515 @@
+'use strict';
+
+// src/errors.ts
+var PantechError = class extends Error {
+  name = "PantechError";
+  /** The HTTP status, when the API answered. */
+  status;
+  /** The problem's stable code, e.g. `INSUFFICIENT_CREDIT`. */
+  code;
+  /** A short summary of the problem class. */
+  title;
+  /** What went wrong and what to do next, in plain language. Safe to show to your users. */
+  detail;
+  /** The request's id. Quote it to support. */
+  requestId;
+  /** The invalid fields of a `422 VALIDATION_FAILED`; empty otherwise. */
+  errors;
+  /** A URI naming the problem class. */
+  type;
+  /** The response headers, when the API answered. */
+  headers;
+  constructor(message, init = {}) {
+    super(message, init.cause === void 0 ? void 0 : { cause: init.cause });
+    this.status = init.status;
+    this.code = init.code;
+    this.title = init.title;
+    this.detail = init.detail;
+    this.requestId = init.requestId;
+    this.errors = init.errors ?? [];
+    this.type = init.type;
+    this.headers = init.headers;
+  }
+};
+var BadRequestError = class extends PantechError {
+  name = "BadRequestError";
+};
+var AuthenticationError = class extends PantechError {
+  name = "AuthenticationError";
+};
+var PaymentRequiredError = class extends PantechError {
+  name = "PaymentRequiredError";
+};
+var PermissionDeniedError = class extends PantechError {
+  name = "PermissionDeniedError";
+};
+var NotFoundError = class extends PantechError {
+  name = "NotFoundError";
+};
+var ConflictError = class extends PantechError {
+  name = "ConflictError";
+};
+var ValidationError = class extends PantechError {
+  name = "ValidationError";
+};
+var RateLimitError = class extends PantechError {
+  name = "RateLimitError";
+  /** Seconds the API asked to wait (`Retry-After`), when it said. */
+  retryAfterSeconds;
+  constructor(message, init = {}) {
+    super(message, init);
+    this.retryAfterSeconds = init.retryAfterSeconds;
+  }
+};
+var InternalServerError = class extends PantechError {
+  name = "InternalServerError";
+};
+var APIConnectionError = class extends PantechError {
+  name = "APIConnectionError";
+};
+var APITimeoutError = class extends APIConnectionError {
+  name = "APITimeoutError";
+};
+var OperationFailedError = class extends PantechError {
+  name = "OperationFailedError";
+  /** The failed operation, as `GET /operations/{id}` returned it. */
+  operation;
+  constructor(message, operation, init = {}) {
+    super(message, init);
+    this.operation = operation;
+  }
+};
+var OrderFailedError = class extends PantechError {
+  name = "OrderFailedError";
+  /** The failed order. */
+  order;
+  constructor(message, order, init = {}) {
+    super(message, init);
+    this.order = order;
+  }
+};
+var WaitTimeoutError = class extends PantechError {
+  name = "WaitTimeoutError";
+};
+var WebhookVerificationError = class extends PantechError {
+  name = "WebhookVerificationError";
+};
+function isPantechError(err, code) {
+  return err instanceof PantechError && (code === void 0 || err.code === code);
+}
+var STATUS_TEXT = {
+  400: "Bad request",
+  401: "Unauthorized",
+  402: "Payment required",
+  403: "Forbidden",
+  404: "Not found",
+  405: "Method not allowed",
+  409: "Conflict",
+  413: "Request too large",
+  415: "Unsupported media type",
+  422: "Validation failed",
+  429: "Too many requests",
+  500: "Internal server error",
+  502: "Bad gateway",
+  503: "Service unavailable",
+  504: "Gateway timeout"
+};
+var str = (v) => typeof v === "string" && v !== "" ? v : void 0;
+function fieldErrors(v) {
+  if (!Array.isArray(v)) return [];
+  return v.filter((e) => typeof e === "object" && e !== null).map((e) => ({ field: String(e.field ?? ""), code: String(e.code ?? ""), message: String(e.message ?? "") }));
+}
+function errorFromResponse(status, headers, bodyText, retryAfterSeconds) {
+  let problem;
+  try {
+    const parsed = JSON.parse(bodyText);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) problem = parsed;
+  } catch {
+    problem = void 0;
+  }
+  const code = str(problem?.code);
+  const title = str(problem?.title);
+  let detail = str(problem?.detail);
+  const errors = fieldErrors(problem?.errors);
+  const requestId = str(problem?.request_id) ?? headers.get("x-request-id") ?? void 0;
+  const isProblem = code !== void 0 || detail !== void 0 || title !== void 0 || errors.length > 0;
+  if (!isProblem) {
+    const text = STATUS_TEXT[status] ?? `HTTP ${status}`;
+    detail = status >= 500 ? `The Pantech API is temporarily unavailable (${status} ${text}). Try again in a moment.` : `The Pantech API refused the request (${status} ${text}).`;
+  }
+  let message = detail ?? title ?? STATUS_TEXT[status] ?? `HTTP ${status}`;
+  const tags = [code, requestId ? `request ${requestId}` : void 0].filter(Boolean);
+  if (tags.length > 0) message += ` (${tags.join(", ")})`;
+  const init = {
+    status,
+    code,
+    title,
+    detail,
+    requestId,
+    errors,
+    type: str(problem?.type),
+    headers
+  };
+  switch (true) {
+    case status === 400:
+      return new BadRequestError(message, init);
+    case status === 401:
+      return new AuthenticationError(message, init);
+    case status === 402:
+      return new PaymentRequiredError(message, init);
+    case status === 403:
+      return new PermissionDeniedError(message, init);
+    case status === 404:
+      return new NotFoundError(message, init);
+    case status === 409:
+      return new ConflictError(message, init);
+    case status === 422:
+      return new ValidationError(message, init);
+    case status === 429:
+      return new RateLimitError(message, { ...init, retryAfterSeconds });
+    case status >= 500:
+      return new InternalServerError(message, init);
+    default:
+      return new PantechError(message, init);
+  }
+}
+
+// src/pagination.ts
+async function* paginate(fetchPage, startCursor) {
+  let cursor = startCursor ?? void 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    const page = await fetchPage(cursor);
+    for (const item of page.data ?? []) yield item;
+    const next = page.next_cursor;
+    if (!next || seen.has(next)) return;
+    seen.add(next);
+    cursor = next;
+  }
+}
+
+// src/resource.ts
+var APIResource = class {
+  _client;
+  constructor(client) {
+    this._client = client;
+  }
+  _request(method, path2, init = {}, options) {
+    return this._client.request({ method, path: path2, ...init }, options);
+  }
+  _get(path2, query, options) {
+    return this._request("GET", path2, { query }, options);
+  }
+  _post(path2, body, options, extra) {
+    return this._request("POST", path2, { body, ...extra }, options);
+  }
+  _put(path2, body, options) {
+    return this._request("PUT", path2, { body }, options);
+  }
+  _patch(path2, body, options) {
+    return this._request("PATCH", path2, { body }, options);
+  }
+  _delete(path2, options, extra) {
+    return this._request("DELETE", path2, extra, options);
+  }
+  /** Every item of a list, following `next_cursor` page by page. */
+  _listAll(path2, params, options) {
+    return paginate((cursor) => this._get(path2, { ...params, cursor }, options));
+  }
+};
+
+// src/util.ts
+function uuid() {
+  const c = globalThis.crypto;
+  if (typeof c?.randomUUID === "function") return c.randomUUID();
+  const b = new Uint8Array(16);
+  if (typeof c?.getRandomValues === "function") {
+    c.getRandomValues(b);
+  } else {
+    for (let i = 0; i < 16; i++) b[i] = Math.floor(Math.random() * 256);
+  }
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const h = Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+function readEnv(name) {
+  try {
+    const proc = globalThis.process;
+    const value = proc?.env?.[name]?.trim();
+    return value ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function path(strings, ...ids) {
+  let out = strings[0] ?? "";
+  ids.forEach((id, i) => {
+    if (typeof id !== "string" || id === "") {
+      throw new PantechError("A resource id is required, and it must be a non-empty string.");
+    }
+    out += encodeURIComponent(id) + (strings[i + 1] ?? "");
+  });
+  return out;
+}
+
+// src/resources/billing.ts
+var Billing = class extends APIResource {
+  credit = new Credit(this._client);
+  receipts = new Receipts(this._client);
+};
+var Credit = class extends APIResource {
+  purchases = new CreditPurchases(this._client);
+  /** Your credit balance and whether it covers the next invoice. */
+  get(options) {
+    return this._get("/billing/credit", void 0, options);
+  }
+};
+var CreditPurchases = class extends APIResource {
+  /** Creates a payment link that adds credit: send its `checkout_url` to whoever pays. */
+  create(body, options) {
+    return this._post("/billing/credit/purchases", body, options);
+  }
+  get(purchaseId, options) {
+    return this._get(path`/billing/credit/purchases/${purchaseId}`, void 0, options);
+  }
+};
+var Receipts = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/billing/receipts", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/billing/receipts", params, options);
+  }
+  get(receiptId, options) {
+    return this._get(path`/billing/receipts/${receiptId}`, void 0, options);
+  }
+  /** The receipt as a PDF document. */
+  getPdf(receiptId, options) {
+    return this._request("GET", path`/billing/receipts/${receiptId}/pdf`, { responseType: "arrayBuffer" }, options);
+  }
+};
+
+// src/resources/catalog.ts
+var Regions = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/regions", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/regions", params, options);
+  }
+};
+var Plans = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/plans", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/plans", params, options);
+  }
+};
+var Images = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/images", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/images", params, options);
+  }
+};
+var DiskOfferings = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/disk-offerings", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/disk-offerings", params, options);
+  }
+  /** What a volume of this offering costs. */
+  quote(slug, params = {}, options) {
+    return this._get(path`/disk-offerings/${slug}/quote`, params, options);
+  }
+};
+var DatabaseEngines = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/database-engines", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/database-engines", params, options);
+  }
+};
+var KubernetesVersions = class extends APIResource {
+  /** The Kubernetes versions a new cluster can run, and the zones that offer high availability. */
+  list(params = {}, options) {
+    return this._get("/kubernetes-versions", params, options);
+  }
+};
+var Pricing = class extends APIResource {
+  /** Prices a set of instances, volumes and other resources. Changes nothing. */
+  estimate(body, options) {
+    return this._post("/pricing/estimate", body, options);
+  }
+};
+
+// src/wait.ts
+var DEFAULT_WAIT_TIMEOUT_MS = 20 * 6e4;
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+async function poll(read, done, what, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+  const interval = Math.max(0, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const value = await read();
+    options.onUpdate?.(value);
+    if (done(value)) return value;
+    if (Date.now() + interval > deadline) {
+      throw new WaitTimeoutError(
+        `${what} did not finish within ${Math.round(timeoutMs / 1e3)} seconds. It may still finish: check it again later.`
+      );
+    }
+    await sleep(interval, options.signal);
+  }
+}
+
+// src/orders.ts
+var orderId = (ref) => typeof ref === "string" ? ref : ref.order_id;
+async function waitForOrder(client, read, what, options = {}) {
+  const started = Date.now();
+  const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+  const order = await poll(
+    () => read(options.signal),
+    (o) => {
+      if (o.status === "failed" || o.status === "payment_failed") {
+        const code = o.failure_code ?? o.status;
+        throw new OrderFailedError(
+          `${what} ${o.status === "payment_failed" ? "could not be paid" : "failed"} (${code}). Any payment taken is returned to your credit.`,
+          o,
+          { code }
+        );
+      }
+      return o.status === "provisioned";
+    },
+    what,
+    options
+  );
+  if (options.waitForOperation !== false && order.operation_id) {
+    await client.operations.wait(order.operation_id, {
+      timeoutMs: Math.max(0, timeoutMs - (Date.now() - started)),
+      pollIntervalMs: options.pollIntervalMs,
+      signal: options.signal
+    });
+  }
+  return order;
+}
+
+// src/resources/databases.ts
+var Databases = class extends APIResource {
+  /** Snapshots of a database. */
+  snapshots = new DatabaseSnapshots(this._client);
+  list(params = {}, options) {
+    return this._get("/databases", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/databases", params, options);
+  }
+  /**
+   * Orders a database. A generated admin password is in this response only;
+   * follow the order with `client.databaseOrders.wait(order)`.
+   */
+  create(body, options) {
+    return this._post("/databases", body, options);
+  }
+  get(databaseId, options) {
+    return this._get(path`/databases/${databaseId}`, void 0, options);
+  }
+  delete(databaseId, options) {
+    return this._delete(path`/databases/${databaseId}`, options);
+  }
+  /** Replaces the CIDRs allowed to connect. */
+  replaceAccessRules(databaseId, body, options) {
+    return this._put(path`/databases/${databaseId}/access-rules`, body, options);
+  }
+  /** Replaces the attached security groups. */
+  setSecurityGroups(databaseId, body, options) {
+    return this._put(path`/databases/${databaseId}/security-groups`, body, options);
+  }
+  changePassword(databaseId, body, options) {
+    return this._put(path`/databases/${databaseId}/password`, body, options);
+  }
+  /** Generates a new admin password, returned in this response only. */
+  resetPassword(databaseId, options) {
+    return this._post(path`/databases/${databaseId}/reset-password`, void 0, options);
+  }
+  start(databaseId, options) {
+    return this._post(path`/databases/${databaseId}/start`, void 0, options);
+  }
+  stop(databaseId, options) {
+    return this._post(path`/databases/${databaseId}/stop`, void 0, options);
+  }
+  resizeStorage(databaseId, body, options) {
+    return this._post(path`/databases/${databaseId}/resize-storage`, body, options);
+  }
+};
+var DatabaseSnapshots = class extends APIResource {
+  list(databaseId, params = {}, options) {
+    return this._get(path`/databases/${databaseId}/snapshots`, params, options);
+  }
+  listAll(databaseId, params = {}, options) {
+    return this._listAll(path`/databases/${databaseId}/snapshots`, params, options);
+  }
+  create(databaseId, body, options) {
+    return this._post(path`/databases/${databaseId}/snapshots`, body, options);
+  }
+  get(databaseId, snapshotId, options) {
+    return this._get(path`/databases/${databaseId}/snapshots/${snapshotId}`, void 0, options);
+  }
+  delete(databaseId, snapshotId, options) {
+    return this._delete(path`/databases/${databaseId}/snapshots/${snapshotId}`, options);
+  }
+};
+var DatabaseOrders = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/database-orders", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/database-orders", params, options);
+  }
+  get(orderId2, options) {
+    return this._get(path`/database-orders/${orderId2}`, void 0, options);
+  }
+  /**
+   * Polls the order until it is provisioned and (by default) the database's
+   * create operation has finished. Rejects with OrderFailedError or
+   * OperationFailedError. Accepts an id or the body `databases.create` returned.
+   */
+  wait(ref, options = {}) {
+    const id = orderId(ref);
+    return waitForOrder(this._client, (signal) => this.get(id, { signal }), `Database order ${id}`, options);
+  }
+};
+
+// src/resources/instances.ts
+var Instances = class extends APIResource {
+  /** Snapshots of an instance's root disk. */
+  snapshots = new InstanceSnapshots(this._client);
+  /** Short-lived SSH access grants through the browser terminal relay. */
+  sshAccess = new InstanceSshAccess(this._client);
+  /** One page of your instances. */
+  list(params = {}, options) {
+    return this._get("/instances", params, options);
+  }
+  /** Every instance: `for await (const vm of client.instances.listAll())`. */
+  listAll(params = {}, options) {
+    return this._listAll("/instances", params, options);
+  }
+  /**
+   * Orders an instance. The initial payment is taken first, then it is
+   * provisioned: follow the order with `client.instanceOrders.wait(order)`.
+   */
+  create(body, options) {
+    return this._post("/instances", body, options);
+  }
+  get(instanceId, options) {
+    return this._get(path`/instances/${instanceId}`, void 0, options);
+  }
+  delete(instanceId, options) {
+    return this._delete(path`/instances/${instanceId}`, options);
+  }
+  start(instanceId, options) {
+    return this._post(path`/instances/${instanceId}/start`, void 0, options);
+  }
+  stop(instanceId, options) {
+    return this._post(path`/instances/${instanceId}/stop`, void 0, options);
+  }
+  reboot(instanceId, options) {
+    return this._post(path`/instances/${instanceId}/reboot`, void 0, options);
+  }
+  /** Reinstalls the root disk from an image. Everything on it is lost. */
+  rebuild(instanceId, body, options) {
+    return this._post(path`/instances/${instanceId}/rebuild`, body, options);
+  }
+  rename(instanceId, body, options) {
+    return this._post(path`/instances/${instanceId}/rename`, body, options);
+  }
+  /** Moves the instance to a bigger plan. */
+  resize(instanceId, body, options) {
+    return this._post(path`/instances/${instanceId}/resize`, body, options);
+  }
+  changeSshKey(instanceId, body, options) {
+    return this._post(path`/instances/${instanceId}/change-ssh-key`, body, options);
+  }
+  /** Restores the root disk from a snapshot. Changes since then are lost. */
+  restore(instanceId, body, options) {
+    return this._post(path`/instances/${instanceId}/restore`, body, options);
+  }
+  changeSecurityGroup(instanceId, body, options) {
+    return this._put(path`/instances/${instanceId}/security-group`, body, options);
+  }
+  attachPrivateNetwork(instanceId, options) {
+    return this._post(path`/instances/${instanceId}/private-network`, void 0, options);
+  }
+  detachPrivateNetwork(instanceId, options) {
+    return this._delete(path`/instances/${instanceId}/private-network`, options);
+  }
+  /** A short-lived URL to the instance's console. Sent once: the API does not replay it. */
+  openConsole(instanceId, options) {
+    return this._post(path`/instances/${instanceId}/console`, void 0, options, { noRetry: true });
+  }
+  /** Issues a credential that unlocks the instance's encrypted volumes. Sent once: the API does not replay it. */
+  issueVolumeKeyCredential(instanceId, options) {
+    return this._post(path`/instances/${instanceId}/volume-key-credential`, void 0, options, { noRetry: true });
+  }
+  metrics(instanceId, params = {}, options) {
+    return this._get(path`/instances/${instanceId}/metrics`, params, options);
+  }
+  usage(instanceId, options) {
+    return this._get(path`/instances/${instanceId}/usage`, void 0, options);
+  }
+  /** One page of the volumes attached to the instance. */
+  listVolumes(instanceId, params = {}, options) {
+    return this._get(path`/instances/${instanceId}/volumes`, params, options);
+  }
+  listAllVolumes(instanceId, params = {}, options) {
+    return this._listAll(path`/instances/${instanceId}/volumes`, params, options);
+  }
+  getSnapshotSchedule(instanceId, options) {
+    return this._get(path`/instances/${instanceId}/snapshot-schedule`, void 0, options);
+  }
+  setSnapshotSchedule(instanceId, body, options) {
+    return this._put(path`/instances/${instanceId}/snapshot-schedule`, body, options);
+  }
+};
+var InstanceSnapshots = class extends APIResource {
+  list(instanceId, params = {}, options) {
+    return this._get(path`/instances/${instanceId}/snapshots`, params, options);
+  }
+  listAll(instanceId, params = {}, options) {
+    return this._listAll(path`/instances/${instanceId}/snapshots`, params, options);
+  }
+  create(instanceId, body, options) {
+    return this._post(path`/instances/${instanceId}/snapshots`, body, options);
+  }
+};
+var InstanceSshAccess = class extends APIResource {
+  open(instanceId, options) {
+    return this._post(path`/instances/${instanceId}/ssh-access`, void 0, options);
+  }
+  get(instanceId, grantId, options) {
+    return this._get(path`/instances/${instanceId}/ssh-access/${grantId}`, void 0, options);
+  }
+  revoke(instanceId, grantId, options) {
+    return this._delete(path`/instances/${instanceId}/ssh-access/${grantId}`, options);
+  }
+};
+var InstanceOrders = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/instance-orders", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/instance-orders", params, options);
+  }
+  get(orderId2, options) {
+    return this._get(path`/instance-orders/${orderId2}`, void 0, options);
+  }
+  /**
+   * Polls the order until it is provisioned and (by default) the instance's
+   * create operation has finished. Rejects with OrderFailedError when the
+   * order fails or cannot be paid, and OperationFailedError when the create
+   * fails. Accepts an id or the body `instances.create` returned.
+   */
+  wait(ref, options = {}) {
+    const id = orderId(ref);
+    return waitForOrder(this._client, (signal) => this.get(id, { signal }), `Instance order ${id}`, options);
+  }
+};
+
+// src/resources/kubernetes.ts
+var Kubernetes = class extends APIResource {
+  /** A cluster's node pools. */
+  nodePools = new KubernetesNodePools(this._client);
+  /** A cluster's add-ons. */
+  addons = new KubernetesAddons(this._client);
+  list(params = {}, options) {
+    return this._get("/kubernetes-clusters", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/kubernetes-clusters", params, options);
+  }
+  create(body, options) {
+    return this._post("/kubernetes-clusters", body, options);
+  }
+  get(clusterId, options) {
+    return this._get(path`/kubernetes-clusters/${clusterId}`, void 0, options);
+  }
+  /** Changes the cluster's size (`PATCH`). */
+  update(clusterId, body, options) {
+    return this._patch(path`/kubernetes-clusters/${clusterId}`, body, options);
+  }
+  delete(clusterId, options) {
+    return this._delete(path`/kubernetes-clusters/${clusterId}`, options);
+  }
+  /** Upgrades the cluster to a newer Kubernetes version. */
+  upgrade(clusterId, body, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/upgrade`, body, options);
+  }
+  /** Moves every node to another plan. */
+  resizePlan(clusterId, body, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/resize-plan`, body, options);
+  }
+  /** Changes the cluster's networking. */
+  upgradeNetwork(clusterId, body, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/upgrade-network`, body, options);
+  }
+  start(clusterId, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/start`, void 0, options);
+  }
+  stop(clusterId, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/stop`, void 0, options);
+  }
+  /** The cluster's kubeconfig. It holds credentials: store it securely. */
+  getKubeconfig(clusterId, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/kubeconfig`, void 0, options);
+  }
+  listNodes(clusterId, options) {
+    return this._get(path`/kubernetes-clusters/${clusterId}/nodes`, void 0, options);
+  }
+  getWorkloads(clusterId, options) {
+    return this._get(path`/kubernetes-clusters/${clusterId}/workloads`, void 0, options);
+  }
+  applyManifest(clusterId, body, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/apply-manifest`, body, options);
+  }
+  getLiveManifests(clusterId, options) {
+    return this._get(path`/kubernetes-clusters/${clusterId}/live-manifests`, void 0, options);
+  }
+  exposeService(clusterId, body, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/expose-service`, body, options);
+  }
+  syncRouting(clusterId, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/sync-routing`, void 0, options);
+  }
+  /** Sets whether the cluster's API endpoint is private, public or both. */
+  configureEndpointAccess(clusterId, body, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/endpoint-access`, body, options);
+  }
+};
+var KubernetesNodePools = class extends APIResource {
+  list(clusterId, params = {}, options) {
+    return this._get(path`/kubernetes-clusters/${clusterId}/node-pools`, params, options);
+  }
+  listAll(clusterId, params = {}, options) {
+    return this._listAll(path`/kubernetes-clusters/${clusterId}/node-pools`, params, options);
+  }
+  create(clusterId, body, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/node-pools`, body, options);
+  }
+  /** Sets the pool's whole size: a missing `autoscaling_enabled` turns autoscaling off. */
+  scale(clusterId, poolId, body, options) {
+    return this._patch(path`/kubernetes-clusters/${clusterId}/node-pools/${poolId}`, body, options);
+  }
+  delete(clusterId, poolId, options) {
+    return this._delete(path`/kubernetes-clusters/${clusterId}/node-pools/${poolId}`, options);
+  }
+};
+var KubernetesAddons = class extends APIResource {
+  list(clusterId, params = {}, options) {
+    return this._get(path`/kubernetes-clusters/${clusterId}/addons`, params, options);
+  }
+  listAll(clusterId, params = {}, options) {
+    return this._listAll(path`/kubernetes-clusters/${clusterId}/addons`, params, options);
+  }
+  /** Turns an add-on on or off. */
+  toggle(clusterId, addonName, body, options) {
+    return this._post(path`/kubernetes-clusters/${clusterId}/addons/${addonName}/toggle`, body, options);
+  }
+};
+
+// src/resources/load-balancers.ts
+var LoadBalancers = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/load-balancers", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/load-balancers", params, options);
+  }
+  create(body, options) {
+    return this._post("/load-balancers", body, options);
+  }
+  get(loadBalancerId, options) {
+    return this._get(path`/load-balancers/${loadBalancerId}`, void 0, options);
+  }
+  update(loadBalancerId, body, options) {
+    return this._patch(path`/load-balancers/${loadBalancerId}`, body, options);
+  }
+  delete(loadBalancerId, options) {
+    return this._delete(path`/load-balancers/${loadBalancerId}`, options);
+  }
+};
+
+// src/resources/me.ts
+var MeResource = class extends APIResource {
+  /** The organization and project the key acts in, its scopes, kind and expiry. */
+  get(options) {
+    return this._get("/me", void 0, options);
+  }
+  /**
+   * Revokes the API key making the call. Every later call with it is a
+   * `401`. Sent once: a retry would find the key gone.
+   */
+  revoke(options) {
+    return this._delete("/me", options, { noRetry: true });
+  }
+};
+
+// src/resources/networks.ts
+var Networks = class extends APIResource {
+  /** A network's subnets: `client.networks.subnets.list(networkId)`. */
+  subnets = new Subnets(this._client);
+  /** A subnet's firewall rules: `client.networks.firewallRules.list(subnetId)`. */
+  firewallRules = new FirewallRules(this._client);
+  list(params = {}, options) {
+    return this._get("/networks", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/networks", params, options);
+  }
+  create(body, options) {
+    return this._post("/networks", body, options);
+  }
+  /** What a network costs a month. */
+  quote(options) {
+    return this._get("/networks/quote", void 0, options);
+  }
+  get(networkId, options) {
+    return this._get(path`/networks/${networkId}`, void 0, options);
+  }
+  delete(networkId, options) {
+    return this._delete(path`/networks/${networkId}`, options);
+  }
+};
+var Subnets = class extends APIResource {
+  /** One page of a network's subnets. */
+  list(networkId, params = {}, options) {
+    return this._get(path`/networks/${networkId}/subnets`, params, options);
+  }
+  listAll(networkId, params = {}, options) {
+    return this._listAll(path`/networks/${networkId}/subnets`, params, options);
+  }
+  create(networkId, body, options) {
+    return this._post(path`/networks/${networkId}/subnets`, body, options);
+  }
+  get(subnetId, options) {
+    return this._get(path`/subnets/${subnetId}`, void 0, options);
+  }
+  delete(subnetId, options) {
+    return this._delete(path`/subnets/${subnetId}`, options);
+  }
+};
+var FirewallRules = class extends APIResource {
+  /** A subnet's rules, plus the `system_rules` every subnet has. */
+  list(subnetId, params = {}, options) {
+    return this._get(path`/subnets/${subnetId}/firewall-rules`, params, options);
+  }
+  listAll(subnetId, params = {}, options) {
+    return this._listAll(path`/subnets/${subnetId}/firewall-rules`, params, options);
+  }
+  create(subnetId, body, options) {
+    return this._post(path`/subnets/${subnetId}/firewall-rules`, body, options);
+  }
+  get(subnetId, ruleId, options) {
+    return this._get(path`/subnets/${subnetId}/firewall-rules/${ruleId}`, void 0, options);
+  }
+  delete(ruleId, options) {
+    return this._delete(path`/firewall-rules/${ruleId}`, options);
+  }
+};
+
+// src/resources/operations.ts
+function operationId(ref) {
+  const id = typeof ref === "string" ? ref : ref.operation_id;
+  if (!id) throw new PantechError("There is no operation to wait for: the response carried no operation_id.");
+  return id;
+}
+function operationFailed(op) {
+  const reason = op.failure?.reason ?? "The operation failed.";
+  const code = op.failure?.code;
+  return new OperationFailedError(code ? `${reason} (${code})` : reason, op, { code, detail: reason });
+}
+var Operations = class extends APIResource {
+  /** An operation's current state. */
+  get(operationId2, options) {
+    return this._get(path`/operations/${operationId2}`, void 0, options);
+  }
+  /**
+   * Polls the operation until it succeeds (resolves with it) or fails
+   * (rejects with OperationFailedError). Accepts an id or the `202` body of
+   * any write: `await client.operations.wait(await client.instances.stop(id))`.
+   */
+  wait(ref, options = {}) {
+    const id = operationId(ref);
+    return poll(
+      () => this.get(id, { signal: options.signal }),
+      (op) => {
+        if (op.status === "failed") throw operationFailed(op);
+        return op.status === "succeeded";
+      },
+      `Operation ${id}`,
+      options
+    );
+  }
+  /**
+   * Streams the operation's changes (Server-Sent Events) until it succeeds
+   * or fails, yielding the Operation each time it changes. A stream the API
+   * ends early (after 15 minutes, say) rejects with its code; poll with
+   * `wait` instead.
+   */
+  async *stream(operationId2, options = {}) {
+    const res = await this._request(
+      "GET",
+      path`/operations/${operationId2}/events`,
+      { responseType: "response" },
+      { ...options, headers: { ...options.headers, Accept: "text/event-stream" } }
+    );
+    if (!res.body) return;
+    for await (const event of readEvents(res.body)) {
+      if (event.event === "error") {
+        let body = {};
+        try {
+          body = JSON.parse(event.data);
+        } catch {
+          body = {};
+        }
+        const detail = body.detail ?? "The operation stream ended before the operation finished.";
+        throw new PantechError(body.code ? `${detail} (${body.code})` : detail, {
+          code: body.code,
+          detail,
+          requestId: body.request_id
+        });
+      }
+      if (event.event !== "operation" || !event.data) continue;
+      const op = JSON.parse(event.data);
+      yield op;
+      if (op.status === "succeeded" || op.status === "failed") return;
+    }
+  }
+};
+async function* readEvents(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let event = "message";
+  let data = [];
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+      const lines = buffer.split(/\r\n|\r|\n/);
+      buffer = done ? "" : lines.pop() ?? "";
+      for (const line of lines) {
+        if (line === "") {
+          if (data.length > 0) yield { event, data: data.join("\n") };
+          event = "message";
+          data = [];
+        } else if (!line.startsWith(":")) {
+          const colon = line.indexOf(":");
+          const field = colon === -1 ? line : line.slice(0, colon);
+          const value2 = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+          if (field === "event") event = value2;
+          else if (field === "data") data.push(value2);
+        }
+      }
+      if (done) {
+        if (data.length > 0) yield { event, data: data.join("\n") };
+        return;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    await body.cancel().catch(() => void 0);
+  }
+}
+
+// src/resources/public-ips.ts
+var PublicIps = class extends APIResource {
+  /** An address's port forwarding rules. */
+  portForwardingRules = new PortForwardingRules(this._client);
+  list(params = {}, options) {
+    return this._get("/public-ips", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/public-ips", params, options);
+  }
+  create(body, options) {
+    return this._post("/public-ips", body, options);
+  }
+  /** What a public IP costs a month. */
+  quote(options) {
+    return this._get("/public-ips/quote", void 0, options);
+  }
+  get(publicIpId, options) {
+    return this._get(path`/public-ips/${publicIpId}`, void 0, options);
+  }
+  delete(publicIpId, options) {
+    return this._delete(path`/public-ips/${publicIpId}`, options);
+  }
+  attach(publicIpId, body, options) {
+    return this._post(path`/public-ips/${publicIpId}/attach`, body, options);
+  }
+  detach(publicIpId, options) {
+    return this._post(path`/public-ips/${publicIpId}/detach`, void 0, options);
+  }
+};
+var PortForwardingRules = class extends APIResource {
+  list(publicIpId, params = {}, options) {
+    return this._get(path`/public-ips/${publicIpId}/port-forwarding-rules`, params, options);
+  }
+  listAll(publicIpId, params = {}, options) {
+    return this._listAll(path`/public-ips/${publicIpId}/port-forwarding-rules`, params, options);
+  }
+  create(publicIpId, body, options) {
+    return this._post(path`/public-ips/${publicIpId}/port-forwarding-rules`, body, options);
+  }
+  get(publicIpId, ruleId, options) {
+    return this._get(path`/public-ips/${publicIpId}/port-forwarding-rules/${ruleId}`, void 0, options);
+  }
+  delete(ruleId, options) {
+    return this._delete(path`/port-forwarding-rules/${ruleId}`, options);
+  }
+};
+
+// src/resources/security-groups.ts
+var SecurityGroups = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/security-groups", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/security-groups", params, options);
+  }
+  create(body, options) {
+    return this._post("/security-groups", body, options);
+  }
+  get(securityGroupId, options) {
+    return this._get(path`/security-groups/${securityGroupId}`, void 0, options);
+  }
+  delete(securityGroupId, options) {
+    return this._delete(path`/security-groups/${securityGroupId}`, options);
+  }
+  /** Replaces every rule of the group. */
+  replaceRules(securityGroupId, body, options) {
+    return this._put(path`/security-groups/${securityGroupId}/rules`, body, options);
+  }
+};
+
+// src/resources/snapshots.ts
+var Snapshots = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/snapshots", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/snapshots", params, options);
+  }
+  /** What a snapshot of `size_gb` costs. */
+  quote(params, options) {
+    return this._get("/snapshots/quote", params, options);
+  }
+  get(snapshotId, options) {
+    return this._get(path`/snapshots/${snapshotId}`, void 0, options);
+  }
+  delete(snapshotId, options) {
+    return this._delete(path`/snapshots/${snapshotId}`, options);
+  }
+  /** Restores the snapshot into a new volume. */
+  restore(snapshotId, body, options) {
+    return this._post(path`/snapshots/${snapshotId}/restore`, body, options);
+  }
+  usage(snapshotId, options) {
+    return this._get(path`/snapshots/${snapshotId}/usage`, void 0, options);
+  }
+};
+
+// src/resources/ssh-keys.ts
+var SshKeys = class extends APIResource {
+  list(params = {}, options) {
+    return this._get("/ssh-keys", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/ssh-keys", params, options);
+  }
+  /**
+   * Adds your public key, or generates a key pair and returns the private
+   * key in this response only. If the call fails without an answer, list
+   * your keys before trying again.
+   */
+  create(body, options) {
+    return this._post("/ssh-keys", body, options, { noRetry: true });
+  }
+  get(sshKeyId, options) {
+    return this._get(path`/ssh-keys/${sshKeyId}`, void 0, options);
+  }
+  /** Deletes the key. A repeat after it is gone is a `404`: treat that as done. */
+  delete(sshKeyId, options) {
+    return this._delete(path`/ssh-keys/${sshKeyId}`, options, { noRetry: true });
+  }
+};
+
+// src/resources/usage.ts
+var Usage = class extends APIResource {
+  /** The organization's usage this period. */
+  get(options) {
+    return this._get("/usage", void 0, options);
+  }
+  /** Usage broken down per resource. */
+  byResource(params = {}, options) {
+    return this._get("/usage/by-resource", params, options);
+  }
+};
+
+// src/resources/volumes.ts
+var Volumes = class extends APIResource {
+  /** Snapshots of a volume. */
+  snapshots = new VolumeSnapshots(this._client);
+  list(params = {}, options) {
+    return this._get("/volumes", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/volumes", params, options);
+  }
+  create(body, options) {
+    return this._post("/volumes", body, options);
+  }
+  get(volumeId, options) {
+    return this._get(path`/volumes/${volumeId}`, void 0, options);
+  }
+  delete(volumeId, options) {
+    return this._delete(path`/volumes/${volumeId}`, options);
+  }
+  attach(volumeId, body, options) {
+    return this._post(path`/volumes/${volumeId}/attach`, body, options);
+  }
+  detach(volumeId, options) {
+    return this._post(path`/volumes/${volumeId}/detach`, void 0, options);
+  }
+  /** Grows a detached volume. */
+  resize(volumeId, body, options) {
+    return this._post(path`/volumes/${volumeId}/resize`, body, options);
+  }
+  usage(volumeId, options) {
+    return this._get(path`/volumes/${volumeId}/usage`, void 0, options);
+  }
+  getSnapshotSchedule(volumeId, options) {
+    return this._get(path`/volumes/${volumeId}/snapshot-schedule`, void 0, options);
+  }
+  setSnapshotSchedule(volumeId, body, options) {
+    return this._put(path`/volumes/${volumeId}/snapshot-schedule`, body, options);
+  }
+};
+var VolumeSnapshots = class extends APIResource {
+  list(volumeId, params = {}, options) {
+    return this._get(path`/volumes/${volumeId}/snapshots`, params, options);
+  }
+  listAll(volumeId, params = {}, options) {
+    return this._listAll(path`/volumes/${volumeId}/snapshots`, params, options);
+  }
+  create(volumeId, body, options) {
+    return this._post(path`/volumes/${volumeId}/snapshots`, body, options);
+  }
+};
+
+// src/resources/webhooks.ts
+var Webhooks = class extends APIResource {
+  /** A webhook's delivery log. */
+  deliveries = new WebhookDeliveries(this._client);
+  list(params = {}, options) {
+    return this._get("/webhooks", params, options);
+  }
+  listAll(params = {}, options) {
+    return this._listAll("/webhooks", params, options);
+  }
+  /** Every event type a webhook can subscribe to. */
+  listEventTypes(params = {}, options) {
+    return this._get("/webhook-event-types", params, options);
+  }
+  /** Creates a webhook. Its signing `secret` is in this response only. */
+  create(body, options) {
+    return this._post("/webhooks", body, options);
+  }
+  get(webhookId, options) {
+    return this._get(path`/webhooks/${webhookId}`, void 0, options);
+  }
+  update(webhookId, body, options) {
+    return this._patch(path`/webhooks/${webhookId}`, body, options);
+  }
+  /** Deletes the webhook. A repeat after it is gone is a `404`: treat that as done. */
+  delete(webhookId, options) {
+    return this._delete(path`/webhooks/${webhookId}`, options, { noRetry: true });
+  }
+  /** Sends a test event. Each call sends another. */
+  test(webhookId, options) {
+    return this._post(path`/webhooks/${webhookId}/test`, void 0, options, { noRetry: true });
+  }
+  /** Issues a new signing secret, in this response only. The previous one keeps signing for 24 hours. */
+  rotateSecret(webhookId, options) {
+    return this._post(path`/webhooks/${webhookId}/rotate-secret`, void 0, options, { noRetry: true });
+  }
+};
+var WebhookDeliveries = class extends APIResource {
+  list(webhookId, params = {}, options) {
+    return this._get(path`/webhooks/${webhookId}/deliveries`, params, options);
+  }
+  listAll(webhookId, params = {}, options) {
+    return this._listAll(path`/webhooks/${webhookId}/deliveries`, params, options);
+  }
+  get(webhookId, deliveryId, options) {
+    return this._get(path`/webhooks/${webhookId}/deliveries/${deliveryId}`, void 0, options);
+  }
+  /** Sends the delivery again. Each call sends another. */
+  redeliver(webhookId, deliveryId, options) {
+    return this._post(path`/webhooks/${webhookId}/deliveries/${deliveryId}/redeliver`, void 0, options, {
+      noRetry: true
+    });
+  }
+};
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.pantechdynamics.com/public/v1";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_RETRIES = 3;
+var MAX_RETRY_AFTER_MS = 6e4;
+var RETRY_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var Pantech = class {
+  baseURL;
+  maxRetries;
+  timeout;
+  // Private fields are invisible to console.log and JSON.stringify, so the
+  // key cannot leak through a logged client.
+  #apiKey;
+  #fetch;
+  #headers;
+  /** `GET` and `DELETE /me`: the API key making the call. */
+  me;
+  /** Credit, credit purchases and receipts. */
+  billing;
+  regions;
+  plans;
+  images;
+  diskOfferings;
+  databaseEngines;
+  kubernetesVersions;
+  pricing;
+  usage;
+  instances;
+  instanceOrders;
+  /** VPC networks, with their subnets and firewall rules. */
+  networks;
+  /** Public IPs, with their port forwarding rules. */
+  publicIps;
+  loadBalancers;
+  /** Managed Kubernetes clusters, with node pools and add-ons. */
+  kubernetes;
+  securityGroups;
+  volumes;
+  snapshots;
+  databases;
+  databaseOrders;
+  sshKeys;
+  webhooks;
+  operations;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? readEnv("PANTECH_API_KEY");
+    if (!apiKey) {
+      throw new PantechError(
+        "No Pantech API key. Pass `apiKey` or set PANTECH_API_KEY. Create a key in the console under Organization \u203A API keys."
+      );
+    }
+    this.#apiKey = apiKey;
+    this.baseURL = (options.baseURL ?? readEnv("PANTECH_API_URL") ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.#fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    this.#headers = {
+      ...options.defaultHeaders,
+      "User-Agent": options.userAgent ?? `pantech-js/${VERSION}`
+    };
+    this.me = new MeResource(this);
+    this.billing = new Billing(this);
+    this.regions = new Regions(this);
+    this.plans = new Plans(this);
+    this.images = new Images(this);
+    this.diskOfferings = new DiskOfferings(this);
+    this.databaseEngines = new DatabaseEngines(this);
+    this.kubernetesVersions = new KubernetesVersions(this);
+    this.pricing = new Pricing(this);
+    this.usage = new Usage(this);
+    this.operations = new Operations(this);
+    this.instances = new Instances(this);
+    this.instanceOrders = new InstanceOrders(this);
+    this.networks = new Networks(this);
+    this.publicIps = new PublicIps(this);
+    this.loadBalancers = new LoadBalancers(this);
+    this.kubernetes = new Kubernetes(this);
+    this.securityGroups = new SecurityGroups(this);
+    this.volumes = new Volumes(this);
+    this.snapshots = new Snapshots(this);
+    this.databases = new Databases(this);
+    this.databaseOrders = new DatabaseOrders(this);
+    this.sshKeys = new SshKeys(this);
+    this.webhooks = new Webhooks(this);
+  }
+  /**
+   * Sends one request and returns its decoded body (undefined for an empty
+   * one). A write carries an Idempotency-Key, reused by every retry, so a
+   * change cannot happen twice.
+   */
+  async request(req, options = {}) {
+    const url = this.baseURL + req.path + queryString(req.query);
+    const isWrite = req.method !== "GET";
+    const headers = {
+      ...this.#headers,
+      Accept: req.responseType === "arrayBuffer" ? "*/*" : "application/json",
+      ...options.headers,
+      Authorization: `Bearer ${this.#apiKey}`
+    };
+    let payload;
+    if (req.body !== void 0) {
+      payload = JSON.stringify(req.body);
+      headers["Content-Type"] = "application/json";
+    }
+    if (isWrite) headers["Idempotency-Key"] = options.idempotencyKey ?? uuid();
+    const maxRetries = options.maxRetries ?? this.maxRetries;
+    const timeout = options.timeout ?? this.timeout;
+    const signal = options.signal;
+    for (let attempt = 0; ; attempt++) {
+      const canRetry = attempt < maxRetries;
+      const attemptSignal = linkSignal(signal, timeout);
+      let res;
+      try {
+        res = await this.#fetch(url, { method: req.method, headers, body: payload, signal: attemptSignal.signal });
+      } catch (err) {
+        attemptSignal.done();
+        if (signal?.aborted) throw signal.reason;
+        const error = connectionError(err, attemptSignal.timedOut(), isWrite);
+        if (canRetry && !req.noRetry) {
+          await sleep(backoff(attempt), signal);
+          continue;
+        }
+        throw error;
+      }
+      if (res.ok) {
+        try {
+          return await readBody(res, req.responseType);
+        } catch (err) {
+          if (signal?.aborted) throw signal.reason;
+          if (err instanceof PantechError) throw err;
+          throw connectionError(err, attemptSignal.timedOut(), isWrite);
+        } finally {
+          if (req.responseType !== "response") attemptSignal.done();
+          else attemptSignal.stopTimer();
+        }
+      }
+      let text = "";
+      try {
+        text = await res.text();
+      } catch {
+        text = "";
+      } finally {
+        attemptSignal.done();
+      }
+      const retryAfter = parseRetryAfter(res.headers.get("retry-after"));
+      if (canRetry && RETRY_STATUSES.has(res.status) && (!req.noRetry || res.status === 429)) {
+        await sleep(retryAfter !== void 0 ? Math.min(retryAfter, MAX_RETRY_AFTER_MS) : backoff(attempt), signal);
+        continue;
+      }
+      throw errorFromResponse(
+        res.status,
+        res.headers,
+        text,
+        retryAfter === void 0 ? void 0 : Math.ceil(retryAfter / 1e3)
+      );
+    }
+  }
+};
+function queryString(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    for (const v of Array.isArray(value) ? value : [value]) params.append(key, String(v));
+  }
+  const s = params.toString();
+  return s ? `?${s}` : "";
+}
+async function readBody(res, type) {
+  if (type === "response") return res;
+  if (type === "arrayBuffer") return res.arrayBuffer();
+  const text = await res.text();
+  if (res.status === 204 || text === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    throw new PantechError("The Pantech API sent a response that is not valid JSON.", {
+      status: res.status,
+      requestId: res.headers.get("x-request-id") ?? void 0,
+      headers: res.headers,
+      cause
+    });
+  }
+}
+function backoff(attempt) {
+  const base = Math.min(500 * 2 ** attempt, 8e3);
+  return base * (1 - Math.random() * 0.25);
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  const date = Date.parse(value);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return void 0;
+}
+function connectionError(cause, timedOut, isWrite) {
+  const maybeApplied = isWrite ? " The change may still have gone through: check before trying again, and retry with the same idempotencyKey." : " Try again in a moment.";
+  if (timedOut) return new APITimeoutError(`The Pantech API did not answer in time.${maybeApplied}`, { cause });
+  return new APIConnectionError(
+    isWrite ? `The connection to the Pantech API failed.${maybeApplied}` : "Could not reach the Pantech API. Check the network connection and try again.",
+    { cause }
+  );
+}
+function linkSignal(parent, timeout) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const onAbort = () => controller.abort(parent?.reason);
+  if (parent?.aborted) controller.abort(parent.reason);
+  else parent?.addEventListener("abort", onAbort, { once: true });
+  const timer = timeout > 0 && Number.isFinite(timeout) ? setTimeout(() => {
+    timedOut = true;
+    controller.abort(new APITimeoutError("The Pantech API did not answer in time."));
+  }, timeout) : void 0;
+  return {
+    signal: controller.signal,
+    timedOut: () => timedOut,
+    /** For a streamed body: the timeout covers the headers only. */
+    stopTimer: () => clearTimeout(timer),
+    done: () => {
+      clearTimeout(timer);
+      parent?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+
+// src/webhooks.ts
+var WEBHOOK_SIGNATURE_HEADER = "Pantech-Signature";
+var DEFAULT_WEBHOOK_TOLERANCE_SECONDS = 300;
+var encoder = new TextEncoder();
+function bytes(body) {
+  if (typeof body === "string") return encoder.encode(body);
+  return body instanceof Uint8Array ? body : new Uint8Array(body);
+}
+function subtle() {
+  const s = globalThis.crypto?.subtle;
+  if (!s) {
+    throw new PantechError(
+      "Web Crypto is not available in this runtime. On Node.js 18 start node with --experimental-global-webcrypto, or use Node.js 20 or later."
+    );
+  }
+  return s;
+}
+async function hmacHex(secret, timestamp, body) {
+  const s = subtle();
+  const key = await s.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const prefix = encoder.encode(`${timestamp}.`);
+  const message = new Uint8Array(prefix.length + body.length);
+  message.set(prefix, 0);
+  message.set(body, prefix.length);
+  const mac = new Uint8Array(await s.sign("HMAC", key, message));
+  return Array.from(mac, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+async function verifyWebhook(options) {
+  const { secret, header } = options;
+  if (!secret) throw new WebhookVerificationError("No webhook secret was given to verify the signature with.");
+  if (!header) throw new WebhookVerificationError(`The ${WEBHOOK_SIGNATURE_HEADER} header is missing.`);
+  let timestamp;
+  const signatures = [];
+  for (const part of header.split(",")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key === "t") timestamp = value;
+    else if (key === "v1" && value) signatures.push(value.toLowerCase());
+  }
+  if (!timestamp || !/^\d+$/.test(timestamp) || signatures.length === 0) {
+    throw new WebhookVerificationError(`The ${WEBHOOK_SIGNATURE_HEADER} header is malformed.`);
+  }
+  const tolerance = options.toleranceSeconds ?? DEFAULT_WEBHOOK_TOLERANCE_SECONDS;
+  const now = options.now ?? Math.floor(Date.now() / 1e3);
+  if (tolerance > 0 && Math.abs(now - Number(timestamp)) > tolerance) {
+    throw new WebhookVerificationError(
+      `The webhook's timestamp is more than ${tolerance} seconds from now. Check the server's clock, or this may be a replayed delivery.`
+    );
+  }
+  const expected = await hmacHex(secret, timestamp, bytes(options.body));
+  let matched = false;
+  for (const signature of signatures) {
+    if (timingSafeEqual(expected, signature)) matched = true;
+  }
+  if (!matched) {
+    throw new WebhookVerificationError(
+      "The webhook signature does not match. Check the secret, and pass the raw body."
+    );
+  }
+}
+async function signWebhook(options) {
+  const t = String(options.timestamp ?? Math.floor(Date.now() / 1e3));
+  return `t=${t},v1=${await hmacHex(options.secret, t, bytes(options.body))}`;
+}
+
+exports.APIConnectionError = APIConnectionError;
+exports.APITimeoutError = APITimeoutError;
+exports.AuthenticationError = AuthenticationError;
+exports.BadRequestError = BadRequestError;
+exports.ConflictError = ConflictError;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.DEFAULT_WEBHOOK_TOLERANCE_SECONDS = DEFAULT_WEBHOOK_TOLERANCE_SECONDS;
+exports.InternalServerError = InternalServerError;
+exports.NotFoundError = NotFoundError;
+exports.OperationFailedError = OperationFailedError;
+exports.OrderFailedError = OrderFailedError;
+exports.Pantech = Pantech;
+exports.PantechError = PantechError;
+exports.PaymentRequiredError = PaymentRequiredError;
+exports.PermissionDeniedError = PermissionDeniedError;
+exports.RateLimitError = RateLimitError;
+exports.VERSION = VERSION;
+exports.ValidationError = ValidationError;
+exports.WEBHOOK_SIGNATURE_HEADER = WEBHOOK_SIGNATURE_HEADER;
+exports.WaitTimeoutError = WaitTimeoutError;
+exports.WebhookVerificationError = WebhookVerificationError;
+exports.isPantechError = isPantechError;
+exports.paginate = paginate;
+exports.signWebhook = signWebhook;
+exports.verifyWebhook = verifyWebhook;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map