@strimz/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,831 @@
+'use strict';
+
+var sharedConfig = require('@strimz/shared-config');
+var sharedTypes = require('@strimz/shared-types');
+var sharedCrypto = require('@strimz/shared-crypto');
+
+// src/client.ts
+
+// src/errors.ts
+var StrimzError = class extends Error {
+  code;
+  httpStatus;
+  requestId;
+  param;
+  details;
+  constructor(body, httpStatus) {
+    super(body.message);
+    this.name = "StrimzError";
+    this.code = body.code;
+    this.httpStatus = httpStatus;
+    this.requestId = body.requestId;
+    this.param = body.param;
+    this.details = body.details;
+  }
+};
+var StrimzAuthenticationError = class extends StrimzError {
+  constructor(body, httpStatus) {
+    super(body, httpStatus);
+    this.name = "StrimzAuthenticationError";
+  }
+};
+var StrimzPermissionError = class extends StrimzError {
+  constructor(body, httpStatus) {
+    super(body, httpStatus);
+    this.name = "StrimzPermissionError";
+  }
+};
+var StrimzValidationError = class extends StrimzError {
+  constructor(body, httpStatus) {
+    super(body, httpStatus);
+    this.name = "StrimzValidationError";
+  }
+};
+var StrimzNotFoundError = class extends StrimzError {
+  constructor(body, httpStatus) {
+    super(body, httpStatus);
+    this.name = "StrimzNotFoundError";
+  }
+};
+var StrimzIdempotencyError = class extends StrimzError {
+  constructor(body, httpStatus) {
+    super(body, httpStatus);
+    this.name = "StrimzIdempotencyError";
+  }
+};
+var StrimzRateLimitError = class extends StrimzError {
+  retryAfterMs;
+  constructor(body, httpStatus, retryAfterMs) {
+    super(body, httpStatus);
+    this.name = "StrimzRateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var StrimzNetworkError = class extends StrimzError {
+  cause;
+  constructor(message, cause) {
+    super({ code: "network_error", message });
+    this.name = "StrimzNetworkError";
+    this.cause = cause;
+  }
+};
+var StrimzTimeoutError = class extends StrimzError {
+  constructor(message) {
+    super({ code: "timeout", message });
+    this.name = "StrimzTimeoutError";
+  }
+};
+var StrimzModeMismatchError = class extends StrimzError {
+  constructor(message) {
+    super({ code: "mode_mismatch", message });
+    this.name = "StrimzModeMismatchError";
+  }
+};
+function classifyError(httpStatus, body, retryAfterMs) {
+  if (httpStatus === 401) return new StrimzAuthenticationError(body, httpStatus);
+  if (httpStatus === 403) return new StrimzPermissionError(body, httpStatus);
+  if (httpStatus === 404) return new StrimzNotFoundError(body, httpStatus);
+  if (httpStatus === 409 && body.code === "idempotency_error") {
+    return new StrimzIdempotencyError(body, httpStatus);
+  }
+  if (httpStatus === 422) return new StrimzValidationError(body, httpStatus);
+  if (httpStatus === 429) return new StrimzRateLimitError(body, httpStatus, retryAfterMs);
+  return new StrimzError(body, httpStatus);
+}
+
+// src/http/headers.ts
+var HEADERS = {
+  authorization: "Authorization",
+  idempotencyKey: "X-Strimz-Idempotency-Key",
+  sdkName: "X-Strimz-Sdk",
+  sdkVersion: "X-Strimz-Sdk-Version",
+  sdkRuntime: "X-Strimz-Sdk-Runtime"
+};
+var SDK_NAME = "@strimz/sdk";
+var SDK_VERSION = "0.0.0";
+function buildBaseHeaders(apiKey, runtime) {
+  return {
+    [HEADERS.authorization]: `Bearer ${apiKey}`,
+    [HEADERS.sdkName]: SDK_NAME,
+    [HEADERS.sdkVersion]: SDK_VERSION,
+    [HEADERS.sdkRuntime]: runtime,
+    Accept: "application/json"
+  };
+}
+
+// src/http/fetcher.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_INITIAL_BACKOFF_MS = 250;
+var Fetcher = class {
+  baseUrl;
+  baseHeaders;
+  timeoutMs;
+  maxRetries;
+  initialBackoffMs;
+  onRequest;
+  onResponse;
+  fetchImpl;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/$/, "");
+    this.baseHeaders = opts.baseHeaders;
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.initialBackoffMs = opts.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF_MS;
+    this.onRequest = opts.onRequest;
+    this.onResponse = opts.onResponse;
+    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  async request(spec) {
+    const url = this.buildUrl(spec.path, spec.query);
+    const idempotent = isIdempotent(spec);
+    const headers = { ...this.baseHeaders };
+    if (spec.body != null) headers["Content-Type"] = "application/json";
+    if (spec.idempotencyKey) headers[HEADERS.idempotencyKey] = spec.idempotencyKey;
+    let attempt = 0;
+    let lastErr;
+    while (attempt <= this.maxRetries) {
+      try {
+        this.onRequest?.({ method: spec.method, url, attempt });
+        const start = Date.now();
+        const res = await this.fetchWithTimeout(
+          url,
+          {
+            method: spec.method,
+            headers,
+            body: spec.body == null ? void 0 : JSON.stringify(spec.body)
+          },
+          spec.timeoutMs ?? this.timeoutMs
+        );
+        const ms = Date.now() - start;
+        this.onResponse?.({ method: spec.method, url, status: res.status, ms, attempt });
+        if (res.ok) {
+          if (res.status === 204) return void 0;
+          return await res.json();
+        }
+        const errorBody = await parseErrorBody(res);
+        const retryAfterMs = parseRetryAfter(res);
+        if (res.status === 429 && attempt < this.maxRetries) {
+          await delay(retryAfterMs ?? this.backoffFor(attempt));
+          attempt++;
+          continue;
+        }
+        if (res.status >= 500 && idempotent && attempt < this.maxRetries) {
+          await delay(this.backoffFor(attempt));
+          attempt++;
+          continue;
+        }
+        throw classifyError(res.status, errorBody, retryAfterMs);
+      } catch (err) {
+        if (err instanceof StrimzError) throw err;
+        lastErr = err;
+        if (!isNetworkLike(err) || attempt >= this.maxRetries) {
+          if (err instanceof StrimzTimeoutError) throw err;
+          throw new StrimzNetworkError(`Network error: ${describe(err)}`, err);
+        }
+        await delay(this.backoffFor(attempt));
+        attempt++;
+      }
+    }
+    throw new StrimzNetworkError(`Network error after ${this.maxRetries} retries`, lastErr);
+  }
+  async fetchWithTimeout(url, init, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      return await this.fetchImpl(url, { ...init, signal: controller.signal });
+    } catch (err) {
+      if (isAbortError(err)) {
+        throw new StrimzTimeoutError(`Request timed out after ${timeoutMs}ms`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  buildUrl(path, query) {
+    const base = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    if (!query) return base;
+    const usp = new URLSearchParams();
+    for (const [k, v] of Object.entries(query)) {
+      if (v == null) continue;
+      usp.append(k, String(v));
+    }
+    const qs = usp.toString();
+    return qs ? `${base}?${qs}` : base;
+  }
+  backoffFor(attempt) {
+    const expo = this.initialBackoffMs * Math.pow(2, attempt);
+    const jitter = Math.random() * this.initialBackoffMs;
+    return Math.min(expo + jitter, 8e3);
+  }
+};
+function isIdempotent(spec) {
+  if (spec.method === "GET" || spec.method === "DELETE") return true;
+  return spec.idempotencyKey != null;
+}
+async function parseErrorBody(res) {
+  try {
+    const json = await res.json();
+    if (typeof json === "object" && json !== null && "error" in json && json.error) {
+      return json.error;
+    }
+    if (typeof json === "object" && json !== null && "code" in json && "message" in json) {
+      return json;
+    }
+  } catch {
+  }
+  return { code: "api_error", message: `HTTP ${res.status}` };
+}
+function parseRetryAfter(res) {
+  const v = res.headers.get("Retry-After");
+  if (!v) return void 0;
+  const n = Number(v);
+  if (Number.isFinite(n)) return Math.max(0, n) * 1e3;
+  const date = Date.parse(v);
+  if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+  return void 0;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError";
+}
+function isNetworkLike(err) {
+  if (err instanceof TypeError) return true;
+  if (err instanceof Error && /fetch|network|econn/i.test(err.message)) return true;
+  return false;
+}
+function describe(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function generateIdempotencyKey() {
+  return `strimz_${sharedCrypto.uuid()}`;
+}
+var IDEMPOTENCY_KEY_PATTERN = /^(strimz_)?[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function isValidIdempotencyKey(key) {
+  if (typeof key !== "string") return false;
+  if (key.length > 255) return false;
+  return IDEMPOTENCY_KEY_PATTERN.test(key);
+}
+
+// src/pagination.ts
+var AutoPagingIterator = class {
+  constructor(fetchPage) {
+    this.fetchPage = fetchPage;
+  }
+  fetchPage;
+  async *[Symbol.asyncIterator]() {
+    let cursor = null;
+    let first = true;
+    while (first || cursor !== null) {
+      first = false;
+      const page = await this.fetchPage(cursor);
+      for (const item of page.data) {
+        yield item;
+      }
+      cursor = page.hasMore ? page.nextCursor : null;
+    }
+  }
+  async forEach(handler) {
+    for await (const item of this) {
+      await handler(item);
+    }
+  }
+  async toArray() {
+    const out = [];
+    for await (const item of this) out.push(item);
+    return out;
+  }
+};
+
+// src/resources/base-resource.ts
+var BaseResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  async get(path, schema, query) {
+    const data = await this.ctx.fetcher.request({ method: "GET", path, query });
+    return parse(data, schema);
+  }
+  async post(path, body, schema, options) {
+    const data = await this.ctx.fetcher.request({
+      method: "POST",
+      path,
+      body,
+      idempotencyKey: options?.idempotencyKey ?? generateIdempotencyKey(),
+      timeoutMs: options?.timeoutMs
+    });
+    return parse(data, schema);
+  }
+  async patch(path, body, schema, options) {
+    const data = await this.ctx.fetcher.request({
+      method: "PATCH",
+      path,
+      body,
+      idempotencyKey: options?.idempotencyKey ?? generateIdempotencyKey(),
+      timeoutMs: options?.timeoutMs
+    });
+    return parse(data, schema);
+  }
+  async delete(path, schema) {
+    const data = await this.ctx.fetcher.request({ method: "DELETE", path });
+    return parse(data, schema);
+  }
+  listPage(path, itemSchema, params) {
+    return this.ctx.fetcher.request({ method: "GET", path, query: toQuery(params) }).then((raw) => parsePage(raw, itemSchema));
+  }
+  listAuto(path, itemSchema, params) {
+    return new AutoPagingIterator(
+      (cursor) => this.listPage(path, itemSchema, { ...params, cursor })
+    );
+  }
+};
+function toQuery(params) {
+  if (!params) return {};
+  return params;
+}
+function parse(data, schema) {
+  return schema ? schema.parse(data) : data;
+}
+function parsePage(raw, itemSchema) {
+  const obj = raw;
+  const items = (obj?.data ?? []).map((d) => itemSchema.parse(d));
+  return {
+    data: items,
+    nextCursor: obj?.nextCursor ?? null,
+    hasMore: obj?.hasMore === true
+  };
+}
+
+// src/resources/merchants.ts
+var MerchantsResource = class extends BaseResource {
+  /** The merchant the API key belongs to. */
+  me() {
+    return this.get("/v1/merchants/me", sharedTypes.merchantSchema);
+  }
+  update(input, options) {
+    sharedTypes.updateMerchantInputSchema.parse(input);
+    return this.patch("/v1/merchants/me", input, sharedTypes.merchantSchema, options);
+  }
+  changeTier(input, options) {
+    sharedTypes.changeTierInputSchema.parse(input);
+    return this.post("/v1/merchants/me/tier", input, sharedTypes.merchantSchema, options);
+  }
+};
+var ApiKeysResource = class extends BaseResource {
+  list(params) {
+    return this.listPage("/v1/api-keys", sharedTypes.apiKeySchema, params);
+  }
+  retrieve(id) {
+    return this.get(`/v1/api-keys/${encodeURIComponent(id)}`, sharedTypes.apiKeySchema);
+  }
+  create(input, options) {
+    sharedTypes.createApiKeyInputSchema.parse(input);
+    return this.post("/v1/api-keys", input, sharedTypes.createApiKeyOutputSchema, options);
+  }
+  revoke(id, options) {
+    return this.post(`/v1/api-keys/${encodeURIComponent(id)}/revoke`, {}, sharedTypes.apiKeySchema, options);
+  }
+};
+var CustomersResource = class extends BaseResource {
+  retrieve(id) {
+    return this.get(`/v1/customers/${encodeURIComponent(id)}`, sharedTypes.customerSchema);
+  }
+  list(params) {
+    return this.listPage("/v1/customers", sharedTypes.customerSchema, params);
+  }
+  upsert(input, options) {
+    sharedTypes.upsertCustomerInputSchema.parse(input);
+    return this.post("/v1/customers", input, sharedTypes.customerSchema, options);
+  }
+};
+var PaymentSessionsResource = class extends BaseResource {
+  create(input, options) {
+    sharedTypes.createPaymentSessionInputSchema.parse(input);
+    return this.post("/v1/payment-sessions", input, sharedTypes.paymentSessionSchema, options);
+  }
+  retrieve(id) {
+    return this.get(`/v1/payment-sessions/${encodeURIComponent(id)}`, sharedTypes.paymentSessionSchema);
+  }
+  list(params) {
+    return this.listPage("/v1/payment-sessions", sharedTypes.paymentSessionSchema, params);
+  }
+  cancel(id, options) {
+    return this.post(
+      `/v1/payment-sessions/${encodeURIComponent(id)}/cancel`,
+      {},
+      sharedTypes.paymentSessionSchema,
+      options
+    );
+  }
+  expire(id, options) {
+    return this.post(
+      `/v1/payment-sessions/${encodeURIComponent(id)}/expire`,
+      {},
+      sharedTypes.paymentSessionSchema,
+      options
+    );
+  }
+};
+var TransactionsResource = class extends BaseResource {
+  retrieve(id) {
+    return this.get(`/v1/transactions/${encodeURIComponent(id)}`, sharedTypes.transactionSchema);
+  }
+  list(params) {
+    return this.listPage("/v1/transactions", sharedTypes.transactionSchema, params);
+  }
+};
+var SubscriptionPlansResource = class extends BaseResource {
+  create(input, options) {
+    sharedTypes.createSubscriptionPlanInputSchema.parse(input);
+    return this.post("/v1/subscription-plans", input, sharedTypes.subscriptionPlanSchema, options);
+  }
+  retrieve(id) {
+    return this.get(`/v1/subscription-plans/${encodeURIComponent(id)}`, sharedTypes.subscriptionPlanSchema);
+  }
+  list(params) {
+    return this.listPage("/v1/subscription-plans", sharedTypes.subscriptionPlanSchema, params);
+  }
+  archive(id, options) {
+    return this.post(
+      `/v1/subscription-plans/${encodeURIComponent(id)}/archive`,
+      {},
+      sharedTypes.subscriptionPlanSchema,
+      options
+    );
+  }
+};
+var SubscriptionsResource = class extends BaseResource {
+  create(input, options) {
+    sharedTypes.createSubscriptionInputSchema.parse(input);
+    return this.post("/v1/subscriptions", input, sharedTypes.subscriptionSchema, options);
+  }
+  retrieve(id) {
+    return this.get(`/v1/subscriptions/${encodeURIComponent(id)}`, sharedTypes.subscriptionSchema);
+  }
+  list(params) {
+    return this.listPage("/v1/subscriptions", sharedTypes.subscriptionSchema, params);
+  }
+  cancel(input, options) {
+    sharedTypes.cancelSubscriptionInputSchema.parse(input);
+    return this.post(
+      `/v1/subscriptions/${encodeURIComponent(input.id)}/cancel`,
+      input,
+      sharedTypes.subscriptionSchema,
+      options
+    );
+  }
+};
+var RefundsResource = class extends BaseResource {
+  create(input, options) {
+    sharedTypes.createRefundInputSchema.parse(input);
+    return this.post("/v1/refunds", input, sharedTypes.refundSchema, options);
+  }
+  retrieve(id) {
+    return this.get(`/v1/refunds/${encodeURIComponent(id)}`, sharedTypes.refundSchema);
+  }
+  list(params) {
+    return this.listPage("/v1/refunds", sharedTypes.refundSchema, params);
+  }
+  /** Record the on-chain refund tx after the merchant signs from their wallet. */
+  submitSignature(input, options) {
+    sharedTypes.submitRefundSignatureInputSchema.parse(input);
+    return this.post(
+      `/v1/refunds/${encodeURIComponent(input.id)}/signature`,
+      input,
+      sharedTypes.refundSchema,
+      options
+    );
+  }
+};
+var WebhookEndpointsResource = class extends BaseResource {
+  create(input, options) {
+    sharedTypes.createWebhookEndpointInputSchema.parse(input);
+    return this.post("/v1/webhook-endpoints", input, sharedTypes.createWebhookEndpointOutputSchema, options);
+  }
+  retrieve(id) {
+    return this.get(`/v1/webhook-endpoints/${encodeURIComponent(id)}`, sharedTypes.webhookEndpointSchema);
+  }
+  list(params) {
+    return this.listPage("/v1/webhook-endpoints", sharedTypes.webhookEndpointSchema, params);
+  }
+  disable(id, options) {
+    return this.post(
+      `/v1/webhook-endpoints/${encodeURIComponent(id)}/disable`,
+      {},
+      sharedTypes.webhookEndpointSchema,
+      options
+    );
+  }
+  enable(id, options) {
+    return this.post(
+      `/v1/webhook-endpoints/${encodeURIComponent(id)}/enable`,
+      {},
+      sharedTypes.webhookEndpointSchema,
+      options
+    );
+  }
+  /** Rotates the signing secret. Returns the new full secret exactly once. */
+  rotateSecret(id, options) {
+    return this.post(
+      `/v1/webhook-endpoints/${encodeURIComponent(id)}/rotate-secret`,
+      {},
+      sharedTypes.createWebhookEndpointOutputSchema,
+      options
+    );
+  }
+};
+var WebhookDeliveriesResource = class extends BaseResource {
+  retrieve(id) {
+    return this.get(`/v1/webhook-deliveries/${encodeURIComponent(id)}`, sharedTypes.webhookDeliverySchema);
+  }
+  list(params) {
+    return this.listPage("/v1/webhook-deliveries", sharedTypes.webhookDeliverySchema, params);
+  }
+  /** Manually replay a permanently-failed delivery. */
+  replay(id, options) {
+    return this.post(
+      `/v1/webhook-deliveries/${encodeURIComponent(id)}/replay`,
+      {},
+      sharedTypes.webhookDeliverySchema,
+      options
+    );
+  }
+};
+var InvoicesResource = class extends BaseResource {
+  create(input, options) {
+    sharedTypes.createInvoiceInputSchema.parse(input);
+    return this.post("/v1/invoices", input, sharedTypes.invoiceSchema, options);
+  }
+  retrieve(id) {
+    return this.get(`/v1/invoices/${encodeURIComponent(id)}`, sharedTypes.invoiceSchema);
+  }
+  list(params) {
+    return this.listPage("/v1/invoices", sharedTypes.invoiceSchema, params);
+  }
+  send(id, options) {
+    return this.post(`/v1/invoices/${encodeURIComponent(id)}/send`, {}, sharedTypes.invoiceSchema, options);
+  }
+  void(id, options) {
+    return this.post(`/v1/invoices/${encodeURIComponent(id)}/void`, {}, sharedTypes.invoiceSchema, options);
+  }
+};
+var StorefrontsResource = class extends BaseResource {
+  /** Retrieve the merchant's own storefront. */
+  retrieve() {
+    return this.get("/v1/storefront", sharedTypes.storefrontSchema);
+  }
+  upsert(input, options) {
+    sharedTypes.createStorefrontInputSchema.parse(input);
+    return this.post("/v1/storefront", input, sharedTypes.storefrontSchema, options);
+  }
+  publish(options) {
+    return this.post("/v1/storefront/publish", {}, sharedTypes.storefrontSchema, options);
+  }
+  archive(options) {
+    return this.post("/v1/storefront/archive", {}, sharedTypes.storefrontSchema, options);
+  }
+  // ----- Products -----
+  listProducts(params) {
+    return this.listPage("/v1/storefront/products", sharedTypes.storefrontProductSchema, params);
+  }
+  createProduct(input, options) {
+    sharedTypes.createStorefrontProductInputSchema.parse(input);
+    return this.post("/v1/storefront/products", input, sharedTypes.storefrontProductSchema, options);
+  }
+  retrieveProduct(productId) {
+    return this.get(
+      `/v1/storefront/products/${encodeURIComponent(productId)}`,
+      sharedTypes.storefrontProductSchema
+    );
+  }
+  archiveProduct(productId, options) {
+    return this.post(
+      `/v1/storefront/products/${encodeURIComponent(productId)}/archive`,
+      {},
+      sharedTypes.storefrontProductSchema,
+      options
+    );
+  }
+};
+var AgentsResource = class extends BaseResource {
+  /** Retrieve the merchant's AutoPay Agent config. */
+  retrieveConfig() {
+    return this.get("/v1/agents/config", sharedTypes.agentMerchantConfigSchema);
+  }
+  updateConfig(input, options) {
+    sharedTypes.updateAgentConfigInputSchema.parse(input);
+    return this.patch("/v1/agents/config", input, sharedTypes.agentMerchantConfigSchema, options);
+  }
+  listActivity(params) {
+    return this.listPage("/v1/agents/activity", sharedTypes.agentActivityLogSchema, params);
+  }
+  // ----- ERC-8183 jobs -----
+  listJobs(params) {
+    return this.listPage("/v1/agents/jobs", sharedTypes.agentJobSchema, params);
+  }
+  retrieveJob(id) {
+    return this.get(`/v1/agents/jobs/${encodeURIComponent(id)}`, sharedTypes.agentJobSchema);
+  }
+  createJob(input, options) {
+    sharedTypes.createAgentJobInputSchema.parse(input);
+    return this.post("/v1/agents/jobs", input, sharedTypes.agentJobSchema, options);
+  }
+  approveJob(id, options) {
+    return this.post(
+      `/v1/agents/jobs/${encodeURIComponent(id)}/approve`,
+      {},
+      sharedTypes.agentJobSchema,
+      options
+    );
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.strimz.io";
+var StrimzClient = class {
+  /** Resolved mode — `test` or `live`. Derived from the API key prefix. */
+  mode;
+  merchants;
+  apiKeys;
+  customers;
+  paymentSessions;
+  transactions;
+  subscriptionPlans;
+  subscriptions;
+  refunds;
+  webhookEndpoints;
+  webhookDeliveries;
+  invoices;
+  storefronts;
+  agents;
+  constructor(options) {
+    if (!options.apiKey || typeof options.apiKey !== "string") {
+      throw new StrimzAuthenticationError(
+        { code: "authentication_error", message: "apiKey is required" },
+        401
+      );
+    }
+    if (sharedConfig.kindFromKey(options.apiKey) !== "secret") {
+      throw new StrimzAuthenticationError(
+        {
+          code: "authentication_error",
+          message: "StrimzClient requires a secret key (sk_test_... or sk_live_...). Use StrimzBrowserClient for publishable keys."
+        },
+        401
+      );
+    }
+    const mode = sharedConfig.modeFromKey(options.apiKey);
+    if (mode == null) {
+      throw new StrimzAuthenticationError(
+        { code: "authentication_error", message: "Unrecognised API key prefix" },
+        401
+      );
+    }
+    this.mode = mode;
+    const fetcher = new Fetcher({
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+      baseHeaders: buildBaseHeaders(options.apiKey, detectRuntime()),
+      timeoutMs: options.timeoutMs,
+      maxRetries: options.maxRetries,
+      onRequest: options.onRequest,
+      onResponse: options.onResponse,
+      fetch: options.fetch
+    });
+    const ctx = { fetcher };
+    this.merchants = new MerchantsResource(ctx);
+    this.apiKeys = new ApiKeysResource(ctx);
+    this.customers = new CustomersResource(ctx);
+    this.paymentSessions = new PaymentSessionsResource(ctx);
+    this.transactions = new TransactionsResource(ctx);
+    this.subscriptionPlans = new SubscriptionPlansResource(ctx);
+    this.subscriptions = new SubscriptionsResource(ctx);
+    this.refunds = new RefundsResource(ctx);
+    this.webhookEndpoints = new WebhookEndpointsResource(ctx);
+    this.webhookDeliveries = new WebhookDeliveriesResource(ctx);
+    this.invoices = new InvoicesResource(ctx);
+    this.storefronts = new StorefrontsResource(ctx);
+    this.agents = new AgentsResource(ctx);
+  }
+};
+function detectRuntime() {
+  if (typeof EdgeRuntime !== "undefined") return "edge";
+  if (typeof process !== "undefined" && process.versions?.node)
+    return `node-${process.versions.node}`;
+  if (typeof navigator !== "undefined" && navigator.userAgent) return "browser";
+  return "unknown";
+}
+var CheckoutResource = class extends BaseResource {
+  /** Load a payment session by id (public — no merchant scoping). */
+  session(id) {
+    return this.get(`/v1/checkout/sessions/${encodeURIComponent(id)}`, sharedTypes.paymentSessionSchema);
+  }
+  /** Load a subscription plan by id (public — no merchant scoping). */
+  plan(id) {
+    return this.get(`/v1/checkout/plans/${encodeURIComponent(id)}`, sharedTypes.subscriptionPlanSchema);
+  }
+};
+var TokensResource = class extends BaseResource {
+  /**
+   * Fetch full metadata for a token. Throws via the underlying fetcher
+   * (404 → `StrimzNotFoundError`) if the token isn't whitelisted.
+   */
+  retrieve(address) {
+    return this.get(`/v1/tokens/${encodeURIComponent(address.toLowerCase())}`, sharedTypes.tokenMetadataSchema);
+  }
+  /**
+   * Read an owner's current EIP-2612 permit nonce. Call this
+   * immediately before signing a Permit — the token contract rejects
+   * stale nonces, and the value advances on every successful permit.
+   */
+  permitNonce(address, owner) {
+    return this.get(
+      `/v1/tokens/${encodeURIComponent(address.toLowerCase())}/permit-nonce`,
+      sharedTypes.tokenPermitNonceSchema,
+      { owner: owner.toLowerCase() }
+    );
+  }
+};
+
+// src/browser-client.ts
+var DEFAULT_BASE_URL2 = "https://api.strimz.io";
+var StrimzBrowserClient = class {
+  mode;
+  /**
+   * Public hosted-checkout reads — payment sessions and subscription
+   * plans by id. Backed by the `/v1/checkout/*` namespace on the API,
+   * which is intentionally unauthenticated.
+   */
+  checkout;
+  /** Token metadata + EIP-2612 permit nonce lookup. */
+  tokens;
+  constructor(options) {
+    const key = options.publishableKey;
+    if (!key || typeof key !== "string") {
+      throw new StrimzAuthenticationError(
+        { code: "authentication_error", message: "publishableKey is required" },
+        401
+      );
+    }
+    if (sharedConfig.kindFromKey(key) !== "publishable") {
+      throw new StrimzAuthenticationError(
+        {
+          code: "authentication_error",
+          message: "StrimzBrowserClient must be initialised with a publishable key (pk_test_... / pk_live_...). Never expose secret keys to a browser."
+        },
+        401
+      );
+    }
+    const mode = sharedConfig.modeFromKey(key);
+    if (mode == null) {
+      throw new StrimzAuthenticationError(
+        { code: "authentication_error", message: "Unrecognised API key prefix" },
+        401
+      );
+    }
+    this.mode = mode;
+    const fetcher = new Fetcher({
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL2,
+      baseHeaders: buildBaseHeaders(key, "browser"),
+      timeoutMs: options.timeoutMs,
+      maxRetries: 2
+    });
+    this.checkout = new CheckoutResource({ fetcher });
+    this.tokens = new TokensResource({ fetcher });
+  }
+};
+function parseWebhookEvent(rawJson) {
+  return sharedTypes.webhookEventSchema.parse(JSON.parse(rawJson));
+}
+
+Object.defineProperty(exports, "signWebhookPayload", {
+  enumerable: true,
+  get: function () { return sharedCrypto.signWebhookPayload; }
+});
+Object.defineProperty(exports, "verifyWebhookSignature", {
+  enumerable: true,
+  get: function () { return sharedCrypto.verifyWebhookSignature; }
+});
+exports.AutoPagingIterator = AutoPagingIterator;
+exports.StrimzAuthenticationError = StrimzAuthenticationError;
+exports.StrimzBrowserClient = StrimzBrowserClient;
+exports.StrimzClient = StrimzClient;
+exports.StrimzError = StrimzError;
+exports.StrimzIdempotencyError = StrimzIdempotencyError;
+exports.StrimzModeMismatchError = StrimzModeMismatchError;
+exports.StrimzNetworkError = StrimzNetworkError;
+exports.StrimzNotFoundError = StrimzNotFoundError;
+exports.StrimzPermissionError = StrimzPermissionError;
+exports.StrimzRateLimitError = StrimzRateLimitError;
+exports.StrimzTimeoutError = StrimzTimeoutError;
+exports.StrimzValidationError = StrimzValidationError;
+exports.classifyError = classifyError;
+exports.generateIdempotencyKey = generateIdempotencyKey;
+exports.isValidIdempotencyKey = isValidIdempotencyKey;
+exports.parseWebhookEvent = parseWebhookEvent;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map