@openlup/core 0.0.0 → 0.6.0

package/release-gates.json

@@ -0,0 +1,232 @@
+{
+  "schemaVersion": 4,
+  "compatibilityPolicies": {
+    "internal-candidate": "Candidate package surfaces may change until the platform phase-5 activation explicitly freezes a public API.",
+    "testing-internal": "Test-support surfaces may change and are not runtime compatibility promises."
+  },
+  "packageRelease": {
+    "phase": "platform-monorepo-phase-5",
+    "publicStability": "not-claimed",
+    "artifactChannel": "npm-staged-preview",
+    "versionRule": "0.<n>.0"
+  },
+  "evidence": {
+    "packageSmokeEvidence": {
+      "state": "required",
+      "meaning": "Hermetic build, import, pack and directory publish-refusal proof for this package."
+    },
+    "conformanceEvidence": {
+      "state": "required-for-declared-ports",
+      "meaning": "A framework-free port/adapter suite is required only when this package declares that seam."
+    },
+    "dogfoodEvidence": {
+      "state": "private-current-seams",
+      "meaning": "A private product currently imports candidate package seams; this does not establish a public platform adopter seam."
+    },
+    "externalConsumerEvidence": {
+      "state": "not-evaluated",
+      "meaning": "Requires a real independent adopter or public platform artifact in phase 4 or 5; first-party packed consumers remain package smoke evidence."
+    }
+  },
+  "packageSurface": {
+    "./subscription": {
+      "role": "kernel",
+      "maturity": "candidate",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/subscriptionBundleStandalone.test.ts"],
+      "entrypoint": "dist/subscription/index.d.ts",
+      "snapshot": "api/subscription.api.md"
+    },
+    "./bundle": {
+      "role": "kernel",
+      "maturity": "candidate",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/subscriptionBundleStandalone.test.ts"],
+      "entrypoint": "dist/bundle/contracts.d.ts",
+      "snapshot": "api/bundle.api.md"
+    },
+    "./pricing": {
+      "role": "kernel",
+      "maturity": "candidate",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/pricingStandalone.test.ts"],
+      "entrypoint": "dist/pricing/index.d.ts",
+      "snapshot": "api/pricing.api.md"
+    },
+    "./checkout": {
+      "role": "kernel",
+      "maturity": "experimental",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/checkoutStandalone.test.ts"],
+      "entrypoint": "dist/checkout/index.d.ts",
+      "snapshot": "api/checkout.api.md"
+    },
+    "./company-identity": {
+      "role": "kernel",
+      "maturity": "experimental",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/companyIdentityStandalone.test.ts"],
+      "entrypoint": "dist/company-identity/index.d.ts",
+      "snapshot": "api/company-identity.api.md"
+    },
+    "./fulfillment": {
+      "role": "kernel",
+      "maturity": "experimental",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/fulfillmentStandalone.test.ts"],
+      "entrypoint": "dist/fulfillment/index.d.ts",
+      "snapshot": "api/fulfillment.api.md"
+    },
+    "./inventory": {
+      "role": "kernel",
+      "maturity": "candidate",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/inventoryStandalone.test.ts"],
+      "entrypoint": "dist/inventory/index.d.ts",
+      "snapshot": "api/inventory.api.md"
+    },
+    "./shipping": {
+      "role": "kernel",
+      "maturity": "candidate",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/shippingStandalone.test.ts"],
+      "entrypoint": "dist/shipping/index.d.ts",
+      "snapshot": "api/shipping.api.md"
+    },
+    "./catalog": {
+      "role": "kernel",
+      "maturity": "candidate",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/catalogStandalone.test.ts"],
+      "entrypoint": "dist/catalog/index.d.ts",
+      "snapshot": "api/catalog.api.md"
+    },
+    "./promo": {
+      "role": "kernel",
+      "maturity": "candidate",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/promoStandalone.test.ts"],
+      "entrypoint": "dist/promo/index.d.ts",
+      "snapshot": "api/promo.api.md"
+    },
+    "./risk": {
+      "role": "kernel",
+      "maturity": "candidate",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/riskStandalone.test.ts"],
+      "entrypoint": "dist/risk/index.d.ts",
+      "snapshot": "api/risk.api.md"
+    },
+    "./marketing/research": {
+      "role": "kernel",
+      "maturity": "experimental",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/marketingResearchStandalone.test.ts"],
+      "entrypoint": "dist/marketing/research/index.d.ts",
+      "snapshot": "api/marketing-research.api.md"
+    },
+    "./partners": {
+      "role": "kernel",
+      "maturity": "experimental",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/partnersStandalone.test.ts"],
+      "entrypoint": "dist/partners/index.d.ts",
+      "snapshot": "api/partners.api.md"
+    },
+    "./payment": {
+      "role": "kernel",
+      "maturity": "experimental",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/paymentStandalone.test.ts"],
+      "entrypoint": "dist/payment/index.d.ts",
+      "snapshot": "api/payment.api.md"
+    },
+    "./platform-runtime": {
+      "role": "kernel",
+      "maturity": "experimental",
+      "compatibilityPolicy": "internal-candidate",
+      "packageSmokeEvidence": ["smoke/platformRuntimeStandalone.test.ts"],
+      "entrypoint": "dist/platform-runtime/index.d.ts",
+      "snapshot": "api/platform-runtime.api.md"
+    },
+    "./testing": {
+      "role": "testing",
+      "maturity": "testing",
+      "compatibilityPolicy": "testing-internal",
+      "packageSmokeEvidence": ["smoke/testingStandalone.test.ts"],
+      "entrypoint": "dist/testing.d.ts",
+      "snapshot": "api/testing.api.md"
+    }
+  },
+  "requiredRepositoryArtifacts": [
+    ".github/CODEOWNERS",
+    ".github/dependabot.yml",
+    ".github/workflows/ci.yml",
+    "CHANGELOG.md",
+    "CODE_OF_CONDUCT.md",
+    "CONTRIBUTING.md",
+    "LICENSE",
+    "MAINTAINERS.md",
+    "README.md",
+    "SECURITY.md",
+    "package-lock.json",
+    "package.json",
+    "release-gates.json",
+    "repository-policy.json",
+    "scripts/api-contract.ts",
+    "scripts/core-package-consumer-audit.ts",
+    "scripts/core-package-consumer-fixed-box-fixture.ts",
+    "scripts/core-package-consumer-fixed-catalog-subscription-fixture.ts",
+    "scripts/core-package-consumer-smoke.ts",
+    "scripts/documentation-contract.ts",
+    "scripts/neutrality-shell-fold.ts",
+    "scripts/neutrality-source-scanner.ts",
+    "scripts/public-api-config.ts",
+    "scripts/refuse-publish.ts",
+    "scripts/release-bundle.ts",
+    "scripts/release-check.ts",
+    "scripts/release-npm-checks.ts",
+    "scripts/repository-policy-check.ts",
+    "test/assertNoZeroCoverage.ts",
+    "test/documentationContract.test.ts",
+    "test/publicApiConfig.test.ts",
+    "test/releaseBundle.test.ts",
+    "test/repositoryPolicy.test.ts"
+  ],
+  "productionLicenses": {
+    "allow": [
+      "Apache-2.0",
+      "MIT"
+    ]
+  },
+  "audit": {
+    "maximumVulnerabilities": {
+      "critical": 0,
+      "high": 0,
+      "moderate": 0,
+      "low": 0,
+      "info": 0
+    }
+  },
+  "pack": {
+    "$raiseReason": "2026-09-11, owner-approved: checkout refusal recovery adds two neutral contract and policy modules with their normal source, JavaScript and declaration outputs. The reviewed artifact measured 122504 packed bytes, 533693 unpacked bytes and 192 files before this note. Packed allowance increases by 2048 bytes and unpacked by 6144 bytes; maxFiles stays 192. Exports, dependencies, runtime behavior and all other release gates remain unchanged by this exception.",
+    "maxPackedBytes": 122880,
+    "maxUnpackedBytes": 534528,
+    "maxFiles": 192,
+    "requiredFiles": [
+      "CHANGELOG.md",
+      "CODE_OF_CONDUCT.md",
+      "CONTRIBUTING.md",
+      "LICENSE",
+      "MAINTAINERS.md",
+      "README.md",
+      "SECURITY.md",
+      "package.json",
+      "release-gates.json"
+    ]
+  },
+  "publish": {
+    "prepublishOnly": "node --experimental-strip-types ./scripts/refuse-publish.ts",
+    "refusalMarker": "CORE_DIRECTORY_PUBLISH_REFUSED"
+  }
+}

