@syscli/oneclickdz 0.1.0

package/dist/index.cjs

@@ -0,0 +1,934 @@
+'use strict';
+
+// src/errors.ts
+var OneClickError = class extends Error {
+  /** HTTP status, or undefined for a client-side or network error. */
+  status;
+  code;
+  details;
+  requestId;
+  body;
+  constructor(message, code, options = {}) {
+    super(
+      message,
+      options.cause !== void 0 ? { cause: options.cause } : void 0
+    );
+    this.name = new.target.name;
+    this.code = code;
+    this.status = options.status;
+    this.details = options.details;
+    this.requestId = options.requestId;
+    this.body = options.body;
+  }
+};
+var AuthError = class extends OneClickError {
+};
+var ForbiddenError = class extends OneClickError {
+};
+var InsufficientBalanceError = class extends ForbiddenError {
+};
+var DuplicateRefError = class extends ForbiddenError {
+};
+var ValidationError = class extends OneClickError {
+  issues;
+  constructor(message, options = {}) {
+    super(message, options.code ?? "ERR_VALIDATION", options);
+    this.issues = options.issues ?? [];
+  }
+};
+var NotFoundError = class extends OneClickError {
+};
+var RateLimitError = class extends OneClickError {
+  retryAfter;
+  constructor(message, options = {}) {
+    super(message, "RATE_LIMIT_EXCEEDED", options);
+    this.retryAfter = options.retryAfter;
+  }
+};
+var ServiceError = class extends OneClickError {
+};
+var NetworkError = class extends OneClickError {
+  constructor(message, options = {}) {
+    super(message, "network", options);
+  }
+};
+var RequestError = class extends OneClickError {
+};
+function errorFromResponse(status, body, retryAfter) {
+  const apiError = readApiError(body);
+  const code = apiError.code;
+  const message = apiError.message ?? `Request failed with status ${status}.`;
+  const options = {
+    status,
+    body,
+    requestId: readRequestId(body),
+    details: apiError.details
+  };
+  switch (code) {
+    case "MISSING_ACCESS_TOKEN":
+    case "INVALID_ACCESS_TOKEN":
+    case "ERR_AUTH":
+      return new AuthError(message, code, options);
+    case "NO_BALANCE":
+    case "INSUFFICIENT_BALANCE":
+      return new InsufficientBalanceError(message, code, options);
+    case "DUPLICATED_REF":
+      return new DuplicateRefError(message, code, options);
+    case "IP_BLOCKED":
+    case "IP_NOT_ALLOWED":
+      return new ForbiddenError(message, code, options);
+    case "ERR_VALIDATION":
+    case "ERR_PHONE":
+    case "ERR_STOCK":
+      return new ValidationError(message, { ...options, code });
+    case "NOT_FOUND":
+      return new NotFoundError(message, code, options);
+    case "RATE_LIMIT_EXCEEDED":
+      return new RateLimitError(message, { ...options, retryAfter });
+    case "INTERNAL_SERVER_ERROR":
+    case "INTERNAL_ERROR":
+    case "ERR_SERVICE":
+      return new ServiceError(message, code, options);
+  }
+  return errorFromStatus(status, message, options, code, retryAfter);
+}
+function errorFromStatus(status, message, options, code, retryAfter) {
+  if (status === 401) return new AuthError(message, code ?? "ERR_AUTH", options);
+  if (status === 403)
+    return new ForbiddenError(message, code ?? "ERR_AUTH", options);
+  if (status === 404)
+    return new NotFoundError(message, code ?? "NOT_FOUND", options);
+  if (status === 429)
+    return new RateLimitError(message, { ...options, retryAfter });
+  if (status >= 500)
+    return new ServiceError(message, code ?? "INTERNAL_SERVER_ERROR", options);
+  return new RequestError(message, code ?? "ERR_VALIDATION", options);
+}
+function readApiError(body) {
+  if (body && typeof body === "object" && "error" in body) {
+    const inner = body.error;
+    if (inner && typeof inner === "object") {
+      const e = inner;
+      return {
+        code: typeof e.code === "string" ? e.code : void 0,
+        message: typeof e.message === "string" ? e.message : void 0,
+        details: e.details
+      };
+    }
+  }
+  return {};
+}
+function readRequestId(body) {
+  if (body && typeof body === "object" && "requestId" in body) {
+    const id = body.requestId;
+    if (typeof id === "string") return id;
+  }
+  return void 0;
+}
+
+// src/http.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function encodeQuery(params) {
+  if (!params) return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    parts.push(
+      `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+    );
+  }
+  return parts.length ? `?${parts.join("&")}` : "";
+}
+function buildHeaders(config, hasBody) {
+  const headers = {
+    "X-Access-Token": config.key,
+    Accept: "application/json"
+  };
+  if (hasBody) headers["Content-Type"] = "application/json";
+  return headers;
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds);
+  const at = Date.parse(value);
+  if (Number.isNaN(at)) return void 0;
+  return Math.max(0, Math.round((at - Date.now()) / 1e3));
+}
+var HttpClient = class {
+  config;
+  constructor(config) {
+    this.config = {
+      ...config,
+      baseUrl: config.baseUrl.endsWith("/") ? config.baseUrl : `${config.baseUrl}/`
+    };
+  }
+  /**
+   * Send a request and return the unwrapped envelope.
+   *
+   * Retry policy is deliberately narrow. A 429 is always safe to retry, since
+   * the request was rejected before processing. A 5xx or a dropped connection is
+   * retried only for GET: a send that timed out may still have gone through, and
+   * a blind retry could charge the account twice. Use a `ref` for safe resends.
+   */
+  async request(method, path, options = {}) {
+    const maxAttempts = Math.max(1, this.config.retry.attempts);
+    const idempotent = method === "GET";
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return await this.send(method, path, options);
+      } catch (error) {
+        if (attempt >= maxAttempts || !this.retryable(error, idempotent)) {
+          throw error;
+        }
+        await sleep(this.backoffMs(error, attempt));
+      }
+    }
+  }
+  retryable(error, idempotent) {
+    if (error instanceof RateLimitError) return true;
+    if (error instanceof ServiceError) return idempotent;
+    if (error instanceof NetworkError) return idempotent;
+    return false;
+  }
+  /** Wait the API's Retry-After when offered, otherwise an exponential backoff. */
+  backoffMs(error, attempt) {
+    if (error instanceof RateLimitError && this.config.retry.respectRetryAfter && error.retryAfter !== void 0) {
+      return error.retryAfter * 1e3;
+    }
+    return Math.min(2 ** (attempt - 1) * 500, 3e4);
+  }
+  async send(method, path, options) {
+    const hasBody = options.body !== void 0;
+    const url = new URL(path, this.config.baseUrl);
+    const target = `${url.toString()}${encodeQuery(options.query)}`;
+    const headers = buildHeaders(this.config, hasBody);
+    const controller = new AbortController();
+    const timer = this.config.timeoutMs > 0 ? setTimeout(() => controller.abort(), this.config.timeoutMs) : void 0;
+    if (options.signal) {
+      if (options.signal.aborted) controller.abort();
+      else
+        options.signal.addEventListener("abort", () => controller.abort(), {
+          once: true
+        });
+    }
+    let response;
+    try {
+      response = await this.config.fetch(target, {
+        method,
+        headers,
+        body: hasBody ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+    } catch (cause) {
+      if (options.signal?.aborted) throw cause;
+      const reason = cause instanceof Error ? cause.message : "request failed";
+      throw new NetworkError(`Could not reach the API: ${reason}.`, { cause });
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+    const text = await response.text();
+    let body;
+    try {
+      body = text ? JSON.parse(text) : void 0;
+    } catch {
+      body = text;
+    }
+    if (!response.ok) {
+      const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+      throw errorFromResponse(response.status, body, retryAfter);
+    }
+    return this.toEnvelope(body, response.status);
+  }
+  /** Confirm the body is a success envelope before handing it back. */
+  toEnvelope(body, status) {
+    if (body && typeof body === "object" && "success" in body) {
+      if (body.success === false) {
+        throw errorFromResponse(status, body);
+      }
+      return body;
+    }
+    throw new OneClickError(
+      "The API returned a response in an unexpected shape.",
+      "ERR_SERVICE",
+      { status, body }
+    );
+  }
+};
+
+// src/resources/base.ts
+var Resource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** GET a path and return its `data` payload. */
+  async getData(path, query, signal) {
+    const env = await this.http.request("GET", path, { query, signal });
+    return env.data;
+  }
+  /** POST a body and return the `data` payload. */
+  async postData(path, body, signal) {
+    const env = await this.http.request("POST", path, { body, signal });
+    return env.data;
+  }
+  /**
+   * Fetch one page of a list. `extract` pulls the items and the pagination block
+   * out of whatever shape the endpoint nests them in; it gets the whole envelope
+   * because some endpoints keep pagination in `data` and others in `meta`.
+   * `next()` reissues the same request with the page number bumped.
+   */
+  async fetchPage(path, query, extract) {
+    const env = await this.http.request("GET", path, { query });
+    const { items, pagination } = extract(env);
+    const hasMore = pagination.page < pagination.totalPages;
+    return {
+      items,
+      ...pagination,
+      hasMore,
+      next: hasMore ? () => this.fetchPage(
+        path,
+        { ...query, page: pagination.page + 1 },
+        extract
+      ) : async () => void 0
+    };
+  }
+  /** Walk every item across every page, starting from a first-page promise. */
+  async *iterate(first) {
+    let page = await first;
+    while (page) {
+      for (const item of page.items) yield item;
+      page = await page.next();
+    }
+  }
+};
+
+// src/resources/core.ts
+var Core = class extends Resource {
+  /** Check the API and each operator's reachability. */
+  ping(signal) {
+    return this.getData("ping", void 0, signal);
+  }
+  /** Confirm the key and read its environment, scope, and IP allowlist. */
+  validate(signal) {
+    return this.getData("validate", void 0, signal);
+  }
+};
+
+// src/resources/account.ts
+function extractTransactions(env) {
+  const d = env.data ?? {};
+  return {
+    items: d.items ?? [],
+    pagination: d.pagination ?? { page: 1, pageSize: 0, totalPages: 1, totalResults: 0 }
+  };
+}
+var Account = class extends Resource {
+  /** The current balance in dinars. */
+  balance(signal) {
+    return this.getData("account/balance", void 0, signal);
+  }
+  /** One page of the transaction ledger, newest first. */
+  transactions(params = {}) {
+    return this.fetchPage(
+      "account/transactions",
+      { ...params },
+      extractTransactions
+    );
+  }
+  /** Every transaction across every page, as an async iterator. */
+  paginateTransactions(params = {}) {
+    return this.iterate(this.transactions(params));
+  }
+};
+
+// src/types.ts
+var TOPUP_TERMINAL = [
+  "FULFILLED",
+  "REFUNDED",
+  "UNKNOWN_ERROR"
+];
+var GIFT_TERMINAL = [
+  "FULFILLED",
+  "PARTIALLY_FILLED",
+  "REFUNDED"
+];
+var PAYMENT_TERMINAL = [
+  "CONFIRMED",
+  "FAILED"
+];
+
+// src/poll.ts
+var PollTimeoutError = class extends OneClickError {
+  /** The most recent value seen before time ran out. */
+  last;
+  constructor(message, last, attempts) {
+    super(message, "poll_timeout", { details: { attempts } });
+    this.last = last;
+  }
+};
+async function pollUntil(fetchOnce, isDone, options = {}) {
+  const intervalMs = options.intervalMs ?? 5e3;
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 60);
+  let last;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    throwIfAborted(options.signal);
+    last = await fetchOnce();
+    if (isDone(last)) return last;
+    if (attempt < maxAttempts) await delay(intervalMs, options.signal);
+  }
+  throw new PollTimeoutError(
+    `Gave up after ${maxAttempts} checks without a final status.`,
+    last,
+    maxAttempts
+  );
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw abortReason(signal);
+}
+function abortReason(signal) {
+  const reason = signal.reason;
+  if (reason !== void 0) return reason;
+  const error = new Error("The wait was aborted.");
+  error.name = "AbortError";
+  return error;
+}
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortReason(signal));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/ref.ts
+function generateRef(prefix = "ocd") {
+  const uuid = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  return `${prefix}-${uuid}`;
+}
+
+// src/validate.ts
+var MOBILE_NUMBER = /^0[567]\d{8}$/;
+var ADSL_NUMBER = /^0\d{8}$/;
+var FOURG_NUMBER = /^213\d{9}$/;
+function isMobileNumber(value) {
+  return MOBILE_NUMBER.test(value);
+}
+function isAdslNumber(value) {
+  return ADSL_NUMBER.test(value);
+}
+function isFourgNumber(value) {
+  return FOURG_NUMBER.test(value);
+}
+function isWholeAmount(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1;
+}
+var Issues = class {
+  list = [];
+  /** Record a problem. The ref ties an issue to one order when checking a batch. */
+  add(field, message, ref) {
+    this.list.push(ref ? { field, message, ref } : { field, message });
+    return this;
+  }
+  /** Record a problem only when the condition holds. */
+  addIf(condition, field, message, ref) {
+    if (condition) this.add(field, message, ref);
+    return this;
+  }
+  get any() {
+    return this.list.length > 0;
+  }
+  all() {
+    return this.list;
+  }
+  /** Throw if anything was collected; otherwise do nothing. */
+  throwIfAny(summary = "The request did not pass validation.") {
+    if (this.list.length > 0) {
+      throw new ValidationError(summary, { issues: this.list });
+    }
+  }
+};
+function requireText(issues, value, field, ref) {
+  if (typeof value !== "string" || value.trim() === "") {
+    issues.add(field, "is required", ref);
+  }
+}
+
+// src/resources/mobile.ts
+function extractTopups(env) {
+  const d = env.data ?? {};
+  return {
+    items: d.items ?? [],
+    pagination: d.pagination ?? { page: 1, pageSize: 0, totalPages: 1, totalResults: 0 }
+  };
+}
+function validateSend(input) {
+  const issues = new Issues();
+  requireText(issues, input.plan_code, "plan_code");
+  if (typeof input.MSSIDN !== "string" || !isMobileNumber(input.MSSIDN)) {
+    issues.add("MSSIDN", "is not a valid mobile number");
+  }
+  if (input.amount !== void 0 && !isWholeAmount(input.amount)) {
+    issues.add("amount", "must be a whole number of dinars");
+  }
+  issues.throwIfAny("The top-up did not pass validation.");
+}
+var isTerminal = (t) => TOPUP_TERMINAL.includes(t.status);
+var Mobile = class extends Resource {
+  /** The plans available to your account, split into dynamic and fixed. */
+  plans(signal) {
+    return this.getData("mobile/plans", void 0, signal);
+  }
+  /**
+   * Send a top-up. The number and amount are checked first, and a reference is
+   * generated when you do not pass one, so the returned `topupRef` is always set.
+   */
+  async send(input, signal) {
+    validateSend(input);
+    const body = { ...input, ref: input.ref ?? generateRef() };
+    return this.postData("mobile/send", body, signal);
+  }
+  /** Look a top-up up by your own reference. */
+  checkByRef(ref, signal) {
+    return this.getData(
+      `mobile/check-ref/${encodeURIComponent(ref)}`,
+      void 0,
+      signal
+    );
+  }
+  /** Look a top-up up by the id from `send`. */
+  checkById(id, signal) {
+    return this.getData(
+      `mobile/check-id/${encodeURIComponent(id)}`,
+      void 0,
+      signal
+    );
+  }
+  /**
+   * Send a top-up and wait for it to settle, polling by reference. Resolves with
+   * the final top-up once it is FULFILLED, REFUNDED, or UNKNOWN_ERROR. Defaults
+   * to a check every 5 seconds for up to 5 minutes, which the docs recommend.
+   */
+  async sendAndWait(input, options = {}) {
+    const ref = input.ref ?? generateRef();
+    await this.send({ ...input, ref }, options.signal);
+    return pollUntil(() => this.checkByRef(ref, options.signal), isTerminal, {
+      intervalMs: 5e3,
+      maxAttempts: 60,
+      ...options
+    });
+  }
+  /** One page of your past top-ups, newest first. */
+  list(params = {}) {
+    return this.fetchPage("mobile/list", { ...params }, extractTopups);
+  }
+  /** Every past top-up across every page, as an async iterator. */
+  paginate(params = {}) {
+    return this.iterate(this.list(params));
+  }
+};
+
+// src/secret.ts
+var REDACTED = "[redacted]";
+var INSPECT = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var Secret = class _Secret {
+  // A private field is neither enumerable nor reachable by Object.keys or a
+  // spread, so the value cannot leak through ordinary object handling.
+  #value;
+  constructor(value) {
+    this.#value = value;
+  }
+  /** The real value. Calling this is the deliberate, searchable moment a secret is read. */
+  reveal() {
+    return this.#value;
+  }
+  /** Used by JSON.stringify, so a secret nested in an object serializes redacted. */
+  toJSON() {
+    return REDACTED;
+  }
+  toString() {
+    return REDACTED;
+  }
+  [INSPECT]() {
+    return `Secret(${REDACTED})`;
+  }
+  static of(value) {
+    return new _Secret(value);
+  }
+};
+function isSecret(value) {
+  return value instanceof Secret;
+}
+function reveal(value) {
+  return value instanceof Secret ? value.reveal() : value;
+}
+
+// src/resources/internet.ts
+function toTopup(raw) {
+  const { card_code, ...rest } = raw;
+  return card_code ? { ...rest, card_code: Secret.of(card_code) } : { ...rest };
+}
+function extractInternetTopups(env) {
+  const data = env.data ?? {};
+  const page = env.meta?.pagination ?? {};
+  const items = (data.topups ?? []).map(toTopup);
+  return {
+    items,
+    pagination: {
+      page: page.currentPage ?? page.page ?? 1,
+      pageSize: items.length,
+      totalPages: page.totalPages ?? 1,
+      totalResults: page.totalItems ?? page.totalResults ?? items.length
+    }
+  };
+}
+function validateSend2(input) {
+  const issues = new Issues();
+  if (input.type !== "ADSL" && input.type !== "4G") {
+    issues.add("type", "must be ADSL or 4G");
+  } else if (input.type === "ADSL" && !isAdslNumber(input.number)) {
+    issues.add("number", "is not a valid ADSL number");
+  } else if (input.type === "4G" && !isFourgNumber(input.number)) {
+    issues.add("number", "is not a valid 4G number");
+  }
+  if (!isWholeAmount(input.value)) {
+    issues.add("value", "must be a whole number of dinars");
+  }
+  issues.throwIfAny("The internet top-up did not pass validation.");
+}
+var isTerminal2 = (t) => TOPUP_TERMINAL.includes(t.status);
+var Internet = class extends Resource {
+  /** The cards on offer for a service type, with their cost and stock. */
+  products(type, signal) {
+    return this.getData("internet/products", { type }, signal);
+  }
+  /** Confirm a number is valid and active before sending to it. */
+  checkNumber(type, number, signal) {
+    return this.getData(
+      "internet/check-number",
+      { type, number },
+      signal
+    );
+  }
+  /** Send a recharge. The number and value are checked first; a ref is filled in. */
+  async send(input, signal) {
+    validateSend2(input);
+    const body = { ...input, ref: input.ref ?? generateRef() };
+    return this.postData("internet/send", body, signal);
+  }
+  async checkByRef(ref, signal) {
+    const raw = await this.getData(
+      `internet/check-ref/${encodeURIComponent(ref)}`,
+      void 0,
+      signal
+    );
+    return toTopup(raw);
+  }
+  async checkById(id, signal) {
+    const raw = await this.getData(
+      `internet/check-id/${encodeURIComponent(id)}`,
+      void 0,
+      signal
+    );
+    return toTopup(raw);
+  }
+  /**
+   * Send and wait for the recharge to settle. Resolves with the final order,
+   * its `card_code` ready to reveal once FULFILLED. A QUEUED order can take up to
+   * 48 hours, well past the default polling window, so expect a timeout there.
+   */
+  async sendAndWait(input, options = {}) {
+    const ref = input.ref ?? generateRef();
+    await this.send({ ...input, ref }, options.signal);
+    return pollUntil(() => this.checkByRef(ref, options.signal), isTerminal2, {
+      intervalMs: 5e3,
+      maxAttempts: 60,
+      ...options
+    });
+  }
+  list(params = {}) {
+    return this.fetchPage(
+      "internet/list",
+      { ...params },
+      extractInternetTopups
+    );
+  }
+  paginate(params = {}) {
+    return this.iterate(this.list(params));
+  }
+};
+
+// src/resources/giftcards.ts
+function toOrder(raw) {
+  const cards = (raw.cards ?? []).map((card) => ({
+    value: Secret.of(card.value ?? ""),
+    serial: Secret.of(card.serial ?? "")
+  }));
+  return { ...raw, cards };
+}
+function extractOrders(env) {
+  const d = env.data ?? {};
+  return {
+    items: (d.items ?? []).map(toOrder),
+    pagination: d.pagination ?? { page: 1, pageSize: 0, totalPages: 1, totalResults: 0 }
+  };
+}
+function validateOrder(input) {
+  const issues = new Issues();
+  requireText(issues, input.productId, "productId");
+  requireText(issues, input.typeId, "typeId");
+  if (!Number.isInteger(input.quantity) || input.quantity < 1) {
+    issues.add("quantity", "must be a whole number of one or more");
+  }
+  issues.throwIfAny("The gift-card order did not pass validation.");
+}
+var isTerminal3 = (o) => GIFT_TERMINAL.includes(o.status);
+var GiftCards = class extends Resource {
+  /** The full product catalog. Cache it; the docs say it changes rarely. */
+  async catalog(signal) {
+    const env = await this.http.request(
+      "GET",
+      "gift-cards/catalog",
+      { signal }
+    );
+    return {
+      categories: env.data.categories ?? [],
+      totalCategories: env.totalCategories,
+      totalProducts: env.totalProducts
+    };
+  }
+  /** A product's denominations, with live pricing and stock. */
+  checkProduct(productId, signal) {
+    return this.getData(
+      `gift-cards/checkProduct/${encodeURIComponent(productId)}`,
+      void 0,
+      signal
+    );
+  }
+  /** Place an order. The product, type, and quantity are checked first. */
+  async placeOrder(input, signal) {
+    validateOrder(input);
+    return this.postData(
+      "gift-cards/placeOrder",
+      input,
+      signal
+    );
+  }
+  /** Read an order's status and, once settled, its cards. */
+  async checkOrder(orderId, signal) {
+    const raw = await this.getData(
+      `gift-cards/checkOrder/${encodeURIComponent(orderId)}`,
+      void 0,
+      signal
+    );
+    return toOrder(raw);
+  }
+  /**
+   * Place an order and wait for it to settle. Resolves once the order is
+   * FULFILLED, PARTIALLY_FILLED, or REFUNDED. Gift cards can take longer than a
+   * top-up, so this checks every 5 seconds for up to 10 minutes by default.
+   */
+  async placeOrderAndWait(input, options = {}) {
+    const { orderId } = await this.placeOrder(input, options.signal);
+    return pollUntil(
+      () => this.checkOrder(orderId, options.signal),
+      isTerminal3,
+      { intervalMs: 5e3, maxAttempts: 120, ...options }
+    );
+  }
+  /** One page of past orders, newest first. */
+  listOrders(params = {}) {
+    return this.fetchPage(
+      "gift-cards/list",
+      { ...params },
+      extractOrders
+    );
+  }
+  /** Every past order across every page, as an async iterator. */
+  paginateOrders(params = {}) {
+    return this.iterate(this.listOrders(params));
+  }
+};
+
+// src/resources/payments.ts
+var MIN_PAYMENT_AMOUNT = 500;
+var MAX_PAYMENT_AMOUNT = 5e5;
+function validateCreateLink(input) {
+  const issues = new Issues();
+  const info = input.productInfo ?? {};
+  requireText(issues, info.title, "productInfo.title");
+  if (typeof info.title === "string" && info.title.length > 200) {
+    issues.add("productInfo.title", "must be at most 200 characters");
+  }
+  if (!isWholeAmount(info.amount)) {
+    issues.add("productInfo.amount", "must be a whole number of dinars");
+  } else if (info.amount < MIN_PAYMENT_AMOUNT || info.amount > MAX_PAYMENT_AMOUNT) {
+    issues.add(
+      "productInfo.amount",
+      `must be between ${MIN_PAYMENT_AMOUNT} and ${MAX_PAYMENT_AMOUNT}`
+    );
+  }
+  if (info.description !== void 0 && info.description.length > 1e3) {
+    issues.add("productInfo.description", "must be at most 1000 characters");
+  }
+  if (input.successMessage !== void 0 && input.successMessage.length > 500) {
+    issues.add("successMessage", "must be at most 500 characters");
+  }
+  if (input.feeMode !== void 0 && input.feeMode !== "NO_FEE" && input.feeMode !== "SPLIT_FEE" && input.feeMode !== "CUSTOMER_FEE") {
+    issues.add("feeMode", "must be NO_FEE, SPLIT_FEE, or CUSTOMER_FEE");
+  }
+  if (input.redirectUrl !== void 0 && !/^https?:\/\//.test(input.redirectUrl)) {
+    issues.add("redirectUrl", "must start with http:// or https://");
+  }
+  issues.throwIfAny("The payment link did not pass validation.");
+}
+var isTerminal4 = (p) => PAYMENT_TERMINAL.includes(p.status);
+var Payments = class extends Resource {
+  /** Create a payment link. Returns the URL to send the customer to. */
+  async createLink(input, signal) {
+    validateCreateLink(input);
+    return this.postData("ocpay/createLink", input, signal);
+  }
+  /** Check a payment's status by its reference. */
+  checkPayment(ref, signal) {
+    return this.getData(
+      `ocpay/checkPayment/${encodeURIComponent(ref)}`,
+      void 0,
+      signal
+    );
+  }
+  /**
+   * Poll a payment until it is CONFIRMED or FAILED. The default window is twenty
+   * minutes, matching how long an unpaid link stays open; a payment that is
+   * never started times out with a PollTimeoutError. Pass a signal to stop early.
+   */
+  waitForPayment(ref, options = {}) {
+    return pollUntil(
+      () => this.checkPayment(ref, options.signal),
+      isTerminal4,
+      { intervalMs: 5e3, maxAttempts: 240, ...options }
+    );
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.oneclickdz.com/v3";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_RETRY = { attempts: 3, respectRetryAfter: true };
+var OneClickDZ = class {
+  core;
+  account;
+  mobile;
+  internet;
+  giftCards;
+  payments;
+  http;
+  constructor(options) {
+    if (!options.key) {
+      throw new Error("OneClickDZ needs an access token in options.key.");
+    }
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new Error(
+        "No fetch is available. Run on Node 18+ or pass one in options.fetch."
+      );
+    }
+    this.http = new HttpClient({
+      key: options.key,
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+      timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      retry: { ...DEFAULT_RETRY, ...options.retry },
+      fetch: fetchImpl
+    });
+    this.core = new Core(this.http);
+    this.account = new Account(this.http);
+    this.mobile = new Mobile(this.http);
+    this.internet = new Internet(this.http);
+    this.giftCards = new GiftCards(this.http);
+    this.payments = new Payments(this.http);
+  }
+  /** Shortcut for `core.ping()`: the API and operator status. */
+  ping(signal) {
+    return this.core.ping(signal);
+  }
+  /** Shortcut for `core.validate()`: confirm the key and read its environment. */
+  validate(signal) {
+    return this.core.validate(signal);
+  }
+};
+
+// src/pricing.ts
+function sellPrice(cost, markup) {
+  const raw = "percent" in markup ? cost * (1 + markup.percent / 100) : cost + markup.flat;
+  return Math.round(raw);
+}
+function priceInternetProducts(products, markup) {
+  return products.map((p) => ({
+    value: p.value,
+    price: sellPrice(p.cost, markup),
+    available: p.available
+  }));
+}
+function priceGiftTypes(types, markup) {
+  return types.map((t) => ({
+    id: t.id,
+    name: t.name,
+    price: sellPrice(t.price, markup),
+    inStock: t.quantity > 0
+  }));
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+exports.ADSL_NUMBER = ADSL_NUMBER;
+exports.Account = Account;
+exports.AuthError = AuthError;
+exports.Core = Core;
+exports.DuplicateRefError = DuplicateRefError;
+exports.FOURG_NUMBER = FOURG_NUMBER;
+exports.ForbiddenError = ForbiddenError;
+exports.GIFT_TERMINAL = GIFT_TERMINAL;
+exports.GiftCards = GiftCards;
+exports.InsufficientBalanceError = InsufficientBalanceError;
+exports.Internet = Internet;
+exports.Issues = Issues;
+exports.MAX_PAYMENT_AMOUNT = MAX_PAYMENT_AMOUNT;
+exports.MIN_PAYMENT_AMOUNT = MIN_PAYMENT_AMOUNT;
+exports.MOBILE_NUMBER = MOBILE_NUMBER;
+exports.Mobile = Mobile;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.OneClickDZ = OneClickDZ;
+exports.OneClickError = OneClickError;
+exports.PAYMENT_TERMINAL = PAYMENT_TERMINAL;
+exports.Payments = Payments;
+exports.PollTimeoutError = PollTimeoutError;
+exports.RateLimitError = RateLimitError;
+exports.RequestError = RequestError;
+exports.Secret = Secret;
+exports.ServiceError = ServiceError;
+exports.TOPUP_TERMINAL = TOPUP_TERMINAL;
+exports.VERSION = VERSION;
+exports.ValidationError = ValidationError;
+exports.errorFromResponse = errorFromResponse;
+exports.generateRef = generateRef;
+exports.isAdslNumber = isAdslNumber;
+exports.isFourgNumber = isFourgNumber;
+exports.isMobileNumber = isMobileNumber;
+exports.isSecret = isSecret;
+exports.isWholeAmount = isWholeAmount;
+exports.pollUntil = pollUntil;
+exports.priceGiftTypes = priceGiftTypes;
+exports.priceInternetProducts = priceInternetProducts;
+exports.requireText = requireText;
+exports.reveal = reveal;
+exports.sellPrice = sellPrice;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map