@xylex-group/athena 2.13.0 → 3.0.0

package/dist/billing.js

@@ -0,0 +1,1194 @@
+// package.json
+var package_default = {
+  version: "3.0.0"
+};
+
+// src/sdk-version.ts
+var PACKAGE_VERSION = package_default.version;
+function buildSdkHeaderValue(sdkName) {
+  return `${sdkName} ${PACKAGE_VERSION}`;
+}
+
+// src/cookies/cookie-utils.ts
+var SECURE_COOKIE_PREFIX = "__Secure-";
+function parseCookies(cookieHeader) {
+  const cookies = cookieHeader.split("; ");
+  const cookieMap = /* @__PURE__ */ new Map();
+  cookies.forEach((cookie) => {
+    const [name, value] = cookie.split(/=(.*)/s);
+    cookieMap.set(name, value);
+  });
+  return cookieMap;
+}
+var getSessionCookie = (request, config) => {
+  const cookies = (request instanceof Headers || !("headers" in request) ? request : request.headers).get("cookie");
+  if (!cookies) {
+    return null;
+  }
+  const { cookieName = "session_token", cookiePrefix = "athena-auth" } = {};
+  const parsedCookie = parseCookies(cookies);
+  const getCookie = (name) => parsedCookie.get(name) || parsedCookie.get(`${SECURE_COOKIE_PREFIX}${name}`);
+  const candidateCookieNames = Array.from(/* @__PURE__ */ new Set([
+    cookieName,
+    cookieName.replace(/_/g, "-"),
+    cookieName.replace(/-/g, "_")
+  ])).filter(Boolean);
+  for (const candidateName of candidateCookieNames) {
+    const sessionToken = getCookie(`${cookiePrefix}.${candidateName}`) || getCookie(`${cookiePrefix}-${candidateName}`);
+    if (sessionToken) {
+      return sessionToken;
+    }
+  }
+  return null;
+};
+
+// src/utils/athena-request-headers.ts
+var NO_CACHE_HEADER_VALUE = "no-cache";
+var API_KEY_HEADER_CANDIDATES = ["X-Athena-Key", "x-athena-key", "X-Api-Key", "x-api-key", "apikey"];
+var ATHENA_KEY_HEADER_CANDIDATES = ["X-Athena-Key", "x-athena-key"];
+var SESSION_TOKEN_HEADER_CANDIDATES = ["X-Athena-Auth-Session-Token"];
+var BEARER_MIRROR_HEADER_CANDIDATES = ["X-Athena-Auth-Bearer-Token"];
+var CLIENT_HEADER_CANDIDATES = ["X-Athena-Client", "x-athena-client"];
+var PG_URI_HEADER_CANDIDATES = ["x-pg-uri"];
+var JDBC_URI_HEADER_CANDIDATES = ["x-athena-jdbc-url", "x-jdbc-url"];
+var PROFILE_RULES = {
+  gateway: { apiKeys: true, routing: true, authMirror: true, authBearer: false, contentType: true, stripNullsDefault: true },
+  chat: { apiKeys: true, routing: true, authMirror: true, authBearer: true, accept: true },
+  storage: { apiKeys: true, routing: true, authMirror: true, authBearer: false, contentType: true },
+  auth: { apiKeys: true, routing: true, authMirror: false, authBearer: true, contentType: true },
+  minimal: { apiKeys: false, routing: false, authMirror: false, authBearer: false }
+};
+function normalizeHeaderValue(value) {
+  return value ? value : void 0;
+}
+function mergeExtraHeaders(configHeaders, callHeaders) {
+  return { ...configHeaders ?? {}, ...callHeaders ?? {} };
+}
+function hasHeaderIgnoreCase(headers, targetKey) {
+  const normalizedTargetKey = targetKey.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === normalizedTargetKey);
+}
+function resolveHeaderValue(headers, candidates) {
+  for (const candidate of candidates) {
+    const direct = normalizeHeaderValue(headers[candidate]);
+    if (direct) return direct;
+  }
+  const loweredCandidates = new Set(candidates.map((candidate) => candidate.toLowerCase()));
+  for (const [key, value] of Object.entries(headers)) {
+    if (!loweredCandidates.has(key.toLowerCase())) {
+      continue;
+    }
+    const normalized = normalizeHeaderValue(value);
+    if (normalized) return normalized;
+  }
+  return void 0;
+}
+function isCacheControlHeaderName(name) {
+  return name.toLowerCase() === "cache-control";
+}
+function normalizeBearerToken(value) {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^Bearer\s+(.+)$/i);
+  return match?.[1]?.trim() ?? trimmed;
+}
+function resolveBearerTokenFromAuthorizationHeader(headers) {
+  const authorization = resolveHeaderValue(headers, ["Authorization"]);
+  if (!authorization) {
+    return void 0;
+  }
+  const token = normalizeBearerToken(authorization);
+  return token ? token : void 0;
+}
+function resolveSessionTokenFromCookieHeader(headers) {
+  const cookie = resolveHeaderValue(headers, ["Cookie"]);
+  if (!cookie) {
+    return void 0;
+  }
+  return getSessionCookie(new Headers({ cookie })) ?? void 0;
+}
+function resolveBackendType(backend) {
+  if (!backend) {
+    return void 0;
+  }
+  return typeof backend === "string" ? backend : backend.type;
+}
+function applyAthenaApiKeyHeaders(headers, apiKey) {
+  const resolvedApiKey = normalizeHeaderValue(apiKey);
+  if (resolvedApiKey && !hasHeaderIgnoreCase(headers, "X-Athena-Key")) {
+    headers["X-Athena-Key"] = resolvedApiKey;
+  }
+}
+function applyAthenaAuthContextHeaders(headers, input) {
+  const mergedExtraHeaders = mergeExtraHeaders(input.configHeaders, input.callHeaders);
+  const rules = PROFILE_RULES[input.profile];
+  const explicitCookie = normalizeHeaderValue(input.cookie);
+  if (explicitCookie) {
+    mergedExtraHeaders.Cookie = explicitCookie;
+  }
+  const explicitSessionToken = normalizeHeaderValue(input.sessionToken) ?? resolveHeaderValue(mergedExtraHeaders, SESSION_TOKEN_HEADER_CANDIDATES);
+  const derivedSessionToken = explicitSessionToken ?? resolveSessionTokenFromCookieHeader(mergedExtraHeaders);
+  const cookieFromHeaders = resolveHeaderValue(mergedExtraHeaders, ["Cookie"]);
+  if (explicitCookie && !hasHeaderIgnoreCase(headers, "Cookie")) {
+    headers.Cookie = explicitCookie;
+  } else if (cookieFromHeaders && !hasHeaderIgnoreCase(headers, "Cookie")) {
+    headers.Cookie = cookieFromHeaders;
+  }
+  const explicitBearerToken = (() => {
+    const configured = normalizeHeaderValue(input.bearerToken);
+    if (configured) {
+      return normalizeBearerToken(configured);
+    }
+    const mirrored = resolveHeaderValue(mergedExtraHeaders, BEARER_MIRROR_HEADER_CANDIDATES);
+    return mirrored ? normalizeBearerToken(mirrored) : void 0;
+  })();
+  const derivedBearerToken = explicitBearerToken ?? resolveBearerTokenFromAuthorizationHeader(mergedExtraHeaders);
+  if (rules.authBearer && derivedBearerToken && !hasHeaderIgnoreCase(headers, "Authorization")) {
+    headers.Authorization = `Bearer ${derivedBearerToken}`;
+  }
+  if (rules.authMirror) {
+    if (derivedSessionToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Session-Token")) {
+      headers["X-Athena-Auth-Session-Token"] = derivedSessionToken;
+    }
+    if (derivedBearerToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Bearer-Token")) {
+      headers["X-Athena-Auth-Bearer-Token"] = derivedBearerToken;
+    }
+  } else if (derivedSessionToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Session-Token")) {
+    headers["X-Athena-Auth-Session-Token"] = derivedSessionToken;
+  }
+}
+function applyAthenaPgUriHeaders(headers, input) {
+  const mergedExtraHeaders = mergeExtraHeaders(input.configHeaders, input.callHeaders);
+  const pgUri = normalizeHeaderValue(input.pgUri) ?? resolveHeaderValue(mergedExtraHeaders, PG_URI_HEADER_CANDIDATES);
+  if (pgUri && !hasHeaderIgnoreCase(headers, "x-pg-uri")) {
+    headers["x-pg-uri"] = pgUri;
+  }
+  const jdbcUrl = normalizeHeaderValue(input.jdbcUrl) ?? resolveHeaderValue(mergedExtraHeaders, JDBC_URI_HEADER_CANDIDATES);
+  if (jdbcUrl) {
+    if (!hasHeaderIgnoreCase(headers, "x-athena-jdbc-url")) {
+      headers["x-athena-jdbc-url"] = jdbcUrl;
+    }
+    if (!hasHeaderIgnoreCase(headers, "x-jdbc-url")) {
+      headers["x-jdbc-url"] = jdbcUrl;
+    }
+  }
+}
+function buildAthenaRequestHeaders(input) {
+  const forceNoCache = Boolean(input.forceNoCache);
+  const mergedExtraHeaders = mergeExtraHeaders(input.configHeaders, input.callHeaders);
+  const rules = PROFILE_RULES[input.profile];
+  const headerClient = resolveHeaderValue(mergedExtraHeaders, CLIENT_HEADER_CANDIDATES);
+  const finalClient = normalizeHeaderValue(input.client) ?? headerClient;
+  const finalApiKey = normalizeHeaderValue(input.apiKey) ?? resolveHeaderValue(mergedExtraHeaders, API_KEY_HEADER_CANDIDATES);
+  const finalAthenaKey = resolveHeaderValue(mergedExtraHeaders, ATHENA_KEY_HEADER_CANDIDATES) ?? finalApiKey;
+  const headers = {
+    "X-Athena-Sdk": input.sdkHeaderValue
+  };
+  if (rules.contentType) {
+    headers["Content-Type"] = input.contentType ?? "application/json";
+  }
+  if (input.accept ?? rules.accept) {
+    headers.Accept = input.accept ?? "application/json";
+  }
+  if (rules.routing) {
+    if (normalizeHeaderValue(input.userId)) {
+      headers["X-User-Id"] = input.userId ?? "";
+    }
+    if (normalizeHeaderValue(input.organizationId)) {
+      headers["X-Organization-Id"] = input.organizationId ?? "";
+    }
+    if (finalClient) {
+      headers["X-Athena-Client"] = finalClient;
+    }
+    const backendType = resolveBackendType(input.backend);
+    if (backendType) {
+      headers["X-Backend-Type"] = backendType;
+    }
+    if (typeof input.stripNulls === "boolean") {
+      headers["X-Strip-Nulls"] = input.stripNulls ? "true" : "false";
+    } else if (rules.stripNullsDefault) {
+      headers["X-Strip-Nulls"] = "true";
+    }
+    if (normalizeHeaderValue(input.publishEvent)) {
+      headers["X-Publish-Event"] = input.publishEvent ?? "";
+    }
+  }
+  if (rules.apiKeys && (finalApiKey || finalAthenaKey)) {
+    applyAthenaApiKeyHeaders(headers, finalAthenaKey);
+  }
+  applyAthenaAuthContextHeaders(headers, input);
+  applyAthenaPgUriHeaders(headers, input);
+  const reservedClientHeaderKeys = new Set(CLIENT_HEADER_CANDIDATES.map((key) => key.toLowerCase()));
+  Object.entries(mergedExtraHeaders).forEach(([key, value]) => {
+    if (reservedClientHeaderKeys.has(key.toLowerCase())) {
+      return;
+    }
+    if (forceNoCache && isCacheControlHeaderName(key)) {
+      return;
+    }
+    const normalized = normalizeHeaderValue(value);
+    if (normalized) {
+      headers[key] = normalized;
+    }
+  });
+  if (forceNoCache) {
+    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE;
+  }
+  return headers;
+}
+
+// src/gateway/errors.ts
+var AthenaGatewayError = class _AthenaGatewayError extends Error {
+  code;
+  status;
+  endpoint;
+  method;
+  requestId;
+  hint;
+  causeDetail;
+  constructor(input) {
+    super(input.message);
+    this.name = "AthenaGatewayError";
+    this.code = input.code;
+    this.status = input.status ?? 0;
+    this.endpoint = input.endpoint;
+    this.method = input.method;
+    this.requestId = input.requestId;
+    this.hint = input.hint;
+    this.causeDetail = input.cause;
+  }
+  toDetails() {
+    return {
+      code: this.code,
+      message: this.message,
+      status: this.status,
+      endpoint: this.endpoint,
+      method: this.method,
+      requestId: this.requestId,
+      hint: this.hint,
+      cause: this.causeDetail
+    };
+  }
+  static fromResponse(response, fallback) {
+    const details = response.errorDetails;
+    if (details) {
+      return new _AthenaGatewayError({
+        code: details.code,
+        message: details.message,
+        status: details.status,
+        endpoint: details.endpoint ?? fallback.endpoint,
+        method: details.method ?? fallback.method,
+        requestId: details.requestId ?? fallback.requestId,
+        hint: details.hint,
+        cause: details.cause
+      });
+    }
+    return new _AthenaGatewayError({
+      code: "HTTP_ERROR",
+      message: response.error ?? "Gateway request failed",
+      status: response.status,
+      endpoint: fallback.endpoint,
+      method: fallback.method,
+      requestId: fallback.requestId
+    });
+  }
+};
+
+// src/gateway/url.ts
+function describeReceivedValue(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "string") {
+    return value.trim().length > 0 ? JSON.stringify(value) : "an empty string";
+  }
+  return `${typeof value} ${JSON.stringify(value)}`;
+}
+function invalidBaseUrlError(message, hint) {
+  return new AthenaGatewayError({
+    code: "INVALID_URL",
+    message,
+    status: 0,
+    hint
+  });
+}
+function normalizeAthenaGatewayBaseUrl(input, options = {}) {
+  const label = options.label ?? "Athena gateway base URL";
+  const candidate = input ?? options.defaultBaseUrl;
+  if (candidate === void 0 || candidate === null) {
+    throw invalidBaseUrlError(
+      `${label} must be a non-empty absolute http(s) URL. Received ${describeReceivedValue(input)}.`,
+      'Set ATHENA_URL in the explicit env object (or pass createClient({ url, key })) to a full URL such as "https://mirror3.athena-db.com".'
+    );
+  }
+  const trimmed = candidate.trim();
+  if (!trimmed) {
+    throw invalidBaseUrlError(
+      `${label} must be a non-empty absolute http(s) URL. Received ${describeReceivedValue(candidate)}.`,
+      'Set ATHENA_URL in the explicit env object (or pass createClient({ url, key })) to a full URL such as "https://mirror3.athena-db.com".'
+    );
+  }
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw invalidBaseUrlError(
+      `${label} must be a valid absolute http(s) URL. Received ${describeReceivedValue(candidate)}.`,
+      'Use a full URL including the protocol, for example "https://mirror3.athena-db.com".'
+    );
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw invalidBaseUrlError(
+      `${label} must use http or https. Received ${JSON.stringify(trimmed)}.`,
+      'Use an Athena gateway URL such as "https://mirror3.athena-db.com".'
+    );
+  }
+  if (parsed.search || parsed.hash) {
+    throw invalidBaseUrlError(
+      `${label} must not include query parameters or hash fragments. Received ${JSON.stringify(trimmed)}.`,
+      'Pass only the base URL. Endpoint paths such as "/gateway/fetch" are appended by the SDK.'
+    );
+  }
+  return parsed.toString().replace(/\/+$/, "");
+}
+
+// src/billing/module.ts
+var SDK_NAME = "xylex-group/athena-billing";
+var SDK_HEADER_VALUE = buildSdkHeaderValue(SDK_NAME);
+var AthenaBillingError = class extends Error {
+  status;
+  endpoint;
+  method;
+  body;
+  constructor(input) {
+    super(input.message);
+    this.name = "AthenaBillingError";
+    this.status = input.status;
+    this.endpoint = input.endpoint;
+    this.method = input.method;
+    this.body = input.body;
+  }
+};
+var billingSdkManifest = {
+  namespace: "billing",
+  envelopeKind: "athena",
+  methods: [
+    { name: "getCapabilities", method: "GET", path: "/billing/v1/capabilities" },
+    { name: "createCheckout", method: "POST", path: "/billing/v1/checkouts" },
+    { name: "listCustomers", method: "GET", path: "/billing/v1/customers" },
+    { name: "createCustomer", method: "POST", path: "/billing/v1/customers" },
+    { name: "getCustomer", method: "GET", path: "/billing/v1/customers/{id}" },
+    { name: "updateCustomer", method: "PATCH", path: "/billing/v1/customers/{id}" },
+    { name: "deleteCustomer", method: "DELETE", path: "/billing/v1/customers/{id}" },
+    { name: "listPayments", method: "GET", path: "/billing/v1/payments" },
+    { name: "createPayment", method: "POST", path: "/billing/v1/payments" },
+    { name: "getPayment", method: "GET", path: "/billing/v1/payments/{id}" },
+    { name: "cancelPayment", method: "POST", path: "/billing/v1/payments/{id}/cancel" },
+    { name: "listPaymentLinks", method: "GET", path: "/billing/v1/payment-links" },
+    { name: "createPaymentLink", method: "POST", path: "/billing/v1/payment-links" },
+    { name: "getPaymentLink", method: "GET", path: "/billing/v1/payment-links/{id}" },
+    { name: "updatePaymentLink", method: "PATCH", path: "/billing/v1/payment-links/{id}" },
+    { name: "deletePaymentLink", method: "DELETE", path: "/billing/v1/payment-links/{id}" },
+    { name: "listRefunds", method: "GET", path: "/billing/v1/refunds" },
+    { name: "createRefund", method: "POST", path: "/billing/v1/refunds" },
+    { name: "getRefund", method: "GET", path: "/billing/v1/refunds/{id}" },
+    { name: "cancelRefund", method: "POST", path: "/billing/v1/refunds/{id}/cancel" },
+    { name: "listSubscriptions", method: "GET", path: "/billing/v1/subscriptions" },
+    { name: "createSubscription", method: "POST", path: "/billing/v1/subscriptions" },
+    { name: "getSubscription", method: "GET", path: "/billing/v1/subscriptions/{id}" },
+    { name: "updateSubscription", method: "PATCH", path: "/billing/v1/subscriptions/{id}" },
+    { name: "cancelSubscription", method: "POST", path: "/billing/v1/subscriptions/{id}/cancel" },
+    { name: "listInvoices", method: "GET", path: "/billing/v1/invoices" },
+    { name: "getInvoice", method: "GET", path: "/billing/v1/invoices/{id}" },
+    {
+      name: "listConnections",
+      method: "GET",
+      path: "/admin/billing/clients/{client_name}/connections"
+    },
+    {
+      name: "createConnection",
+      method: "POST",
+      path: "/admin/billing/clients/{client_name}/connections"
+    },
+    {
+      name: "getConnection",
+      method: "GET",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}"
+    },
+    {
+      name: "updateConnection",
+      method: "PATCH",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}"
+    },
+    {
+      name: "deleteConnection",
+      method: "DELETE",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}"
+    },
+    {
+      name: "reconcileDocument",
+      method: "POST",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}/reconcile"
+    },
+    {
+      name: "listWebhookEvents",
+      method: "GET",
+      path: "/admin/billing/clients/{client_name}/webhook-events"
+    },
+    {
+      name: "provisionWebhookSinks",
+      method: "POST",
+      path: "/admin/billing/clients/{client_name}/webhook-sinks/provision"
+    },
+    { name: "listGrants", method: "GET", path: "/admin/billing/grants" },
+    { name: "listProviders", method: "GET", path: "/admin/billing/providers" },
+    {
+      name: "listSinkHelpers",
+      method: "GET",
+      path: "/admin/webhook-sinks/helpers/billing"
+    },
+    {
+      name: "ingestProviderWebhook",
+      method: "POST",
+      path: "/billing/providers/{provider}/clients/{client_name}/connections/{connection_id}/webhook"
+    },
+    { name: "getDebugBilling", method: "GET", path: "/debug/billing" }
+  ]
+};
+function withPathParam(path, name, value) {
+  return path.replace(`{${name}}`, encodeURIComponent(value));
+}
+function appendQuery(path, query) {
+  if (!query) return path;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    params.set(key, String(value));
+  }
+  const serialized = params.toString();
+  return serialized ? `${path}?${serialized}` : path;
+}
+function connectionQuery(input) {
+  const query = {
+    connectionId: input.connectionId
+  };
+  if (input.clientName) query.clientName = input.clientName;
+  if ("cursor" in input && input.cursor) query.cursor = input.cursor;
+  if ("source" in input && input.source) query.source = input.source;
+  if ("limit" in input && input.limit !== void 0) query.limit = String(input.limit);
+  if ("offset" in input && input.offset !== void 0) query.offset = String(input.offset);
+  return query;
+}
+function parseEnvelopeData(body) {
+  if (body && typeof body === "object" && "data" in body) {
+    return body.data;
+  }
+  return body;
+}
+function createBillingModule(config) {
+  const baseUrl = normalizeAthenaGatewayBaseUrl(config.baseUrl, {
+    label: "Athena billing base URL"
+  });
+  const fetchImpl = config.fetchImpl ?? globalThis.fetch.bind(globalThis);
+  async function call(method, path, body, options, responseType = "json") {
+    const headers = buildAthenaRequestHeaders({
+      profile: "gateway",
+      sdkHeaderValue: SDK_HEADER_VALUE,
+      apiKey: options?.apiKey ?? config.apiKey,
+      client: config.client,
+      configHeaders: {
+        ...config.headers ?? {}
+      },
+      callHeaders: options?.headers,
+      contentType: "application/json"
+    });
+    let requestBody;
+    if (body !== void 0 && body !== null) {
+      if (typeof body === "string" || body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof FormData || body instanceof URLSearchParams) {
+        requestBody = body;
+      } else {
+        requestBody = JSON.stringify(body);
+        if (!hasHeaderIgnoreCase(headers, "Content-Type")) {
+          headers["Content-Type"] = "application/json";
+        }
+      }
+    }
+    const targetUrl = `${baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    const response = await fetchImpl(targetUrl, {
+      method,
+      headers,
+      body: requestBody,
+      signal: options?.signal
+    });
+    if (responseType === "text") {
+      const text = await response.text();
+      if (!response.ok) {
+        throw new AthenaBillingError({
+          message: `Billing request failed (${response.status})`,
+          status: response.status,
+          endpoint: path,
+          method,
+          body: text
+        });
+      }
+      return text;
+    }
+    const rawText = await response.text();
+    let parsed = rawText;
+    if (rawText) {
+      try {
+        parsed = JSON.parse(rawText);
+      } catch {
+        parsed = rawText;
+      }
+    } else {
+      parsed = null;
+    }
+    if (!response.ok) {
+      const message = parsed && typeof parsed === "object" && "message" in parsed && typeof parsed.message === "string" ? parsed.message : `Billing request failed (${response.status})`;
+      throw new AthenaBillingError({
+        message,
+        status: response.status,
+        endpoint: path,
+        method,
+        body: parsed
+      });
+    }
+    return parseEnvelopeData(parsed);
+  }
+  return {
+    getCapabilities(input, options) {
+      return call(
+        "GET",
+        appendQuery("/billing/v1/capabilities", connectionQuery(input)),
+        void 0,
+        options
+      );
+    },
+    createCheckout(body, options) {
+      return call("POST", "/billing/v1/checkouts", body, options);
+    },
+    listCustomers(input, options) {
+      return call(
+        "GET",
+        appendQuery("/billing/v1/customers", connectionQuery(input)),
+        void 0,
+        options
+      );
+    },
+    createCustomer(input, options) {
+      return call(
+        "POST",
+        "/billing/v1/customers",
+        {
+          connectionId: input.connectionId,
+          clientName: input.clientName,
+          email: input.email,
+          name: input.name,
+          metadata: input.metadata ?? {},
+          idempotencyKey: input.idempotencyKey
+        },
+        options
+      );
+    },
+    getCustomer(id, input, options) {
+      return call(
+        "GET",
+        appendQuery(
+          withPathParam("/billing/v1/customers/{id}", "id", id),
+          connectionQuery(input)
+        ),
+        void 0,
+        options
+      );
+    },
+    updateCustomer(id, input, options) {
+      return call(
+        "PATCH",
+        withPathParam("/billing/v1/customers/{id}", "id", id),
+        {
+          connectionId: input.connectionId,
+          clientName: input.clientName,
+          email: input.email,
+          name: input.name
+        },
+        options
+      );
+    },
+    deleteCustomer(id, input, options) {
+      return call(
+        "DELETE",
+        appendQuery(
+          withPathParam("/billing/v1/customers/{id}", "id", id),
+          connectionQuery(input)
+        ),
+        void 0,
+        options
+      );
+    },
+    listPayments(input, options) {
+      return call(
+        "GET",
+        appendQuery("/billing/v1/payments", connectionQuery(input)),
+        void 0,
+        options
+      );
+    },
+    createPayment(body, options) {
+      return call("POST", "/billing/v1/payments", body, options);
+    },
+    getPayment(id, input, options) {
+      return call(
+        "GET",
+        appendQuery(
+          withPathParam("/billing/v1/payments/{id}", "id", id),
+          connectionQuery(input)
+        ),
+        void 0,
+        options
+      );
+    },
+    cancelPayment(id, input, options) {
+      return call(
+        "POST",
+        appendQuery(
+          withPathParam("/billing/v1/payments/{id}/cancel", "id", id),
+          connectionQuery(input)
+        ),
+        {},
+        options
+      );
+    },
+    listPaymentLinks(input, options) {
+      return call(
+        "GET",
+        appendQuery("/billing/v1/payment-links", connectionQuery(input)),
+        void 0,
+        options
+      );
+    },
+    createPaymentLink(body, options) {
+      return call("POST", "/billing/v1/payment-links", body, options);
+    },
+    getPaymentLink(id, input, options) {
+      return call(
+        "GET",
+        appendQuery(
+          withPathParam("/billing/v1/payment-links/{id}", "id", id),
+          connectionQuery(input)
+        ),
+        void 0,
+        options
+      );
+    },
+    updatePaymentLink(id, body, options) {
+      return call(
+        "PATCH",
+        withPathParam("/billing/v1/payment-links/{id}", "id", id),
+        body,
+        options
+      );
+    },
+    deletePaymentLink(id, input, options) {
+      return call(
+        "DELETE",
+        appendQuery(
+          withPathParam("/billing/v1/payment-links/{id}", "id", id),
+          connectionQuery(input)
+        ),
+        void 0,
+        options
+      );
+    },
+    listRefunds(input, options) {
+      return call(
+        "GET",
+        appendQuery("/billing/v1/refunds", connectionQuery(input)),
+        void 0,
+        options
+      );
+    },
+    createRefund(body, options) {
+      return call("POST", "/billing/v1/refunds", body, options);
+    },
+    getRefund(id, input, options) {
+      return call(
+        "GET",
+        appendQuery(withPathParam("/billing/v1/refunds/{id}", "id", id), {
+          ...connectionQuery(input),
+          ...input.paymentId ? { paymentId: input.paymentId } : {}
+        }),
+        void 0,
+        options
+      );
+    },
+    cancelRefund(id, input, options) {
+      return call(
+        "POST",
+        appendQuery(withPathParam("/billing/v1/refunds/{id}/cancel", "id", id), {
+          ...connectionQuery(input),
+          ...input.paymentId ? { paymentId: input.paymentId } : {}
+        }),
+        {},
+        options
+      );
+    },
+    listSubscriptions(input, options) {
+      return call(
+        "GET",
+        appendQuery("/billing/v1/subscriptions", connectionQuery(input)),
+        void 0,
+        options
+      );
+    },
+    createSubscription(body, options) {
+      return call("POST", "/billing/v1/subscriptions", body, options);
+    },
+    getSubscription(id, input, options) {
+      return call(
+        "GET",
+        appendQuery(withPathParam("/billing/v1/subscriptions/{id}", "id", id), {
+          ...connectionQuery(input),
+          ...input.customerId ? { customerId: input.customerId } : {}
+        }),
+        void 0,
+        options
+      );
+    },
+    updateSubscription(id, body, options) {
+      return call(
+        "PATCH",
+        withPathParam("/billing/v1/subscriptions/{id}", "id", id),
+        body,
+        options
+      );
+    },
+    cancelSubscription(id, input, options) {
+      return call(
+        "POST",
+        appendQuery(withPathParam("/billing/v1/subscriptions/{id}/cancel", "id", id), {
+          ...connectionQuery(input),
+          customerId: input.customerId
+        }),
+        {},
+        options
+      );
+    },
+    listInvoices(input, options) {
+      return call(
+        "GET",
+        appendQuery("/billing/v1/invoices", connectionQuery(input)),
+        void 0,
+        options
+      );
+    },
+    getInvoice(id, input, options) {
+      return call(
+        "GET",
+        appendQuery(
+          withPathParam("/billing/v1/invoices/{id}", "id", id),
+          connectionQuery(input)
+        ),
+        void 0,
+        options
+      );
+    },
+    listConnections(clientName, options) {
+      return call(
+        "GET",
+        withPathParam("/admin/billing/clients/{client_name}/connections", "client_name", clientName),
+        void 0,
+        options
+      );
+    },
+    createConnection(clientName, input, options) {
+      return call(
+        "POST",
+        withPathParam("/admin/billing/clients/{client_name}/connections", "client_name", clientName),
+        {
+          ownerKind: input.ownerKind,
+          ownerId: input.ownerId,
+          provider: input.provider,
+          mode: input.mode,
+          status: input.status,
+          credentialKind: input.credentialKind,
+          providerAccountId: input.providerAccountId,
+          providerProfileId: input.providerProfileId,
+          scopes: input.scopes,
+          config: input.config,
+          metadata: input.metadata
+        },
+        options
+      );
+    },
+    getConnection(clientName, connectionId, options) {
+      return call(
+        "GET",
+        withPathParam(
+          withPathParam(
+            "/admin/billing/clients/{client_name}/connections/{connection_id}",
+            "client_name",
+            clientName
+          ),
+          "connection_id",
+          connectionId
+        ),
+        void 0,
+        options
+      );
+    },
+    updateConnection(clientName, connectionId, input, options) {
+      return call(
+        "PATCH",
+        withPathParam(
+          withPathParam(
+            "/admin/billing/clients/{client_name}/connections/{connection_id}",
+            "client_name",
+            clientName
+          ),
+          "connection_id",
+          connectionId
+        ),
+        input,
+        options
+      );
+    },
+    deleteConnection(clientName, connectionId, options) {
+      return call(
+        "DELETE",
+        withPathParam(
+          withPathParam(
+            "/admin/billing/clients/{client_name}/connections/{connection_id}",
+            "client_name",
+            clientName
+          ),
+          "connection_id",
+          connectionId
+        ),
+        void 0,
+        options
+      );
+    },
+    reconcileDocument(clientName, connectionId, input, options) {
+      return call(
+        "POST",
+        withPathParam(
+          withPathParam(
+            "/admin/billing/clients/{client_name}/connections/{connection_id}/reconcile",
+            "client_name",
+            clientName
+          ),
+          "connection_id",
+          connectionId
+        ),
+        {
+          resourceKind: input.resourceKind,
+          resourceId: input.resourceId,
+          customerId: input.customerId
+        },
+        options
+      );
+    },
+    listWebhookEvents(clientName, options) {
+      return call(
+        "GET",
+        withPathParam(
+          "/admin/billing/clients/{client_name}/webhook-events",
+          "client_name",
+          clientName
+        ),
+        void 0,
+        options
+      );
+    },
+    provisionWebhookSinks(clientName, input, options) {
+      return call(
+        "POST",
+        appendQuery(
+          withPathParam(
+            "/admin/billing/clients/{client_name}/webhook-sinks/provision",
+            "client_name",
+            clientName
+          ),
+          {
+            targetSchema: input?.targetSchema,
+            instance: input?.instance
+          }
+        ),
+        {},
+        options
+      );
+    },
+    listGrants(options) {
+      return call("GET", "/admin/billing/grants", void 0, options);
+    },
+    listProviders(options) {
+      return call("GET", "/admin/billing/providers", void 0, options);
+    },
+    listSinkHelpers(query, options) {
+      return call(
+        "GET",
+        appendQuery("/admin/webhook-sinks/helpers/billing", {
+          targetSchema: query?.targetSchema,
+          instance: query?.instance
+        }),
+        void 0,
+        options
+      );
+    },
+    ingestProviderWebhook(input, options) {
+      const path = withPathParam(
+        withPathParam(
+          withPathParam(
+            "/billing/providers/{provider}/clients/{client_name}/connections/{connection_id}/webhook",
+            "provider",
+            input.provider
+          ),
+          "client_name",
+          input.clientName
+        ),
+        "connection_id",
+        input.connectionId
+      );
+      return call("POST", path, input.body, {
+        ...options,
+        headers: {
+          ...options?.headers ?? {},
+          ...input.signatureHeaders ?? {}
+        }
+      });
+    },
+    getDebugBilling(jwtSecret, options) {
+      return call(
+        "GET",
+        appendQuery("/debug/billing", { jwt_secret: jwtSecret }),
+        void 0,
+        options,
+        "text"
+      );
+    }
+  };
+}
+
+// src/billing/live-http-routes.json
+var live_http_routes_default = {
+  consumers: [
+    "openapi.yaml",
+    "openapi.json",
+    "packages/athena-js billingSdkManifest",
+    "tests/billing_contract_spine.rs"
+  ],
+  description: "Live Athena billing HTTP surface. Owned by athena_billing::live_http_routes (Rust). Export with: cargo run -p athena-billing --bin billing-contract-spine -- --write",
+  domain: "billing",
+  routes: [
+    {
+      method: "GET",
+      path: "/admin/billing/clients/{client_name}/connections",
+      surface: "admin"
+    },
+    {
+      method: "POST",
+      path: "/admin/billing/clients/{client_name}/connections",
+      surface: "admin"
+    },
+    {
+      method: "DELETE",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}",
+      surface: "admin"
+    },
+    {
+      method: "GET",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}",
+      surface: "admin"
+    },
+    {
+      method: "PATCH",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}",
+      surface: "admin"
+    },
+    {
+      method: "POST",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}/reconcile",
+      surface: "admin"
+    },
+    {
+      method: "GET",
+      path: "/admin/billing/clients/{client_name}/webhook-events",
+      surface: "admin"
+    },
+    {
+      method: "POST",
+      path: "/admin/billing/clients/{client_name}/webhook-sinks/provision",
+      surface: "admin"
+    },
+    {
+      method: "GET",
+      path: "/admin/billing/grants",
+      surface: "admin"
+    },
+    {
+      method: "GET",
+      path: "/admin/billing/providers",
+      surface: "admin"
+    },
+    {
+      method: "GET",
+      path: "/admin/webhook-sinks/helpers/billing",
+      surface: "admin"
+    },
+    {
+      method: "POST",
+      path: "/billing/providers/{provider}/clients/{client_name}/connections/{connection_id}/webhook",
+      surface: "providerWebhook"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/capabilities",
+      surface: "billingV1"
+    },
+    {
+      method: "POST",
+      path: "/billing/v1/checkouts",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/customers",
+      surface: "billingV1"
+    },
+    {
+      method: "POST",
+      path: "/billing/v1/customers",
+      surface: "billingV1"
+    },
+    {
+      method: "DELETE",
+      path: "/billing/v1/customers/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/customers/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "PATCH",
+      path: "/billing/v1/customers/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/invoices",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/invoices/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/payment-links",
+      surface: "billingV1"
+    },
+    {
+      method: "POST",
+      path: "/billing/v1/payment-links",
+      surface: "billingV1"
+    },
+    {
+      method: "DELETE",
+      path: "/billing/v1/payment-links/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/payment-links/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "PATCH",
+      path: "/billing/v1/payment-links/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/payments",
+      surface: "billingV1"
+    },
+    {
+      method: "POST",
+      path: "/billing/v1/payments",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/payments/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "POST",
+      path: "/billing/v1/payments/{id}/cancel",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/refunds",
+      surface: "billingV1"
+    },
+    {
+      method: "POST",
+      path: "/billing/v1/refunds",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/refunds/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "POST",
+      path: "/billing/v1/refunds/{id}/cancel",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/subscriptions",
+      surface: "billingV1"
+    },
+    {
+      method: "POST",
+      path: "/billing/v1/subscriptions",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/billing/v1/subscriptions/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "PATCH",
+      path: "/billing/v1/subscriptions/{id}",
+      surface: "billingV1"
+    },
+    {
+      method: "POST",
+      path: "/billing/v1/subscriptions/{id}/cancel",
+      surface: "billingV1"
+    },
+    {
+      method: "GET",
+      path: "/debug/billing",
+      surface: "debug"
+    }
+  ],
+  schemaVersion: 1,
+  sourceOfTruth: "crates/athena-billing/src/live_http_routes.rs",
+  sources: [
+    "src/api/billing.rs",
+    "src/api/billing_v1/**",
+    "src/api/debug/billing.rs"
+  ]
+};
+
+export { AthenaBillingError, live_http_routes_default as billingLiveHttpRoutes, billingSdkManifest, createBillingModule };
+//# sourceMappingURL=billing.js.map
+//# sourceMappingURL=billing.js.map