package/src/bundle/contracts.ts

@@ -0,0 +1,15 @@
+import type { BundleLineRef, CompositionConstraint } from "./ports.js";
+
+/** @beta */
+export type {
+  BundleLineRef,
+  CompositionConstraint,
+  CompositionRulesPort,
+} from "./ports.js";
+
+/** @beta */
+export interface Bundle {
+  coreLines: BundleLineRef[];
+  addonLines: BundleLineRef[];
+  constraint: CompositionConstraint;
+}

package/src/bundle/ports.ts

@@ -0,0 +1,32 @@
+/** Opaque, adopter-defined sizing anchor with a minimal discriminator. */
+/** @beta */
+export interface CompositionConstraint {
+  /** Adapter-owned constraint family, for example "fixed.catalog". */
+  kind: string;
+  /** Adapter-owned schema version for data. */
+  version: number;
+  /** Adapter-owned payload; core passes it through without inspecting it. */
+  data: Record<string, unknown>;
+}
+
+/** @beta */
+export interface BundleLineRef {
+  variantId: string;
+  qty: number;
+  isAddon: boolean;
+}
+
+/** @beta */
+export interface CompositionRulesPort {
+  validateComposition(input: {
+    coreLines: BundleLineRef[];
+    addonLines: BundleLineRef[];
+    constraint: CompositionConstraint;
+  }): Promise<{ ok: true } | { ok: false; code: string; details?: Record<string, unknown> }>;
+
+  resizeComposition(input: {
+    coreLines: BundleLineRef[];
+    constraint: CompositionConstraint;
+    lever: { kind: string; value: unknown };
+  }): Promise<{ coreLines: BundleLineRef[]; constraint: CompositionConstraint } | null>;
+}

