@feelflow/ffid-sdk 5.24.3 → 5.27.0

package/dist/{chunk-O3HGRALD.js → chunk-JZB2IM7Y.js}

@@ -114,6 +114,24 @@ function isSessionEligibleSubscriptionStatus(value) {
 function hasOwnKey(value, key) {
   return Object.prototype.hasOwnProperty.call(value, key);
 }
+function normalizeEntitlements(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.flatMap((code) => {
+    if (typeof code !== "string") return [];
+    const trimmed = code.trim();
+    return trimmed.length > 0 ? [trimmed] : [];
+  });
+}
+function normalizeSeatAssignmentClaim(raw, organizationId, subscriptionId) {
+  if (!raw || typeof raw !== "object") return null;
+  const { organization_id, subscription_id, status } = raw;
+  if (typeof organization_id !== "string" || typeof subscription_id !== "string" || typeof status !== "string" || !["active", "revoking", "revoked"].includes(status) || organization_id !== organizationId || subscription_id !== subscriptionId) return null;
+  return {
+    organizationId: organization_id,
+    subscriptionId: subscription_id,
+    status
+  };
+}
 function normalizeUserinfo(raw) {
   const hasOrganizationId = hasOwnKey(raw, "organization_id");
   const hasOrganizationName = hasOwnKey(raw, "organization_name");
@@ -147,6 +165,11 @@ function normalizeUserinfo(raw) {
       organizationId: raw.subscription.organization_id ?? null,
       organizationName: hasOwnKey(raw.subscription, "organization_name") ? raw.subscription.organization_name ?? null : null,
       hasSeatAssignment: raw.subscription.has_seat_assignment ?? false,
+      seatAssignment: hasOwnKey(raw.subscription, "seat_assignment") ? normalizeSeatAssignmentClaim(
+        raw.subscription.seat_assignment,
+        raw.subscription.organization_id ?? null,
+        raw.subscription.subscription_id ?? null
+      ) : void 0,
       // #3464: legacy FFID (< this issue) omits the field on the wire.
       // The "unknown" axis is unused — no consumer differentiates "server
       // didn't tell us" from "definitely not scheduled" because the
@@ -154,7 +177,10 @@ function normalizeUserinfo(raw) {
       // `'active_canceling'`) for legacy backends. Defaulting to `false`
       // here keeps the downstream contract a plain boolean.
       cancelAtPeriodEnd: raw.subscription.cancel_at_period_end ?? false,
-      currentPeriodEnd: raw.subscription.current_period_end ?? null
+      currentPeriodEnd: raw.subscription.current_period_end ?? null,
+      // #4333: legacy FFID (< this issue) omits the field on the wire; the
+      // guard defaults to `[]` so consumers always get a plain string[].
+      entitlements: normalizeEntitlements(raw.subscription.entitlements)
     } : void 0
   };
 }
@@ -441,7 +467,12 @@ function createVerifyAccessToken(deps) {
         member_role: introspectResponse.subscription.member_role,
         organization_id: introspectResponse.subscription.organization_id,
         organization_name: introspectResponse.subscription.organization_name ?? null,
-        has_seat_assignment: introspectResponse.subscription.has_seat_assignment ?? false
+        has_seat_assignment: introspectResponse.subscription.has_seat_assignment ?? false,
+        ...Object.prototype.hasOwnProperty.call(introspectResponse.subscription, "seat_assignment") ? { seat_assignment: introspectResponse.subscription.seat_assignment } : {},
+        // #4333: forward pack entitlement codes through the introspect →
+        // userinfo normalization boundary. normalizeUserinfo guards the
+        // value, so an older FFID that omits it degrades to `[]`.
+        entitlements: introspectResponse.subscription.entitlements
       }
     } : base;
     const userinfo = normalizeUserinfo(raw);
@@ -812,6 +843,364 @@ function createSubscriptionMethods(deps) {
   };
 }
 
