@viu/emporix-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,791 @@
+import { LocationsService } from './chunk-NM7VDXBR.js';
+export { LocationsService } from './chunk-NM7VDXBR.js';
+import { MediaService } from './chunk-F3WAQH2E.js';
+export { MediaService } from './chunk-F3WAQH2E.js';
+import { OrdersService, SalesOrdersService } from './chunk-6UNFMCHZ.js';
+export { OrdersService, SalesOrdersService } from './chunk-6UNFMCHZ.js';
+import { PaymentGatewayService } from './chunk-HKPZI7Y5.js';
+export { PaymentGatewayService } from './chunk-HKPZI7Y5.js';
+import { PriceService } from './chunk-HEO34WLO.js';
+export { PriceService } from './chunk-HEO34WLO.js';
+import { ProductService } from './chunk-QDABAMVN.js';
+export { ProductService } from './chunk-QDABAMVN.js';
+import { SegmentService } from './chunk-Z6PNI5VT.js';
+export { SegmentService } from './chunk-Z6PNI5VT.js';
+import { CartService } from './chunk-IEZHGU7F.js';
+export { CartService } from './chunk-IEZHGU7F.js';
+import { CategoryService } from './chunk-4BJUCCKJ.js';
+export { CategoryService } from './chunk-4BJUCCKJ.js';
+export { iterateAll } from './chunk-GWJ2U2CP.js';
+import { CheckoutService } from './chunk-OMYVOOSX.js';
+export { CheckoutService } from './chunk-OMYVOOSX.js';
+import { CompaniesService } from './chunk-RXVVFNYN.js';
+export { CompaniesService } from './chunk-RXVVFNYN.js';
+import { ContactsService } from './chunk-B56JZNI7.js';
+export { ContactsService } from './chunk-B56JZNI7.js';
+import { CustomerGroupsService } from './chunk-SKX7KCMH.js';
+export { CustomerGroupsService } from './chunk-SKX7KCMH.js';
+import { CustomerService } from './chunk-TLH6SLAF.js';
+export { CustomerService } from './chunk-TLH6SLAF.js';
+import './chunk-BFQ732VZ.js';
+import { EmporixAuthError, errorFromResponse } from './chunk-KTODT6DV.js';
+export { EmporixAuthError, EmporixError, EmporixForbiddenError, EmporixInsufficientScopeError, EmporixNotFoundError, EmporixServerError, EmporixValidationError, errorFromResponse } from './chunk-KTODT6DV.js';
+
+// src/core/config.ts
+var DEFAULT_HOST = "https://api.emporix.io";
+var TENANT_RE = /^[a-z][a-z0-9]{2,15}$/;
+function validateConfig(input) {
+  if (!TENANT_RE.test(input.tenant)) {
+    throw new Error(
+      `Invalid tenant "${input.tenant}": must be lowercase, 3\u201316 chars, match ^[a-z][a-z0-9]+$`
+    );
+  }
+  if (!input.credentials) {
+    throw new Error("credentials is required (provide at least one of backend/storefront/custom)");
+  }
+  return {
+    tenant: input.tenant,
+    host: input.host ?? DEFAULT_HOST,
+    credentials: input.credentials,
+    tokenProvider: input.tokenProvider,
+    timeouts: {
+      connectMs: input.timeouts?.connectMs ?? 1e4,
+      readMs: input.timeouts?.readMs ?? 6e4
+    },
+    retry: { maxAttempts: input.retry?.maxAttempts ?? 3 },
+    cache: {
+      expirationBufferSeconds: input.cache?.expirationBufferSeconds ?? 60,
+      maxLifetimeSeconds: input.cache?.maxLifetimeSeconds ?? 3600
+    },
+    logger: input.logger
+  };
+}
+
+// src/core/logger.ts
+var LEVEL = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  silent: 60
+};
+function isValidLevel(v) {
+  return v !== void 0 && v in LEVEL;
+}
+function readEnv(name) {
+  try {
+    return typeof process !== "undefined" && process.env ? process.env[name] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var LevelResolver = class {
+  constructor(cfg, warn = () => {
+  }) {
+    this.warn = warn;
+    this.cfgLevel = cfg.level ?? "warn";
+    this.cfgServices = { ...cfg.services };
+  }
+  warn;
+  cfgLevel;
+  cfgServices;
+  forcedServices = {};
+  forcedGlobal;
+  warned = false;
+  envFor(svc) {
+    const raw = readEnv(`EMPORIX_LOG_LEVEL_${svc.toUpperCase()}`);
+    if (raw === void 0) return void 0;
+    if (isValidLevel(raw)) return raw;
+    if (!this.warned) {
+      this.warned = true;
+      this.warn(`Invalid EMPORIX_LOG_LEVEL_${svc.toUpperCase()}="${raw}" ignored`);
+    }
+    return void 0;
+  }
+  envGlobal() {
+    const raw = readEnv("EMPORIX_LOG_LEVEL");
+    if (raw === void 0) return void 0;
+    if (isValidLevel(raw)) return raw;
+    if (!this.warned) {
+      this.warned = true;
+      this.warn(`Invalid EMPORIX_LOG_LEVEL="${raw}" ignored`);
+    }
+    return void 0;
+  }
+  /**
+   * Effective level for a service. Forced overrides (from `set(..., force)`)
+   * take precedence over env vars; otherwise env > programmatic config.
+   */
+  get(svc) {
+    return this.forcedServices[svc] ?? this.envFor(svc) ?? this.forcedGlobal ?? this.envGlobal() ?? this.cfgServices[svc] ?? this.cfgLevel ?? "warn";
+  }
+  /** Numeric effective level for a service. */
+  numericLevel(svc) {
+    return LEVEL[this.get(svc)];
+  }
+  /** True if `svc`'s effective level allows emitting at `at`. */
+  isAtLeast(svc, at) {
+    return this.numericLevel(svc) <= LEVEL[at];
+  }
+  /** Mutates programmatic level (global or one service). Env-set levels are sticky unless `force`. */
+  set(level, svc, force = false) {
+    if (svc) {
+      const envBound = readEnv(`EMPORIX_LOG_LEVEL_${svc.toUpperCase()}`) !== void 0;
+      if (envBound && !force) {
+        this.warn(`Level for "${svc}" is env-controlled; pass force to override`);
+        return;
+      }
+      if (force) this.forcedServices[svc] = level;
+      else this.cfgServices[svc] = level;
+    } else {
+      const envBound = readEnv("EMPORIX_LOG_LEVEL") !== void 0;
+      if (envBound && !force) {
+        this.warn("Global level is env-controlled; pass force to override");
+        return;
+      }
+      if (force) this.forcedGlobal = level;
+      else this.cfgLevel = level;
+    }
+  }
+};
+var DEFAULT_REDACT = /* @__PURE__ */ new Set([
+  "authorization",
+  "password",
+  "oldpassword",
+  "newpassword",
+  "clientsecret",
+  "secret",
+  "access_token",
+  "refresh_token",
+  "customertoken",
+  "saastoken",
+  "saas-token",
+  "bearertoken",
+  "apikey",
+  "token"
+]);
+function redact(value, extra = []) {
+  const keys = new Set(DEFAULT_REDACT);
+  for (const k of extra) keys.add(k.toLowerCase());
+  const walk = (v) => {
+    if (Array.isArray(v)) return v.map(walk);
+    if (v && typeof v === "object") {
+      const src = v;
+      if (typeof src.kind === "string" && "token" in src) return { kind: src.kind };
+      const out = {};
+      for (const [k, val] of Object.entries(src)) {
+        if (keys.has(k.toLowerCase())) {
+          out[k] = k.toLowerCase() === "authorization" && typeof val === "string" ? "Bearer ***redacted***" : "***redacted***";
+        } else {
+          out[k] = walk(val);
+        }
+      }
+      return out;
+    }
+    return v;
+  };
+  return walk(value);
+}
+var EMIT = {
+  trace: LEVEL.trace,
+  debug: LEVEL.debug,
+  info: LEVEL.info,
+  warn: LEVEL.warn,
+  error: LEVEL.error
+};
+var BaseLogger = class {
+  constructor(resolver, bindings, extraRedact) {
+    this.resolver = resolver;
+    this.bindings = bindings;
+    this.extraRedact = extraRedact;
+  }
+  resolver;
+  bindings;
+  extraRedact;
+  svc() {
+    return this.bindings.service ?? "http";
+  }
+  get level() {
+    return this.resolver.get(this.svc());
+  }
+  isLevelEnabled(level) {
+    return this.resolver.isAtLeast(this.svc(), level);
+  }
+  at(level, msg, fields) {
+    if (this.resolver.numericLevel(this.svc()) > EMIT[level]) return;
+    const merged = { ...this.bindings, ...fields ?? {} };
+    this.emit(level, msg, redact(merged, this.extraRedact));
+  }
+  trace(m, f) {
+    this.at("trace", m, f);
+  }
+  debug(m, f) {
+    this.at("debug", m, f);
+  }
+  info(m, f) {
+    this.at("info", m, f);
+  }
+  warn(m, f) {
+    this.at("warn", m, f);
+  }
+  error(m, f) {
+    this.at("error", m, f);
+  }
+};
+var ConsoleLogger = class _ConsoleLogger extends BaseLogger {
+  constructor(resolver, bindings, extra, sink, pretty) {
+    super(resolver, bindings, extra);
+    this.sink = sink;
+    this.pretty = pretty;
+  }
+  sink;
+  pretty;
+  emit(level, msg, fields) {
+    if (this.pretty) {
+      const fn = level === "error" ? this.sink.error : level === "warn" ? this.sink.warn : level === "info" ? this.sink.info : this.sink.log;
+      fn(`[${level}] ${msg}`, fields);
+    } else {
+      this.sink.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level, msg, ...fields }));
+    }
+  }
+  child(bindings) {
+    return new _ConsoleLogger(
+      this.resolver,
+      { ...this.bindings, ...bindings },
+      this.extraRedact,
+      this.sink,
+      this.pretty
+    );
+  }
+};
+var NoopLogger = class {
+  level = "silent";
+  isLevelEnabled() {
+    return false;
+  }
+  trace() {
+  }
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+  child() {
+    return this;
+  }
+};
+function createConsoleLogger(resolver, bindings = {}, opts = {}) {
+  const pretty = opts.pretty ?? readEnv("NODE_ENV") !== "production";
+  const sink = opts.sink ?? {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  return new ConsoleLogger(resolver, bindings, opts.redact ?? [], sink, pretty);
+}
+function createNoopLogger() {
+  return new NoopLogger();
+}
+
+// src/core/auth.ts
+var auth = {
+  /** Service/custom credential set (default `backend`). */
+  service: (credentials) => credentials === void 0 ? { kind: "service" } : { kind: "service", credentials },
+  /** Cached anonymous storefront token. */
+  anonymous: () => ({ kind: "anonymous" }),
+  /** Caller-owned customer bearer token. */
+  customer: (token) => ({ kind: "customer", token }),
+  /** Exact token, no transformation (SSO / token-exchange). */
+  raw: (token) => ({ kind: "raw", token })
+};
+async function resolveToken(ctx, provider) {
+  switch (ctx.kind) {
+    case "service":
+      return provider.getToken(ctx.credentials ?? "backend");
+    case "anonymous":
+      return (await provider.getAnonymousToken()).accessToken;
+    case "customer":
+    case "raw":
+      return ctx.token;
+  }
+}
+var DefaultTokenProvider = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  serviceCache = /* @__PURE__ */ new Map();
+  serviceLocks = /* @__PURE__ */ new Map();
+  anon;
+  anonLock;
+  anonStore;
+  refreshListeners = /* @__PURE__ */ new Set();
+  onRefresh(listener) {
+    this.refreshListeners.add(listener);
+    return () => {
+      this.refreshListeners.delete(listener);
+    };
+  }
+  notifyRefresh(kind, success) {
+    for (const l of this.refreshListeners) {
+      try {
+        l({ kind, success });
+      } catch {
+      }
+    }
+  }
+  attachAnonymousStore(store) {
+    this.anonStore = store;
+    if (!this.anon) {
+      const persisted = store.read();
+      if (persisted) {
+        this.anon = {
+          accessToken: "",
+          refreshToken: persisted.refreshToken,
+          sessionId: persisted.sessionId,
+          expiresIn: 0,
+          expiresAt: 0
+        };
+      }
+    }
+  }
+  creds(set) {
+    if (set === "backend") {
+      const b = this.cfg.credentials.backend;
+      if (!b?.clientId || !b.secret) {
+        throw new EmporixAuthError(
+          "A 'service' AuthContext was used but credentials.backend is not configured"
+        );
+      }
+      return b;
+    }
+    const c = this.cfg.credentials.custom?.[set];
+    if (!c) throw new Error(`Unknown credential set "${set}"`);
+    return c;
+  }
+  fresh(e) {
+    if (!e) return false;
+    const now = Date.now();
+    if (now - e.obtainedAt >= this.cfg.cache.maxLifetimeSeconds * 1e3) return false;
+    return now < e.expiresAt;
+  }
+  async getToken(set) {
+    this.creds(set);
+    const cached = this.serviceCache.get(set);
+    if (this.fresh(cached)) return cached.token;
+    const inflight = this.serviceLocks.get(set);
+    if (inflight) return inflight;
+    const p = this.requestServiceToken(set).finally(() => this.serviceLocks.delete(set));
+    this.serviceLocks.set(set, p);
+    return p;
+  }
+  async requestServiceToken(set) {
+    const c = this.creds(set);
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: c.clientId,
+      client_secret: c.secret
+    });
+    if (c.scope) body.set("scope", c.scope);
+    const res = await fetch(`${this.cfg.host}/oauth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body
+    });
+    const json = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new EmporixAuthError(`Token request failed for "${set}"`, res.status, json);
+    }
+    const obtainedAt = Date.now();
+    const ttl = Number(json.expires_in ?? 3600);
+    this.serviceCache.set(set, {
+      token: json.access_token,
+      obtainedAt,
+      expiresAt: obtainedAt + (ttl - this.cfg.cache.expirationBufferSeconds) * 1e3
+    });
+    return this.serviceCache.get(set).token;
+  }
+  invalidate(set) {
+    this.serviceCache.delete(set);
+  }
+  anonFresh() {
+    return !!this.anon && Date.now() < this.anon.expiresAt;
+  }
+  async getAnonymousToken() {
+    if (this.anonFresh()) return this.stripExpiry(this.anon);
+    if (this.anonLock) return this.anonLock;
+    const canRefresh = !!this.anon?.refreshToken;
+    const obtain = canRefresh ? this.fetchAnonymous("refresh").catch(() => this.fetchAnonymous("login")) : this.fetchAnonymous("login");
+    const p = obtain.finally(() => {
+      this.anonLock = void 0;
+    });
+    this.anonLock = p;
+    return p;
+  }
+  /** Refreshes the anonymous session, preserving its sessionId. */
+  async refreshAnonymous() {
+    if (!this.anon) return this.getAnonymousToken();
+    return this.fetchAnonymous("refresh");
+  }
+  invalidateAnonymous() {
+    this.anon = void 0;
+    this.anonStore?.write(null);
+  }
+  /** Force a stale access token while keeping the refresh token + sessionId. */
+  expireAnonymous() {
+    if (this.anon) this.anon = { ...this.anon, expiresAt: 0 };
+  }
+  stripExpiry(s) {
+    const { expiresAt: _expiresAt, ...rest } = s;
+    return rest;
+  }
+  async fetchAnonymous(mode) {
+    const sf = this.cfg.credentials.storefront;
+    if (!sf?.clientId) {
+      throw new Error("credentials.storefront.clientId is required for anonymous tokens");
+    }
+    const url = new URL(`${this.cfg.host}/customerlogin/auth/anonymous/${mode}`);
+    url.searchParams.set("tenant", this.cfg.tenant);
+    url.searchParams.set("client_id", sf.clientId);
+    const c = sf.context;
+    if (c?.currency) url.searchParams.set("currency", c.currency);
+    if (c?.siteCode) url.searchParams.set("siteCode", c.siteCode);
+    if (c?.targetLocation) url.searchParams.set("targetLocation", c.targetLocation);
+    if (mode === "refresh" && this.anon) {
+      url.searchParams.set("refresh_token", this.anon.refreshToken);
+    }
+    try {
+      const res = await fetch(url, { method: "GET" });
+      const json = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        this.notifyRefresh("anonymous", false);
+        throw new EmporixAuthError(`Anonymous token ${mode} failed`, res.status, json);
+      }
+      const obtainedAt = Date.now();
+      this.anon = {
+        accessToken: json.access_token,
+        refreshToken: json.refresh_token,
+        sessionId: json.sessionId,
+        expiresIn: json.expires_in,
+        expiresAt: obtainedAt + (json.expires_in - this.cfg.cache.expirationBufferSeconds) * 1e3
+      };
+      this.anonStore?.write({
+        refreshToken: this.anon.refreshToken,
+        sessionId: this.anon.sessionId
+      });
+      this.notifyRefresh("anonymous", true);
+      return this.stripExpiry(this.anon);
+    } catch (err) {
+      if (!(err instanceof EmporixAuthError)) {
+        this.notifyRefresh("anonymous", false);
+      }
+      throw err;
+    }
+  }
+};
+
+// src/core/http.ts
+var requestSeq = 0;
+function safeJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+var HttpClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  }
+  opts;
+  sleep;
+  async request(o) {
+    const requestId = `req-${++requestSeq}`;
+    const log = this.opts.logger.child({ requestId });
+    const url = new URL(this.opts.host + o.path);
+    for (const [k, v] of Object.entries(o.query ?? {})) {
+      if (v !== void 0) url.searchParams.set(k, String(v));
+    }
+    const sdkManaged = o.auth.kind === "service" || o.auth.kind === "anonymous";
+    const maxAttempts = this.opts.retry.maxAttempts;
+    let reauthed = false;
+    for (let attempt = 1; ; attempt++) {
+      const token = await resolveToken(o.auth, this.opts.provider);
+      log.debug("http request", {
+        authKind: o.auth.kind,
+        method: o.method,
+        url: url.pathname,
+        attempt
+      });
+      const controller = new AbortController();
+      const timer = setTimeout(
+        () => controller.abort(),
+        o.timeoutMs ?? this.opts.timeouts.readMs
+      );
+      const isFormData = typeof FormData !== "undefined" && o.body instanceof FormData;
+      const init = {
+        method: o.method,
+        headers: {
+          ...o.headers ?? {},
+          Authorization: `Bearer ${token}`,
+          // JSON bodies: set Content-Type. FormData bodies: let `fetch`
+          // emit `multipart/form-data; boundary=...` itself.
+          ...o.body !== void 0 && !isFormData ? { "Content-Type": "application/json" } : {}
+        },
+        signal: controller.signal
+      };
+      if (o.body !== void 0) {
+        init.body = isFormData ? o.body : JSON.stringify(o.body);
+      }
+      let res;
+      try {
+        res = await fetch(url, init);
+      } finally {
+        clearTimeout(timer);
+      }
+      const text = await res.text();
+      const parsed = text ? safeJson(text) : void 0;
+      if (res.ok) {
+        log.debug("http ok", { status: res.status });
+        return parsed;
+      }
+      if (res.status === 401) {
+        if (sdkManaged && !reauthed) {
+          reauthed = true;
+          if (o.auth.kind === "service") {
+            this.opts.provider.invalidate?.(o.auth.credentials ?? "backend");
+          } else if (this.opts.provider.expireAnonymous) {
+            this.opts.provider.expireAnonymous();
+          } else {
+            this.opts.provider.invalidateAnonymous?.();
+          }
+          log.warn("sdk-managed 401, re-authing once", { authKind: o.auth.kind });
+          continue;
+        }
+        throw errorFromResponse(res.status, `${o.method} ${o.path} \u2192 401`, parsed);
+      }
+      const retryable = res.status >= 500 || res.status === 429;
+      if (retryable && attempt < maxAttempts) {
+        const retryAfter = Number(res.headers.get("Retry-After"));
+        const backoff = Number.isFinite(retryAfter) && retryAfter >= 0 ? retryAfter * 1e3 : Math.min(1e3 * 2 ** (attempt - 1), 8e3) + Math.random() * 100;
+        log.warn("retryable failure", { status: res.status, attempt, backoffMs: backoff });
+        await this.sleep(backoff);
+        continue;
+      }
+      log.error("http error (final)", { status: res.status, attempt });
+      throw errorFromResponse(res.status, `${o.method} ${o.path} \u2192 ${res.status}`, parsed);
+    }
+  }
+};
+
+// src/services/site.ts
+var ANON = auth.anonymous();
+var SiteService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** Lists active sites. */
+  async list(authCtx = ANON) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/site/${this.ctx.tenant}/sites`,
+      auth: authCtx
+    });
+  }
+  /** Retrieves one site by code. */
+  async get(code, authCtx = ANON) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/site/${this.ctx.tenant}/sites/${code}`,
+      auth: authCtx
+    });
+  }
+  /**
+   * Returns the tenant's default site (the one with `default: true`).
+   * Throws if no default is configured — a tenant should always have one.
+   */
+  async current(authCtx = ANON) {
+    const sites = await this.list(authCtx);
+    const def = sites.find((s) => s.default);
+    if (!def) {
+      throw new Error(
+        `SiteService.current: no default site for tenant "${this.ctx.tenant}"`
+      );
+    }
+    return def;
+  }
+};
+
+// src/services/session-context.ts
+var ANON2 = auth.anonymous();
+var SessionContextService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /**
+   * Retrieves the current session context, or `null` when the server returns
+   * 404 (no session exists yet — the session-context is created server-side
+   * only after the user creates a cart).
+   */
+  async get(authCtx = ANON2) {
+    try {
+      return await this.ctx.http.request({
+        method: "GET",
+        path: `/session-context/${this.ctx.tenant}/me/context`,
+        auth: authCtx
+      });
+    } catch (err) {
+      if (isNotFound(err)) return null;
+      throw err;
+    }
+  }
+  /**
+   * Partially updates the current session context. Returns `true` when the
+   * PATCH was applied, `false` when there is no session context yet (the
+   * server returned 404 on the version-lookup GET, so there is nothing to
+   * update). Non-404 errors propagate.
+   */
+  async patch(input, authCtx = ANON2) {
+    let version = input.version;
+    if (version === void 0) {
+      const current = await this.get(authCtx);
+      if (current === null) return false;
+      version = current.metadata?.version;
+      if (version === void 0) {
+        throw new Error(
+          "SessionContextService.patch: no metadata.version in server response"
+        );
+      }
+    }
+    const { version: _v, ...fields } = input;
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `/session-context/${this.ctx.tenant}/me/context`,
+      body: {
+        ...fields,
+        metadata: { version }
+      },
+      auth: authCtx
+    });
+    return true;
+  }
+};
+function isNotFound(err) {
+  if (err && typeof err === "object") {
+    const status = err.status;
+    if (typeof status === "number" && status === 404) return true;
+  }
+  return false;
+}
+
+// src/client.ts
+var SDK_VERSION = "0.0.0";
+var EmporixClient = class {
+  customers;
+  products;
+  categories;
+  carts;
+  checkout;
+  payments;
+  prices;
+  media;
+  segments;
+  sites;
+  sessionContext;
+  companies;
+  contacts;
+  locations;
+  customerGroups;
+  orders;
+  salesOrders;
+  /** The validated tenant this client is bound to. */
+  tenant;
+  /**
+   * The token provider in use by this client. Exposed so React/Next hosts can
+   * call `attachAnonymousStore` to wire session persistence. Treat as
+   * read-only — replacing it after construction is not supported.
+   */
+  tokenProvider;
+  /**
+   * The validated config used to construct this client. Exposed so React /
+   * Next hosts can read static settings such as `credentials.storefront.context`
+   * (siteCode, currency, targetLocation) without re-plumbing them through the
+   * Provider tree. Treat as read-only.
+   */
+  config;
+  resolver;
+  constructor(config) {
+    const cfg = validateConfig(config);
+    this.tenant = cfg.tenant;
+    this.config = cfg;
+    let loggerObj = {};
+    let baseLogger;
+    if (cfg.logger === false) {
+      baseLogger = createNoopLogger();
+    } else if (cfg.logger && typeof cfg.logger.child === "function") {
+      baseLogger = cfg.logger;
+    } else if (cfg.logger) {
+      loggerObj = cfg.logger;
+    }
+    this.resolver = new LevelResolver(loggerObj);
+    const root = baseLogger ?? createConsoleLogger(this.resolver, {
+      sdk: "emporix",
+      sdkVersion: SDK_VERSION,
+      tenant: cfg.tenant
+    });
+    const tokenProvider = cfg.tokenProvider ?? new DefaultTokenProvider(cfg);
+    this.tokenProvider = tokenProvider;
+    const mk = (service) => ({
+      tenant: cfg.tenant,
+      tokenProvider,
+      logger: root.child({ service }),
+      http: new HttpClient({
+        host: cfg.host,
+        provider: tokenProvider,
+        logger: root.child({ service: "http" }),
+        retry: cfg.retry,
+        timeouts: cfg.timeouts
+      })
+    });
+    this.customers = new CustomerService(mk("customer"));
+    this.products = new ProductService(mk("product"));
+    this.categories = new CategoryService(mk("category"));
+    this.carts = new CartService(mk("cart"));
+    this.checkout = new CheckoutService(mk("checkout"));
+    this.payments = new PaymentGatewayService(mk("payment"));
+    this.prices = new PriceService(mk("price"));
+    this.media = new MediaService(mk("media"));
+    this.segments = new SegmentService(mk("segment"), {
+      products: this.products,
+      categories: this.categories
+    });
+    this.sites = new SiteService(mk("site"));
+    this.sessionContext = new SessionContextService(mk("session-context"));
+    this.companies = new CompaniesService(mk("customer-management"));
+    this.contacts = new ContactsService(mk("customer-management"));
+    this.locations = new LocationsService(mk("customer-management"));
+    this.customerGroups = new CustomerGroupsService(mk("iam"));
+    this.orders = new OrdersService(mk("orders"));
+    this.salesOrders = new SalesOrdersService(mk("sales-orders"));
+  }
+  /** Sets the runtime log level globally or for one service. */
+  setLogLevel(level, opts = {}) {
+    this.resolver.set(level, opts.service, opts.force ?? false);
+  }
+  /** Returns the effective log level for a service. */
+  getLogLevel(service) {
+    return this.resolver.get(service);
+  }
+};
+
+export { DEFAULT_HOST, DefaultTokenProvider, EmporixClient, HttpClient, LEVEL, LevelResolver, SessionContextService, SiteService, auth, createConsoleLogger, createNoopLogger, redact, resolveToken, validateConfig };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map