package/src/catalog/identifiers.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+/**
+ * Open-but-validated catalog identifier primitives.
+ *
+ * These schemas validate shape only; membership belongs to the host
+ * application's catalog read port. A runtime-editable catalog must accept new
+ * slugs, SKUs, product ids, and variant ids without requiring a package release.
+ * Keep these primitives format-bound, not enum-bound.
+ */
+/** @beta */
+export const catalogSlugFormat = /^[a-z0-9][a-z0-9_-]*$/;
+/** @beta */
+export const slugSchema = z.string().min(1).max(64).regex(catalogSlugFormat);
+
+/**
+ * A purchasable SKU. Charset and length are bounded, but the schema does not
+ * encode packaging, weight, brand, or merchant-specific prefixes.
+ */
+/** @beta */
+export const skuSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(64)
+  .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+
+/**
+ * A catalog product id. Accepts static ids and database ids as long as their
+ * shape is bounded; existence is checked by the host catalog data source.
+ */
+/** @beta */
+export const catalogProductIdSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(64)
+  .regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/);
+
+/**
+ * A variant id. Accepts static ids and database ids without requiring a literal
+ * prefix owned by the package.
+ */
+/** @beta */
+export const variantIdSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(64)
+  .regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/);

package/src/catalog/index.ts

@@ -0,0 +1,2 @@
+/** @beta */
+export * from "./identifiers.js";

package/src/checkout/idempotency.ts