+// src/types/published-catalog.ts
+var FFID_CATALOG_ENVIRONMENTS = ["staging", "production"];
+var FFID_CATALOG_PUBLICATION_STATUSES = [
+  "approved",
+  "superseded",
+  "revoking",
+  "revoked"
+];
+
+// src/shared/catalog-hash.ts
+var CATALOG_HASH_PATTERN = /^[0-9a-f]{64}$/;
+var HEX_RADIX = 16;
+var HEX_DIGITS_PER_BYTE = 2;
+var FFIDCatalogHashError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FFIDCatalogHashError";
+  }
+};
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function canonicalize(value, path) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw new FFIDCatalogHashError(
+          `canonicalize: non-finite number at ${path} \u2014 hashes require finite numbers`
+        );
+      }
+      return JSON.stringify(value);
+    case "undefined":
+      throw new FFIDCatalogHashError(
+        `canonicalize: undefined at ${path} \u2014 omit the key entirely or use null`
+      );
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item, index) => canonicalize(item, `${path}[${index}]`));
+    return `[${items.join(",")}]`;
+  }
+  if (isPlainObject(value)) {
+    const keys = Object.keys(value).sort();
+    const entries = [];
+    for (const key of keys) {
+      const child = value[key];
+      if (child === void 0) {
+        throw new FFIDCatalogHashError(
+          `canonicalize: undefined at ${path}.${key} \u2014 omit the key entirely or use null`
+        );
+      }
+      entries.push(`${JSON.stringify(key)}:${canonicalize(child, `${path}.${key}`)}`);
+    }
+    return `{${entries.join(",")}}`;
+  }
+  throw new FFIDCatalogHashError(
+    `canonicalize: unsupported value type (${typeof value}${typeof value === "object" ? `: ${Object.prototype.toString.call(value)}` : ""}) at ${path} \u2014 only JSON-plain values are hashable`
+  );
+}
+function canonicalizeCatalogValue(value) {
+  return canonicalize(value, "$");
+}
+async function sha256Hex(text) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new FFIDCatalogHashError(
+      "sha256Hex: Web Crypto (crypto.subtle) is not available in this runtime"
+    );
+  }
+  const digest = await subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(HEX_RADIX).padStart(HEX_DIGITS_PER_BYTE, "0")).join("");
+}
+async function hashCanonicalJson(value) {
+  return sha256Hex(canonicalizeCatalogValue(value));
+}
+function assertHashFormat(hash, field) {
+  if (!CATALOG_HASH_PATTERN.test(hash)) {
+    throw new FFIDCatalogHashError(
+      `${field} must be lowercase SHA-256 hex (64 chars), got: ${JSON.stringify(hash)}`
+    );
+  }
+}
+function normalizeStringSet(values) {
+  return [...new Set(values)].sort();
+}
+function compareByCodeUnits(a, b) {
+  if (a.code < b.code) return -1;
+  if (a.code > b.code) return 1;
+  return 0;
+}
+async function computePraxisCopyHash(presentation) {
+  return hashCanonicalJson(presentation);
+}
+async function computeFFIDCheckoutCopyHash(checkoutCopy) {
+  return hashCanonicalJson(checkoutCopy);
+}
+async function computeLegalDisclosureHash(canonicalText) {
+  return sha256Hex(canonicalText.replace(/\r\n?/g, "\n"));
+}
+async function computeTaxConfigurationHash(config) {
+  return hashCanonicalJson({
+    allowedCountries: normalizeStringSet(config.allowedCountries),
+    stripeTaxRegistrations: normalizeStringSet(config.stripeTaxRegistrations),
+    billingAddressRequired: config.billingAddressRequired,
+    planTaxCodes: config.planTaxCodes,
+    planTaxBehaviors: config.planTaxBehaviors
+  });
+}
+async function computePaymentConfigurationHash(config) {
+  return hashCanonicalJson({
+    environment: config.environment,
+    currency: config.currency,
+    paymentMethodTypes: normalizeStringSet(config.paymentMethodTypes),
+    dynamicPaymentMethodsEnabled: config.dynamicPaymentMethodsEnabled,
+    manualInvoiceAllowed: config.manualInvoiceAllowed,
+    customerBalanceAllowed: config.customerBalanceAllowed,
+    delayedPaymentMethodsAllowed: config.delayedPaymentMethodsAllowed,
+    customerInvoiceBalanceRequired: config.customerInvoiceBalanceRequired
+  });
+}
+async function computeScopeHash(input) {
+  assertHashFormat(input.praxisCopyHash, "praxisCopyHash");
+  assertHashFormat(input.ffidCheckoutCopyHash, "ffidCheckoutCopyHash");
+  assertHashFormat(input.legalDisclosureHash, "legalDisclosureHash");
+  assertHashFormat(input.taxConfigurationHash, "taxConfigurationHash");
+  assertHashFormat(input.paymentConfigurationHash, "paymentConfigurationHash");
+  const seenCodes = /* @__PURE__ */ new Set();
+  for (const plan of input.plans) {
+    if (seenCodes.has(plan.code)) {
+      throw new FFIDCatalogHashError(
+        `computeScopeHash: duplicate plan code ${JSON.stringify(plan.code)}`
+      );
+    }
+    seenCodes.add(plan.code);
+  }
+  const plans = [...input.plans].sort(compareByCodeUnits).map((plan) => ({
+    code: plan.code,
+    priceMonthly: plan.priceMonthly,
+    priceYearly: plan.priceYearly,
+    currency: plan.currency,
+    // Set semantics — interval order must not flip the digest.
+    billingIntervals: normalizeStringSet(plan.billingIntervals),
+    taxBehavior: plan.taxBehavior,
+    minSeats: plan.minSeats
+  }));
+  return hashCanonicalJson({
+    plans,
+    praxisCopyHash: input.praxisCopyHash,
+    ffidCheckoutCopyHash: input.ffidCheckoutCopyHash,
+    legalDisclosureHash: input.legalDisclosureHash,
+    taxConfigurationHash: input.taxConfigurationHash,
+    paymentConfigurationHash: input.paymentConfigurationHash
+  });
+}
+
+// src/client/catalog-methods.ts
+var EXT_CATALOG_ENDPOINT = "/api/v1/subscriptions/ext/catalog";
+var MALFORMED_CATALOG_CODE = "MALFORMED_PUBLISHED_CATALOG";
+var PUBLICATION_STATUSES = new Set(
+  FFID_CATALOG_PUBLICATION_STATUSES
+);
+var CATALOG_ENVIRONMENTS = new Set(FFID_CATALOG_ENVIRONMENTS);
+var BILLING_INTERVALS = /* @__PURE__ */ new Set(["monthly", "yearly"]);
+var TAX_BEHAVIORS = /* @__PURE__ */ new Set(["inclusive", "exclusive"]);
+var PUBLICATION_HASH_FIELDS = [
+  "praxisCopyHash",
+  "ffidCheckoutCopyHash",
+  "legalDisclosureHash",
+  "taxConfigurationHash",
+  "paymentConfigurationHash",
+  "scopeHash"
+];
+var PUBLICATION_REQUIRED_TIMESTAMP_FIELDS = ["reviewedAt", "effectiveAt"];
+var PUBLICATION_NULLABLE_TIMESTAMP_FIELDS = [
+  "supersededAt",
+  "sellThroughUntil",
+  "revocationEffectiveAt"
+];
+function malformed(detail) {
+  return new FFIDSDKError(
+    MALFORMED_CATALOG_CODE,
+    `SDK: server returned malformed PublishedCatalog \u2014 ${detail}`
+  );
+}
+function isNullableIsoString(value) {
+  return value === null || typeof value === "string" && value.trim() !== "";
+}
+function isNonNegativeIntOrNull(value) {
+  return value === null || typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function validatePublishedPlan(plan, index) {
+  if (plan === null || typeof plan !== "object") {
+    throw malformed(`plans[${index}] must be an object`);
+  }
+  const record = plan;
+  for (const key of Object.keys(record)) {
+    if (/stripe/i.test(key)) {
+      throw malformed(
+        `plans[${index}] contains a Stripe identifier field (${JSON.stringify(key)}) \u2014 published catalogs must never expose Stripe IDs`
+      );
+    }
+  }
+  if (isBlankString(record.code)) {
+    throw malformed(`plans[${index}].code must be a non-empty string`);
+  }
+  if (isBlankString(record.name)) {
+    throw malformed(`plans[${index}].name must be a non-empty string`);
+  }
+  if (record.description !== null && typeof record.description !== "string") {
+    throw malformed(`plans[${index}].description must be string or null`);
+  }
+  if (isBlankString(record.currency)) {
+    throw malformed(`plans[${index}].currency must be a non-empty string`);
+  }
+  if (!isNonNegativeIntOrNull(record.priceMonthly)) {
+    throw malformed(`plans[${index}].priceMonthly must be a non-negative integer or null`);
+  }
+  if (!isNonNegativeIntOrNull(record.priceYearly)) {
+    throw malformed(`plans[${index}].priceYearly must be a non-negative integer or null`);
+  }
+  if (typeof record.taxBehavior !== "string" || !TAX_BEHAVIORS.has(record.taxBehavior)) {
+    throw malformed(
+      `plans[${index}].taxBehavior must be inclusive | exclusive (got ${JSON.stringify(record.taxBehavior)})`
+    );
+  }
+  const intervals = record.billingIntervals;
+  if (!Array.isArray(intervals) || intervals.length === 0 || intervals.some((interval) => typeof interval !== "string" || !BILLING_INTERVALS.has(interval))) {
+    throw malformed(
+      `plans[${index}].billingIntervals must be a non-empty array of monthly | yearly`
+    );
+  }
+  if (intervals.includes("monthly") && record.priceMonthly === null) {
+    throw malformed(`plans[${index}] offers monthly billing but priceMonthly is null`);
+  }
+  if (intervals.includes("yearly") && record.priceYearly === null) {
+    throw malformed(`plans[${index}] offers yearly billing but priceYearly is null`);
+  }
+  if (typeof record.minSeats !== "number" || !Number.isInteger(record.minSeats) || record.minSeats < 1) {
+    throw malformed(`plans[${index}].minSeats must be a positive integer`);
+  }
+  if (record.maxSeats !== null && (typeof record.maxSeats !== "number" || !Number.isInteger(record.maxSeats) || record.maxSeats < 1)) {
+    throw malformed(`plans[${index}].maxSeats must be a positive integer or null`);
+  }
+  if (record.maxSeats !== null && record.maxSeats < record.minSeats) {
+    throw malformed(`plans[${index}].maxSeats must be >= minSeats`);
+  }
+  if (typeof record.displayOrder !== "number" || !Number.isInteger(record.displayOrder)) {
+    throw malformed(`plans[${index}].displayOrder must be an integer`);
+  }
+}
+function validatePublishedCatalog(catalog) {
+  if (catalog === null || typeof catalog !== "object") {
+    throw malformed(
+      `expected object, got ${catalog === null ? "null" : typeof catalog}`
+    );
+  }
+  const c = catalog;
+  const service = c.service;
+  if (service === null || typeof service !== "object") {
+    throw malformed("service must be an object");
+  }
+  const s = service;
+  if (isBlankString(s.code)) {
+    throw malformed("service.code must be a non-empty string");
+  }
+  if (isBlankString(s.name)) {
+    throw malformed("service.name must be a non-empty string");
+  }
+  if (isBlankString(c.catalogVersion)) {
+    throw malformed("catalogVersion must be a non-empty string");
+  }
+  const publication = c.publication;
+  if (publication === null || typeof publication !== "object") {
+    throw malformed("publication must be an object");
+  }
+  const p = publication;
+  if (isBlankString(p.serviceCode)) {
+    throw malformed("publication.serviceCode must be a non-empty string");
+  }
+  if (typeof p.environment !== "string" || !CATALOG_ENVIRONMENTS.has(p.environment)) {
+    throw malformed(
+      `publication.environment must be staging | production (got ${JSON.stringify(p.environment)})`
+    );
+  }
+  if (p.catalogVersion !== c.catalogVersion) {
+    throw malformed(
+      `publication.catalogVersion (${JSON.stringify(p.catalogVersion)}) does not match top-level catalogVersion (${JSON.stringify(c.catalogVersion)})`
+    );
+  }
+  if (typeof p.status !== "string" || !PUBLICATION_STATUSES.has(p.status)) {
+    throw malformed(
+      `publication.status must be one of approved | superseded | revoking | revoked (got ${JSON.stringify(p.status)})`
+    );
+  }
+  for (const field of PUBLICATION_HASH_FIELDS) {
+    const value = p[field];
+    if (typeof value !== "string" || !CATALOG_HASH_PATTERN.test(value)) {
+      throw malformed(`publication.${field} must be lowercase SHA-256 hex (64 chars)`);
+    }
+  }
+  if (typeof p.salesEpoch !== "number" || !Number.isInteger(p.salesEpoch) || p.salesEpoch < 1) {
+    throw malformed(
+      `publication.salesEpoch must be a positive integer (got ${JSON.stringify(p.salesEpoch)})`
+    );
+  }
+  if (isBlankString(p.approvalId)) {
+    throw malformed("publication.approvalId must be a non-empty string");
+  }
+  for (const field of PUBLICATION_REQUIRED_TIMESTAMP_FIELDS) {
+    if (isBlankString(p[field])) {
+      throw malformed(`publication.${field} must be a non-empty ISO 8601 string`);
+    }
+  }
+  for (const field of PUBLICATION_NULLABLE_TIMESTAMP_FIELDS) {
+    if (!isNullableIsoString(p[field])) {
+      throw malformed(`publication.${field} must be a non-empty ISO 8601 string or null`);
+    }
+  }
+  if (!Array.isArray(c.plans)) {
+    throw malformed(`plans must be an array (got ${typeof c.plans})`);
+  }
+  for (const [index, plan] of c.plans.entries()) {
+    validatePublishedPlan(plan, index);
+  }
+}
+function createCatalogMethods(deps) {
+  const { fetchWithAuth, createError } = deps;
+  async function getPublishedCatalog(serviceCode) {
+    if (isBlankString(serviceCode)) {
+      return {
+        error: createError("VALIDATION_ERROR", "serviceCode \u306F\u5FC5\u9808\u3067\u3059")
+      };
+    }
+    const requestedCode = serviceCode.trim();
+    const response = await fetchWithAuth(
+      `${EXT_CATALOG_ENDPOINT}/${encodeURIComponent(requestedCode)}`
+    );
+    if (response.data !== void 0) {
+      validatePublishedCatalog(response.data);
+      if (response.data.service.code !== requestedCode || response.data.publication.serviceCode !== requestedCode) {
+        throw malformed(
+          `response is for service ${JSON.stringify(response.data.service.code)} (publication: ${JSON.stringify(response.data.publication.serviceCode)}) but ${JSON.stringify(requestedCode)} was requested`
+        );
+      }
+    }
+    return response;
+  }
+  return { getPublishedCatalog };
+}
+
 // src/client/members-methods.ts
 var EXT_MEMBERS_ENDPOINT = "/api/v1/organizations/ext/members";
 function createMembersMethods(deps) {
@@ -1254,7 +1643,7 @@ function validateTokenResponse(tokenResponse) {
 }
 
 // src/client/version-check.ts
-var SDK_VERSION = "5.24.3";
+var SDK_VERSION = "5.27.0";
 var SDK_USER_AGENT = `FFID-SDK/${SDK_VERSION} (TypeScript)`;
 var SDK_VERSION_HEADER = "X-FFID-SDK-Version";
 function sdkHeaders() {
@@ -2868,39 +3257,7 @@ function isBlockedFromUserinfo(sub) {
   return BLOCKING_EFFECTIVE_STATUSES.includes(effectiveStatus);
 }
 
-// src/client/error-codes.ts
-var FFID_ERROR_CODES = {
-  NETWORK_ERROR: "NETWORK_ERROR",
-  PARSE_ERROR: "PARSE_ERROR",
-  UNKNOWN_ERROR: "UNKNOWN_ERROR",
-  TOKEN_EXCHANGE_ERROR: "TOKEN_EXCHANGE_ERROR",
-  TOKEN_REFRESH_ERROR: "TOKEN_REFRESH_ERROR",
-  NO_TOKENS: "NO_TOKENS",
-  TOKEN_VERIFICATION_ERROR: "TOKEN_VERIFICATION_ERROR",
-  TOKEN_EXPIRED: "TOKEN_EXPIRED",
-  STATE_MISMATCH_ERROR: "STATE_MISMATCH_ERROR"
-};
-
-// src/client/ffid-client.ts
-var UNAUTHORIZED_STATUS2 = 401;
-var SDK_LOG_PREFIX = "[FFID SDK]";
-var noopLogger = {
-  debug: () => {
-  },
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: () => {
-  }
-};
-var consoleLogger = {
-  debug: (...args) => console.debug(SDK_LOG_PREFIX, ...args),
-  info: (...args) => console.info(SDK_LOG_PREFIX, ...args),
-  warn: (...args) => console.warn(SDK_LOG_PREFIX, ...args),
-  error: (...args) => console.error(SDK_LOG_PREFIX, ...args)
-};
-var EXT_CHECK_ENDPOINT = "/api/v1/subscriptions/ext/check";
+// src/client/service-access-decision.ts
 var DEFAULT_ALLOW_GRACE = true;
 var DEFAULT_SERVICE_ACCESS_FAIL_POLICY = "failClosed";
 var SERVICE_ACCESS_DENIED_CODE = "SERVICE_ACCESS_DENIED";
@@ -2967,6 +3324,40 @@ function failClosedServiceAccessDecision(params, error) {
     error
   };
 }
+
+// src/client/error-codes.ts
+var FFID_ERROR_CODES = {
+  NETWORK_ERROR: "NETWORK_ERROR",
+  PARSE_ERROR: "PARSE_ERROR",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  TOKEN_EXCHANGE_ERROR: "TOKEN_EXCHANGE_ERROR",
+  TOKEN_REFRESH_ERROR: "TOKEN_REFRESH_ERROR",
+  NO_TOKENS: "NO_TOKENS",
+  TOKEN_VERIFICATION_ERROR: "TOKEN_VERIFICATION_ERROR",
+  TOKEN_EXPIRED: "TOKEN_EXPIRED",
+  STATE_MISMATCH_ERROR: "STATE_MISMATCH_ERROR"
+};
+
+// src/client/ffid-client.ts
+var UNAUTHORIZED_STATUS2 = 401;
+var SDK_LOG_PREFIX = "[FFID SDK]";
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var consoleLogger = {
+  debug: (...args) => console.debug(SDK_LOG_PREFIX, ...args),
+  info: (...args) => console.info(SDK_LOG_PREFIX, ...args),
+  warn: (...args) => console.warn(SDK_LOG_PREFIX, ...args),
+  error: (...args) => console.error(SDK_LOG_PREFIX, ...args)
+};
+var EXT_CHECK_ENDPOINT = "/api/v1/subscriptions/ext/check";
 function resolveRedirectUri(raw, logger) {
   if (raw === null) return null;
   try {
@@ -3284,6 +3675,10 @@ function createFFIDClient(config) {
     fetchWithAuth,
     createError
   });
+  const { getPublishedCatalog } = createCatalogMethods({
+    fetchWithAuth,
+    createError
+  });
   const { listMembers, addMember, updateMemberRole, removeMember } = createMembersMethods({
     fetchWithAuth,
     createError,
@@ -3410,6 +3805,7 @@ function createFFIDClient(config) {
     assignSeats,
     unassignSeat,
     listPlans,
+    getPublishedCatalog,
     getSubscription,
     subscribe,
     changePlan,
@@ -5558,4 +5954,4 @@ function FFIDInquiryForm({
   );
 }
 
-export { ACCESS_GRANTING_EFFECTIVE_STATUSES, BLOCKING_EFFECTIVE_STATUSES, DEFAULT_API_BASE_URL, DEFAULT_OAUTH_SCOPES, EFFECTIVE_SUBSCRIPTION_STATUSES, FFIDAnnouncementBadge, FFIDAnnouncementList, FFIDInquiryForm, FFIDLoginButton, FFIDOrganizationSwitcher, FFIDProvider, FFIDSDKError, FFIDSubscriptionBadge, FFIDUserMenu, FFID_ANNOUNCEMENTS_ERROR_CODES, FFID_ERROR_CODES, FFID_INQUIRY_CATEGORIES, FFID_INQUIRY_CATEGORIES_SITE_2026, cleanupStateStorage, computeEffectiveStatusFromSession, createFFIDAnnouncementsClient, createFFIDClient, createTokenStore, generateCodeChallenge, generateCodeVerifier, handleRedirectCallback, hasAccessFromUserinfo, isBlockedFromUserinfo, isFFIDInquiryCategorySite2026, normalizeRedirectUri, retrieveCodeVerifier, retrieveState, storeCodeVerifier, storeState, useFFID, useFFIDAnnouncements, useFFIDContext, useSubscription, withSubscription };
+export { ACCESS_GRANTING_EFFECTIVE_STATUSES, BLOCKING_EFFECTIVE_STATUSES, CATALOG_HASH_PATTERN, DEFAULT_API_BASE_URL, DEFAULT_OAUTH_SCOPES, EFFECTIVE_SUBSCRIPTION_STATUSES, FFIDAnnouncementBadge, FFIDAnnouncementList, FFIDCatalogHashError, FFIDInquiryForm, FFIDLoginButton, FFIDOrganizationSwitcher, FFIDProvider, FFIDSDKError, FFIDSubscriptionBadge, FFIDUserMenu, FFID_ANNOUNCEMENTS_ERROR_CODES, FFID_CATALOG_ENVIRONMENTS, FFID_CATALOG_PUBLICATION_STATUSES, FFID_ERROR_CODES, FFID_INQUIRY_CATEGORIES, FFID_INQUIRY_CATEGORIES_SITE_2026, canonicalizeCatalogValue, cleanupStateStorage, computeEffectiveStatusFromSession, computeFFIDCheckoutCopyHash, computeLegalDisclosureHash, computePaymentConfigurationHash, computePraxisCopyHash, computeScopeHash, computeTaxConfigurationHash, createFFIDAnnouncementsClient, createFFIDClient, createTokenStore, generateCodeChallenge, generateCodeVerifier, handleRedirectCallback, hasAccessFromUserinfo, hashCanonicalJson, isBlockedFromUserinfo, isFFIDInquiryCategorySite2026, normalizeRedirectUri, retrieveCodeVerifier, retrieveState, sha256Hex, storeCodeVerifier, storeState, useFFID, useFFIDAnnouncements, useFFIDContext, useSubscription, validatePublishedCatalog, withSubscription };