@develemit/billing 0.1.0

package/dist/index.cjs

@@ -0,0 +1,625 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BillingApiError: () => BillingApiError,
+  checkEntitlement: () => checkEntitlement,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../shared-types/src/admin.ts
+var import_zod5 = require("zod");
+
+// ../shared-types/src/event-log.ts
+var import_zod = require("zod");
+var eventStatusSchema = import_zod.z.enum([
+  "received",
+  "processed",
+  "failed",
+  "dead_letter",
+  "discarded"
+]);
+var subscriptionStateSchema = import_zod.z.enum([
+  "trialing",
+  "active",
+  "past_due",
+  "canceled",
+  "unpaid"
+]);
+var adminEventSummarySchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  projectId: import_zod.z.string(),
+  providerEventId: import_zod.z.string(),
+  type: import_zod.z.string(),
+  status: eventStatusSchema,
+  attempts: import_zod.z.number(),
+  lastError: import_zod.z.string().nullable(),
+  errorSignature: import_zod.z.string().nullable(),
+  receivedAt: import_zod.z.iso.datetime(),
+  processedAt: import_zod.z.iso.datetime().nullable(),
+  // event_log has no subject/customer reference column (sprint 24's
+  // repo-drizzle-subjects.ts documents the same gap the other direction) —
+  // derived from the raw Stripe payload's well-known `data.object.customer`
+  // path, so this is null for any non-Stripe-shaped payload.
+  subjectRef: import_zod.z.string().nullable()
+});
+var adminEventDetailSchema = adminEventSummarySchema.extend({
+  payload: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()),
+  discardReason: import_zod.z.string().nullable(),
+  discardedBy: import_zod.z.string().nullable(),
+  discardedAt: import_zod.z.iso.datetime().nullable()
+});
+var signatureCountSchema = import_zod.z.object({
+  signature: import_zod.z.string(),
+  count: import_zod.z.number()
+});
+var listEventsResponseSchema = import_zod.z.object({
+  events: import_zod.z.array(adminEventSummarySchema),
+  total: import_zod.z.number(),
+  limit: import_zod.z.number(),
+  offset: import_zod.z.number(),
+  signatureCounts: import_zod.z.array(signatureCountSchema)
+});
+var wouldApplySchema = import_zod.z.discriminatedUnion("kind", [
+  import_zod.z.object({ kind: import_zod.z.literal("create"), to: subscriptionStateSchema }),
+  import_zod.z.object({
+    kind: import_zod.z.literal("transition"),
+    from: subscriptionStateSchema,
+    to: subscriptionStateSchema
+  }),
+  import_zod.z.object({ kind: import_zod.z.literal("stale") }),
+  import_zod.z.object({
+    kind: import_zod.z.literal("invalid"),
+    from: subscriptionStateSchema,
+    to: subscriptionStateSchema
+  }),
+  import_zod.z.object({ kind: import_zod.z.literal("unknown_subscription") }),
+  import_zod.z.object({ kind: import_zod.z.literal("noop"), reason: import_zod.z.string() }),
+  import_zod.z.object({ kind: import_zod.z.literal("error"), reason: import_zod.z.string() })
+]);
+var dryRunReplayResponseSchema = import_zod.z.object({
+  event: adminEventDetailSchema,
+  current: import_zod.z.object({
+    state: subscriptionStateSchema,
+    lastEventAt: import_zod.z.iso.datetime().nullable()
+  }).nullable(),
+  wouldApply: wouldApplySchema
+});
+var replayOutcomeSchema = import_zod.z.enum([
+  "created",
+  "transitioned",
+  "stale",
+  "noop",
+  "invalid",
+  "unknown_subscription",
+  "already_processed",
+  "error"
+]);
+var replayResponseSchema = import_zod.z.object({
+  outcome: replayOutcomeSchema
+});
+var discardEventRequestSchema = import_zod.z.object({
+  actor: import_zod.z.string().min(1),
+  reason: import_zod.z.string()
+});
+var replayGroupCursorSchema = import_zod.z.object({
+  receivedAt: import_zod.z.iso.datetime(),
+  id: import_zod.z.string()
+});
+var replayGroupRequestSchema = import_zod.z.object({
+  projectId: import_zod.z.string().min(1),
+  cursor: replayGroupCursorSchema.optional(),
+  limit: import_zod.z.number().int().positive().optional()
+}).and(
+  import_zod.z.union([
+    import_zod.z.object({ errorSignature: import_zod.z.string().min(1) }),
+    import_zod.z.object({ all: import_zod.z.literal(true) })
+  ])
+);
+var replayGroupOutcomeEntrySchema = import_zod.z.object({
+  eventId: import_zod.z.string(),
+  outcome: replayOutcomeSchema
+});
+var replayGroupResponseSchema = import_zod.z.object({
+  outcomes: import_zod.z.array(replayGroupOutcomeEntrySchema),
+  // Keyed by ProcessOutcome, but zod v4's record needs .partial() semantics
+  // for an exhaustive enum key type, so this stays a plain string map — the
+  // set of possible keys is still exactly replayOutcomeSchema's members.
+  counts: import_zod.z.record(import_zod.z.string(), import_zod.z.number()),
+  // This call's batch (its own limit, or BULK_REPLAY_CAP by default) hit its
+  // ceiling: more matching events remain beyond what was just replayed.
+  // Paging with nextCursor continues; a non-paging caller reads this the
+  // same way it always has, as "replay again to finish draining it."
+  truncated: import_zod.z.boolean(),
+  nextCursor: replayGroupCursorSchema.nullable()
+});
+
+// ../shared-types/src/entitlements.ts
+var import_zod3 = require("zod");
+
+// ../shared-types/src/subscriptions.ts
+var import_zod2 = require("zod");
+var subscriptionStatusSchema = import_zod2.z.enum([
+  "trialing",
+  "active",
+  "past_due",
+  "grace",
+  "canceled",
+  "unpaid",
+  "none"
+]);
+var activeSubscriptionViewSchema = import_zod2.z.object({
+  state: subscriptionStatusSchema.exclude(["none"]),
+  planKey: import_zod2.z.string(),
+  currentPeriodEnd: import_zod2.z.iso.datetime(),
+  cancelAtPeriodEnd: import_zod2.z.boolean()
+});
+var noSubscriptionViewSchema = import_zod2.z.object({
+  state: import_zod2.z.literal("none")
+});
+var subscriptionViewSchema = import_zod2.z.discriminatedUnion("state", [
+  activeSubscriptionViewSchema,
+  noSubscriptionViewSchema
+]);
+
+// ../shared-types/src/entitlements.ts
+var entitlementSourcesSchema = import_zod3.z.object({
+  features: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.enum(["subscription", "override"])),
+  limits: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.enum(["subscription", "override"]))
+});
+var entitlementsResponseSchema = import_zod3.z.object({
+  plan: import_zod3.z.string().nullable(),
+  features: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.boolean()),
+  limits: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()),
+  status: subscriptionStatusSchema,
+  source: import_zod3.z.enum(["subscription", "override", "none"]),
+  sources: entitlementSourcesSchema
+});
+
+// ../shared-types/src/overrides.ts
+var import_zod4 = require("zod");
+var overrideKindSchema = import_zod4.z.enum(["comp", "extend", "revoke"]);
+var overrideTargetSchema = import_zod4.z.discriminatedUnion("type", [
+  import_zod4.z.object({ type: import_zod4.z.literal("feature"), feature: import_zod4.z.string().min(1) }),
+  import_zod4.z.object({
+    type: import_zod4.z.literal("limit"),
+    limit: import_zod4.z.string().min(1),
+    value: import_zod4.z.number()
+  })
+]);
+var createOverrideRequestSchema = import_zod4.z.object({
+  subjectId: import_zod4.z.string().min(1),
+  kind: overrideKindSchema,
+  target: overrideTargetSchema,
+  actor: import_zod4.z.string().min(1),
+  reason: import_zod4.z.string().min(4),
+  expiresAt: import_zod4.z.iso.datetime().optional()
+});
+var createBulkOverrideRequestSchema = import_zod4.z.object({
+  subjectId: import_zod4.z.string().min(1),
+  kind: overrideKindSchema,
+  targets: import_zod4.z.array(overrideTargetSchema).min(1),
+  actor: import_zod4.z.string().min(1),
+  reason: import_zod4.z.string().min(4),
+  expiresAt: import_zod4.z.iso.datetime().optional()
+});
+var overrideRecordSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  subjectId: import_zod4.z.string(),
+  kind: overrideKindSchema,
+  target: overrideTargetSchema,
+  actor: import_zod4.z.string(),
+  reason: import_zod4.z.string(),
+  expiresAt: import_zod4.z.iso.datetime().nullable(),
+  createdAt: import_zod4.z.iso.datetime()
+});
+var bulkOverrideResponseSchema = import_zod4.z.object({
+  overrides: import_zod4.z.array(overrideRecordSchema)
+});
+var listOverridesResponseSchema = import_zod4.z.object({
+  overrides: import_zod4.z.array(overrideRecordSchema),
+  total: import_zod4.z.number(),
+  limit: import_zod4.z.number(),
+  offset: import_zod4.z.number()
+});
+
+// ../shared-types/src/admin.ts
+var stateCountsSchema = import_zod5.z.object({
+  trialing: import_zod5.z.number(),
+  active: import_zod5.z.number(),
+  past_due: import_zod5.z.number(),
+  grace: import_zod5.z.number(),
+  canceled: import_zod5.z.number(),
+  unpaid: import_zod5.z.number()
+});
+var dashboardMetricsSchema = import_zod5.z.object({
+  mrrCents: import_zod5.z.number(),
+  mrrPrevCents: import_zod5.z.number(),
+  subjectsCount: import_zod5.z.number(),
+  states: stateCountsSchema,
+  deadLetterDepth: import_zod5.z.number(),
+  oldestUnprocessedSec: import_zod5.z.number().nullable(),
+  driftCount: import_zod5.z.number()
+});
+var projectMetricsSchema = dashboardMetricsSchema.extend({
+  projectId: import_zod5.z.string(),
+  projectKey: import_zod5.z.string(),
+  projectName: import_zod5.z.string(),
+  subjectType: import_zod5.z.string(),
+  environment: import_zod5.z.enum(["test", "live"]),
+  envLocked: import_zod5.z.boolean(),
+  mrrSeries: import_zod5.z.array(import_zod5.z.number())
+});
+var adminMetricsResponseSchema = import_zod5.z.object({
+  ecosystem: dashboardMetricsSchema,
+  // Shared x-axis labels for every project's mrrSeries (same calendar
+  // months across the ecosystem) — empty when no project has snapshots yet.
+  monthLabels: import_zod5.z.array(import_zod5.z.string()),
+  projects: import_zod5.z.array(projectMetricsSchema)
+});
+var adminEventsListResponseSchema = import_zod5.z.object({
+  events: import_zod5.z.array(adminEventSummarySchema),
+  nextCursor: import_zod5.z.string().nullable(),
+  approxTotal: import_zod5.z.number(),
+  signatureCounts: import_zod5.z.array(signatureCountSchema).optional()
+});
+var adminEventDetailResponseSchema = import_zod5.z.object({
+  event: adminEventDetailSchema,
+  transition: import_zod5.z.object({
+    current: import_zod5.z.object({
+      state: subscriptionStatusSchema.exclude(["grace", "none"]),
+      lastEventAt: import_zod5.z.iso.datetime().nullable()
+    }).nullable(),
+    wouldApply: wouldApplySchema
+  })
+});
+var adminSubjectSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  subjectType: import_zod5.z.string(),
+  externalId: import_zod5.z.string(),
+  providerCustomerId: import_zod5.z.string().nullable()
+});
+var featureGrantsSchema = import_zod5.z.record(
+  import_zod5.z.string(),
+  import_zod5.z.union([import_zod5.z.boolean(), import_zod5.z.number()])
+);
+var adminSubjectSubscriptionPlanSchema = import_zod5.z.object({
+  key: import_zod5.z.string(),
+  featureGrants: featureGrantsSchema,
+  priceInterval: import_zod5.z.enum(["month", "year"]).nullable()
+});
+var adminSubjectLookupResponseSchema = import_zod5.z.object({
+  subject: adminSubjectSchema,
+  entitlements: entitlementsResponseSchema,
+  recentEvents: import_zod5.z.array(adminEventSummarySchema),
+  activeOverrides: import_zod5.z.array(overrideRecordSchema),
+  subscriptionPlan: adminSubjectSubscriptionPlanSchema.nullable()
+});
+var adminPriceSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  interval: import_zod5.z.enum(["month", "year"]),
+  currency: import_zod5.z.string(),
+  unitAmountCents: import_zod5.z.number(),
+  syncStatus: import_zod5.z.enum(["synced", "pending", "drifted"]),
+  syncedUnitAmountCents: import_zod5.z.number().nullable()
+});
+var adminPlanSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  key: import_zod5.z.string(),
+  name: import_zod5.z.string(),
+  featureGrants: featureGrantsSchema,
+  activeSubscriptions: import_zod5.z.number(),
+  prices: import_zod5.z.array(adminPriceSchema)
+});
+var adminPlansResponseSchema = import_zod5.z.object({
+  project: import_zod5.z.object({
+    statementDescriptor: import_zod5.z.string().nullable(),
+    statementDescriptorPrefix: import_zod5.z.string().nullable()
+  }),
+  plans: import_zod5.z.array(adminPlanSchema)
+});
+var adminProviderResponseSchema = import_zod5.z.object({
+  projectId: import_zod5.z.string(),
+  providerKind: import_zod5.z.string(),
+  environment: import_zod5.z.enum(["test", "live"]),
+  envLocked: import_zod5.z.boolean(),
+  secretKeyMasked: import_zod5.z.string().nullable(),
+  publishableKeyMasked: import_zod5.z.string().nullable(),
+  webhookEndpoint: import_zod5.z.string(),
+  webhookSigningConfigured: import_zod5.z.boolean(),
+  defaultPortalReturnUrl: import_zod5.z.string().nullable()
+});
+var adminAuditEntrySchema = overrideRecordSchema.extend({
+  projectId: import_zod5.z.string()
+});
+var adminAuditResponseSchema = import_zod5.z.object({
+  entries: import_zod5.z.array(adminAuditEntrySchema),
+  nextCursor: import_zod5.z.string().nullable(),
+  approxTotal: import_zod5.z.number()
+});
+var adminThroughputResponseSchema = import_zod5.z.object({
+  days: import_zod5.z.array(import_zod5.z.string()),
+  processed: import_zod5.z.array(import_zod5.z.number()),
+  failed: import_zod5.z.array(import_zod5.z.number())
+});
+var adminPlanMixResponseSchema = import_zod5.z.object({
+  months: import_zod5.z.array(import_zod5.z.string()),
+  plans: import_zod5.z.array(import_zod5.z.object({ key: import_zod5.z.string(), name: import_zod5.z.string() })),
+  stacks: import_zod5.z.array(import_zod5.z.array(import_zod5.z.number()))
+});
+var adminDeadLetterGroupSchema = import_zod5.z.object({
+  projectId: import_zod5.z.string(),
+  signature: import_zod5.z.string(),
+  count: import_zod5.z.number(),
+  sampleEventId: import_zod5.z.string(),
+  firstReceivedAt: import_zod5.z.iso.datetime(),
+  lastReceivedAt: import_zod5.z.iso.datetime()
+});
+var adminDeadLetterGroupsResponseSchema = import_zod5.z.object({
+  groups: import_zod5.z.array(adminDeadLetterGroupSchema)
+});
+var adminProjectDashboardResponseSchema = import_zod5.z.object({
+  metrics: projectMetricsSchema,
+  monthLabels: import_zod5.z.array(import_zod5.z.string()),
+  providerKind: import_zod5.z.string(),
+  plans: import_zod5.z.array(adminPlanSchema)
+});
+
+// ../shared-types/src/checkout.ts
+var import_zod6 = require("zod");
+var checkoutRequestSchema = import_zod6.z.object({
+  planKey: import_zod6.z.string(),
+  subjectId: import_zod6.z.string(),
+  successUrl: import_zod6.z.url(),
+  cancelUrl: import_zod6.z.url(),
+  email: import_zod6.z.email().optional()
+});
+var checkoutResponseSchema = import_zod6.z.object({
+  url: import_zod6.z.url()
+});
+var portalRequestSchema = import_zod6.z.object({
+  subjectId: import_zod6.z.string(),
+  returnUrl: import_zod6.z.url()
+});
+var portalResponseSchema = import_zod6.z.object({
+  url: import_zod6.z.url()
+});
+
+// ../shared-types/src/projects.ts
+var import_zod7 = require("zod");
+var registerProjectRequestSchema = import_zod7.z.object({
+  key: import_zod7.z.string().trim().min(1, "is required"),
+  name: import_zod7.z.string().trim().min(1, "is required"),
+  subjectType: import_zod7.z.string().trim().min(1, "is required"),
+  environment: import_zod7.z.enum(["test", "live"], 'must be "test" or "live"'),
+  envLocked: import_zod7.z.boolean().optional(),
+  providerKind: import_zod7.z.string().trim().min(1, "is required"),
+  providerSecretKeyRef: import_zod7.z.string().optional(),
+  providerPublishableKeyRef: import_zod7.z.string().optional(),
+  providerPortalConfigRef: import_zod7.z.string().optional(),
+  statementDescriptor: import_zod7.z.string().optional(),
+  statementDescriptorPrefix: import_zod7.z.string().optional(),
+  graceDays: import_zod7.z.number().min(0, "must be >= 0").optional(),
+  defaultPortalReturnUrl: import_zod7.z.url().optional()
+}).superRefine((input, ctx) => {
+  if (!input.statementDescriptor && !input.statementDescriptorPrefix) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["statementDescriptor"],
+      message: "statementDescriptor or statementDescriptorPrefix is required"
+    });
+  }
+});
+
+// ../shared-types/src/errors.ts
+var import_zod8 = require("zod");
+var errorEnvelopeSchema = import_zod8.z.object({
+  error: import_zod8.z.object({
+    code: import_zod8.z.string(),
+    message: import_zod8.z.string()
+  })
+});
+
+// ../shared-types/src/webhook-secret.ts
+var import_zod9 = require("zod");
+var webhookSigningSecretSchema = import_zod9.z.string().regex(/^whsec_.+/, "must be a non-empty whsec_-prefixed string");
+
+// ../shared-types/src/portal-return-url.ts
+var import_zod10 = require("zod");
+var portalReturnUrlSchema = import_zod10.z.url();
+
+// src/cache.ts
+var TtlCache = class {
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  now;
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.store.get(key);
+  }
+  set(key, value) {
+    this.store.set(key, { value, fetchedAt: this.now() });
+  }
+  getFresh(key, ttlMs) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    return this.now() - entry.fetchedAt < ttlMs ? entry.value : void 0;
+  }
+  getStale(key) {
+    return this.store.get(key)?.value;
+  }
+};
+
+// src/errors.ts
+var BillingApiError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.name = "BillingApiError";
+    this.status = status;
+    this.code = code;
+  }
+};
+async function errorFromResponse(response) {
+  let code = "unknown_error";
+  let message = `Request failed with status ${response.status}`;
+  try {
+    const body = await response.json();
+    const parsed = errorEnvelopeSchema.safeParse(body);
+    if (parsed.success) {
+      code = parsed.data.error.code;
+      message = parsed.data.error.message;
+    }
+  } catch {
+  }
+  return new BillingApiError(response.status, code, message);
+}
+function networkError(cause) {
+  const message = cause instanceof Error ? cause.message : "Network request failed";
+  return new BillingApiError(0, "network_error", message);
+}
+function invalidResponseError(message) {
+  return new BillingApiError(502, "invalid_response", message);
+}
+
+// src/client.ts
+var DEFAULT_ENTITLEMENTS_TTL_MS = 5e3;
+async function requestJson(fetchImpl, url, apiKey, init) {
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      ...init,
+      headers: {
+        ...init?.headers,
+        Authorization: `Bearer ${apiKey}`,
+        ...init?.body ? { "Content-Type": "application/json" } : {}
+      }
+    });
+  } catch (cause) {
+    throw networkError(cause);
+  }
+  if (!response.ok) {
+    throw await errorFromResponse(response);
+  }
+  return response.json();
+}
+function parseOrThrow(schema, data) {
+  const parsed = schema.safeParse(data);
+  if (!parsed.success) {
+    throw invalidResponseError(
+      `Response failed validation: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+function createClient(options) {
+  const { apiKey, baseUrl } = options;
+  const fetchImpl = options.fetch ?? fetch;
+  const entitlementsTtlMs = options.entitlementsTtlMs ?? DEFAULT_ENTITLEMENTS_TTL_MS;
+  const entitlementsCache = new TtlCache();
+  async function getEntitlements(subjectId) {
+    const fresh = entitlementsCache.getFresh(subjectId, entitlementsTtlMs);
+    if (fresh) return fresh;
+    try {
+      const data = await requestJson(
+        fetchImpl,
+        `${baseUrl}/v1/entitlements/${encodeURIComponent(subjectId)}`,
+        apiKey
+      );
+      const parsed = parseOrThrow(entitlementsResponseSchema, data);
+      entitlementsCache.set(subjectId, parsed);
+      return parsed;
+    } catch (err) {
+      const isClientError = err instanceof BillingApiError && err.status >= 400 && err.status < 500;
+      if (isClientError) throw err;
+      const stale = entitlementsCache.getStale(subjectId);
+      if (stale) return { ...stale, stale: true };
+      throw err;
+    }
+  }
+  async function createCheckout(input) {
+    const data = await requestJson(
+      fetchImpl,
+      `${baseUrl}/v1/checkout`,
+      apiKey,
+      {
+        method: "POST",
+        body: JSON.stringify(input)
+      }
+    );
+    return parseOrThrow(checkoutResponseSchema, data);
+  }
+  async function portalUrl(input) {
+    const data = await requestJson(fetchImpl, `${baseUrl}/v1/portal`, apiKey, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return parseOrThrow(portalResponseSchema, data);
+  }
+  async function getSubscription(subjectId) {
+    const data = await requestJson(
+      fetchImpl,
+      `${baseUrl}/v1/subscriptions/${encodeURIComponent(subjectId)}`,
+      apiKey
+    );
+    return parseOrThrow(subscriptionViewSchema, data);
+  }
+  return { getEntitlements, createCheckout, portalUrl, getSubscription };
+}
+
+// src/guard.ts
+function isMisconfiguration(err) {
+  return err instanceof BillingApiError && err.status >= 400 && err.status < 500;
+}
+function decideOnContent(entitlements, feature, limit) {
+  if (feature !== void 0) {
+    return entitlements.features[feature] ? { decision: "allow", entitlements } : { decision: "deny", reason: `Feature "${feature}" is not entitled` };
+  }
+  if (limit !== void 0) {
+    const max = entitlements.limits[limit.key];
+    return max !== void 0 && limit.usage < max ? { decision: "allow", entitlements } : { decision: "deny", reason: `Limit "${limit.key}" has been reached` };
+  }
+  return { decision: "allow", entitlements };
+}
+async function checkEntitlement(input) {
+  const { client, subjectId, feature, limit, onUnavailable } = input;
+  let entitlements;
+  try {
+    entitlements = await client.getEntitlements(subjectId);
+  } catch (err) {
+    if (isMisconfiguration(err)) {
+      const message = err instanceof Error ? err.message : "Billing request was rejected";
+      return { decision: "deny", reason: message, misconfigured: true };
+    }
+    return onUnavailable === "open" ? { decision: "unavailable-allow" } : { decision: "unavailable-deny", reason: "Billing is unavailable" };
+  }
+  return decideOnContent(entitlements, feature, limit);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BillingApiError,
+  checkEntitlement,
+  createClient
+});
+//# sourceMappingURL=index.cjs.map