@@ -0,0 +1,49 @@
+/**
+ * Reference checkout idempotency-key contract.
+ *
+ * This module validates the shape of a header-bound idempotency key only. The
+ * current product checkout validates body `intent.idempotencyKey`, not this
+ * header contract; downstream checkout runtimes must explicitly wire this
+ * helper before treating the header as authoritative.
+ *
+ * Callers own any persistence workflow for inserting, replaying, or completing
+ * a checkout idempotency record.
+ */
+
+/** @beta */
+export const CHECKOUT_IDEMPOTENCY_KEY_HEADER = "idempotency-key";
+
+const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+/** @beta */
+export type CheckoutIdempotencyRejection =
+  | { reason: "missing"; message: string }
+  | { reason: "malformed"; message: string };
+
+/** @beta */
+export function validateCheckoutIdempotencyHeader(
+  headerValue: string | undefined | null,
+): { ok: true; key: string } | { ok: false; rejection: CheckoutIdempotencyRejection } {
+  if (headerValue === undefined || headerValue === null || headerValue.trim().length === 0) {
+    return {
+      ok: false,
+      rejection: {
+        reason: "missing",
+        message: `Missing required ${CHECKOUT_IDEMPOTENCY_KEY_HEADER} header.`,
+      },
+    };
+  }
+
+  const trimmed = headerValue.trim();
+  if (!UUID_V4_PATTERN.test(trimmed)) {
+    return {
+      ok: false,
+      rejection: {
+        reason: "malformed",
+        message: `${CHECKOUT_IDEMPOTENCY_KEY_HEADER} must be a UUID v4.`,
+      },
+    };
+  }
+
+  return { ok: true, key: trimmed };
+}

package/src/checkout/index.ts

@@ -0,0 +1,2 @@
+/** @beta */
+export * from "./idempotency.js";

package/src/company-identity/contracts.ts

@@ -0,0 +1,209 @@
+import { z } from "zod";
+
+/** @beta */
+export const COMPANY_IDENTITY_CONTRACT_VERSION = "company_identity.lookup.v1" as const;
+
+/** Why the lookup is being performed — lets an adapter apply purpose-specific
+ * policy (e.g. stricter verification for a checkout invoice than for a saved
+ * billing profile). */
+/** @beta */
+export const companyIdentityPurposeSchema = z.enum([
+  "checkout_invoice",
+  "customer_billing_profile",
+]);
+
+/**
+ * How much the returned company data can be trusted:
+ * - `registry_verified` — confirmed against an authoritative registry;
+ * - `provider_verified` — confirmed via a commercial data provider (weaker);
+ * - `manual_unverified` — supplied by the user, not checked;
+ * - `invalid` — the identifier failed format/existence checks.
+ */
+/** @beta */
+export const companyIdentityVerificationLevelSchema = z.enum([
+  "registry_verified",
+  "provider_verified",
+  "manual_unverified",
+  "invalid",
+]);
+
+/**
+ * Outcome of a lookup. Distinguishes "no data" reasons so callers branch on
+ * data, not exceptions:
+ * - `found` — a single company resolved;
+ * - `not_found` — identifier valid but no record;
+ * - `partial` — some fields resolved, others missing;
+ * - `invalid` — identifier failed format/checksum;
+ * - `ambiguous` — more than one candidate;
+ * - `unsupported_country` — no adapter for this country;
+ * - `provider_unavailable` — transient upstream failure (retryable).
+ */
+/** @beta */
+export const companyIdentityLookupStatusSchema = z.enum([
+  "found",
+  "not_found",
+  "partial",
+  "invalid",
+  "ambiguous",
+  "unsupported_country",
+  "provider_unavailable",
+]);
+
+/** Per-source outcome inside a lookup (a lookup may consult several sources).
+ * Same vocabulary as the overall status minus the request-level
+ * `unsupported_country`, which is decided before any source is queried. */
+/** @beta */
+export const companyIdentitySourceStatusSchema = z.enum([
+  "found",
+  "not_found",
+  "partial",
+  "invalid",
+  "ambiguous",
+  "provider_unavailable",
+]);
+
+/** Open, format-validated identifier kind (e.g. a national tax-id scheme key).
+ * Deliberately NOT a closed enum: the neutral core does not enumerate
+ * country-specific schemes — the host adapter decides which kinds it accepts. */
+/** @beta */
+export const companyIdentityIdentifierKindSchema = z
+  .string()
+  .trim()
+  .toLowerCase()
+  .min(1)
+  .max(80)
+  .regex(/^[a-z0-9_:-]+$/);
+
+/** @beta */
+export const companyIdentityAddressSchema = z
+  .object({
+    line1: z.string().trim().min(1).max(240),
+    postalCode: z.string().trim().min(1).max(16),
+    city: z.string().trim().min(1).max(120),
+    country: z.string().trim().toUpperCase().length(2),
+  })
+  .strict();
+
+/** @beta */
+export const companyIdentityCompanySchema = z
+  .object({
+    country: z.string().trim().toUpperCase().length(2),
+    identifierKind: companyIdentityIdentifierKindSchema,
+    identifierValue: z.string().trim().min(1).max(80),
+    legalName: z.string().trim().min(1).max(240).nullable(),
+    registeredAddress: companyIdentityAddressSchema.nullable(),
+    registryStatus: z.string().trim().min(1).max(80).nullable(),
+  })
+  .strict();
+
+/** @beta */
+export const companyIdentitySourceSchema = z
+  .object({
+    providerKind: z.string().trim().min(1).max(120),
+    status: companyIdentitySourceStatusSchema,
+    observedAt: z.string().datetime({ offset: true }),
+    evidenceHash: z.string().trim().min(8).max(160).nullable(),
+  })
+  .strict();
+
+/** A lookup request. `country` is an open ISO-3166 alpha-2 code (not restricted
+ * to any single country); `identifierKind`/`identifierValue` name and carry the
+ * tax/registry id; `manualCompany` optionally seeds user-entered data an adapter
+ * may reconcile against a registry. Parsing normalizes country to upper-case and
+ * identifier kind to lower-case. */
+/** @beta */
+export const companyIdentityLookupRequestSchema = z
+  .object({
+    country: z.string().trim().toUpperCase().length(2),
+    identifierKind: companyIdentityIdentifierKindSchema,
+    identifierValue: z.string().trim().min(1).max(120),
+    purpose: companyIdentityPurposeSchema,
+    manualCompany: companyIdentityCompanySchema.partial({
+      identifierKind: true,
+      identifierValue: true,
+      country: true,
+      registryStatus: true,
+    }).optional(),
+  })
+  .strict()
+  .transform((request) => normalizeCompanyIdentityLookupRequest(request as NormalizableCompanyIdentityLookupRequest));
+
+/** A lookup result. `status` + `verificationLevel` say what happened and how
+ * trustworthy it is; `company` is null unless resolved; `sources` records each
+ * consulted provider's per-source outcome; `warnings` carries non-fatal notes. */
+/** @beta */
+export const companyIdentityLookupResponseSchema = z
+  .object({
+    contractVersion: z.literal(COMPANY_IDENTITY_CONTRACT_VERSION),
+    status: companyIdentityLookupStatusSchema,
+    verificationLevel: companyIdentityVerificationLevelSchema,
+    company: companyIdentityCompanySchema.nullable(),
+    sources: z.array(companyIdentitySourceSchema),
+    warnings: z.array(z.string().trim().min(1).max(120)).default([]),
+  })
+  .strict();
+
+/** @beta */
+export type CompanyIdentityLookupRequest = z.infer<typeof companyIdentityLookupRequestSchema>;
+/** @beta */
+export type CompanyIdentityLookupResponse = z.infer<typeof companyIdentityLookupResponseSchema>;
+/** @beta */
+export type CompanyIdentityCompany = z.infer<typeof companyIdentityCompanySchema>;
+/** @beta */
+export type CompanyIdentityPurpose = z.infer<typeof companyIdentityPurposeSchema>;
+/** @beta */
+export type CompanyIdentitySource = z.infer<typeof companyIdentitySourceSchema>;
+/** @beta */
+export type CompanyIdentitySourceStatus = z.infer<typeof companyIdentitySourceStatusSchema>;
+/** @beta */
+export type CompanyIdentityVerificationLevel = z.infer<typeof companyIdentityVerificationLevelSchema>;
+
+interface NormalizableCompanyIdentityLookupRequest {
+  country: string;
+  identifierKind: string;
+  identifierValue: string;
+  purpose: CompanyIdentityPurpose;
+  manualCompany?: Partial<CompanyIdentityCompany>;
+}
+
+function normalizeCompanyIdentityLookupRequest(
+  request: NormalizableCompanyIdentityLookupRequest,
+): NormalizableCompanyIdentityLookupRequest {
+  const country = String(request.country).trim().toUpperCase();
+  const identifierKind = String(request.identifierKind).trim().toLowerCase();
+  const identifierValue = request.identifierValue.trim();
+
+  const normalized = {
+    country,
+    identifierKind,
+    identifierValue,
+    purpose: request.purpose,
+  };
+  if (request.manualCompany) {
+    return {
+      ...normalized,
+      manualCompany: {
+        ...request.manualCompany,
+        country,
+        identifierKind,
+        identifierValue,
+        registryStatus: request.manualCompany.registryStatus ?? "manual",
+      },
+    };
+  }
+  return normalized;
+}
+
+/** True when the company has the minimum fields needed to render/persist a full
+ * billing identity: legal name plus a complete registered address. Used to gate
+ * whether a `partial` lookup is usable for its purpose. */
+/** @beta */
+export function isCompleteCompanyIdentity(company: CompanyIdentityCompany | null): boolean {
+  return Boolean(
+    company?.legalName &&
+      company.registeredAddress?.line1 &&
+      company.registeredAddress.postalCode &&
+      company.registeredAddress.city &&
+      company.registeredAddress.country,
+  );
+}

package/src/company-identity/index.ts

@@ -0,0 +1,27 @@
+/** @beta */
+export {
+  COMPANY_IDENTITY_CONTRACT_VERSION,
+  companyIdentityAddressSchema,
+  companyIdentityCompanySchema,
+  companyIdentityIdentifierKindSchema,
+  companyIdentityLookupRequestSchema,
+  companyIdentityLookupResponseSchema,
+  companyIdentityLookupStatusSchema,
+  companyIdentityPurposeSchema,
+  companyIdentitySourceSchema,
+  companyIdentitySourceStatusSchema,
+  companyIdentityVerificationLevelSchema,
+  isCompleteCompanyIdentity,
+} from "./contracts.js";
+/** @beta */
+export type {
+  CompanyIdentityCompany,
+  CompanyIdentityLookupRequest,
+  CompanyIdentityLookupResponse,
+  CompanyIdentityPurpose,
+  CompanyIdentitySource,
+  CompanyIdentitySourceStatus,
+  CompanyIdentityVerificationLevel,
+} from "./contracts.js";
+/** @beta */
+export type { CompanyIdentityLookupPort } from "./ports.js";

package/src/company-identity/ports.ts

@@ -0,0 +1,19 @@
+import type {
+  CompanyIdentityLookupRequest,
+  CompanyIdentityLookupResponse,
+} from "./contracts.js";
+
+/**
+ * Provider seam for resolving a company's registry identity from a tax/registry
+ * identifier. The host application supplies the adapter (a national registry
+ * client, a commercial data provider, or a manual store); the core owns only
+ * this request/response contract. Adapters must not throw on a "not found" or
+ * "unsupported country" outcome — those are represented in the response
+ * `status`, so callers can branch on data rather than exceptions.
+ */
+/** @beta */
+export interface CompanyIdentityLookupPort {
+  lookupCompanyIdentity(
+    request: CompanyIdentityLookupRequest,
+  ): Promise<CompanyIdentityLookupResponse>;
+}