@openlup/core 0.0.0 → 0.7.0

package/dist/bundle/contracts.d.ts

@@ -0,0 +1,9 @@
+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/dist/bundle/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/bundle/ports.d.ts

@@ -0,0 +1,41 @@
+/** 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/dist/bundle/ports.js

@@ -0,0 +1 @@
+export {};

package/dist/catalog/identifiers.d.ts

@@ -0,0 +1,31 @@
+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 declare const catalogSlugFormat: RegExp;
+/** @beta */
+export declare const slugSchema: z.ZodString;
+/**
+ * A purchasable SKU. Charset and length are bounded, but the schema does not
+ * encode packaging, weight, brand, or merchant-specific prefixes.
+ */
+/** @beta */
+export declare const skuSchema: z.ZodString;
+/**
+ * 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 declare const catalogProductIdSchema: z.ZodString;
+/**
+ * A variant id. Accepts static ids and database ids without requiring a literal
+ * prefix owned by the package.
+ */
+/** @beta */
+export declare const variantIdSchema: z.ZodString;

package/dist/catalog/identifiers.js

@@ -0,0 +1,46 @@
+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/dist/catalog/index.d.ts

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

package/dist/catalog/index.js

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

package/dist/checkout/idempotency.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 declare const CHECKOUT_IDEMPOTENCY_KEY_HEADER = "idempotency-key";
+/** @beta */
+export type CheckoutIdempotencyRejection = {
+    reason: "missing";
+    message: string;
+} | {
+    reason: "malformed";
+    message: string;
+};
+/** @beta */
+export declare function validateCheckoutIdempotencyHeader(headerValue: string | undefined | null): {
+    ok: true;
+    key: string;
+} | {
+    ok: false;
+    rejection: CheckoutIdempotencyRejection;
+};

package/dist/checkout/idempotency.js

@@ -0,0 +1,37 @@
+/**
+ * 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 function validateCheckoutIdempotencyHeader(headerValue) {
+    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/dist/checkout/index.d.ts

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

package/dist/checkout/index.js

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

package/dist/company-identity/contracts.d.ts

@@ -0,0 +1,220 @@
+import { z } from "zod";
+/** @beta */
+export declare const COMPANY_IDENTITY_CONTRACT_VERSION: "company_identity.lookup.v1";
+/** 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 declare const companyIdentityPurposeSchema: z.ZodEnum<{
+    checkout_invoice: "checkout_invoice";
+    customer_billing_profile: "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 declare const companyIdentityVerificationLevelSchema: z.ZodEnum<{
+    registry_verified: "registry_verified";
+    provider_verified: "provider_verified";
+    manual_unverified: "manual_unverified";
+    invalid: "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 declare const companyIdentityLookupStatusSchema: z.ZodEnum<{
+    partial: "partial";
+    invalid: "invalid";
+    found: "found";
+    not_found: "not_found";
+    ambiguous: "ambiguous";
+    unsupported_country: "unsupported_country";
+    provider_unavailable: "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 declare const companyIdentitySourceStatusSchema: z.ZodEnum<{
+    partial: "partial";
+    invalid: "invalid";
+    found: "found";
+    not_found: "not_found";
+    ambiguous: "ambiguous";
+    provider_unavailable: "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 declare const companyIdentityIdentifierKindSchema: z.ZodString;
+/** @beta */
+export declare const companyIdentityAddressSchema: z.ZodObject<{
+    line1: z.ZodString;
+    postalCode: z.ZodString;
+    city: z.ZodString;
+    country: z.ZodString;
+}, z.core.$strict>;
+/** @beta */
+export declare const companyIdentityCompanySchema: z.ZodObject<{
+    country: z.ZodString;
+    identifierKind: z.ZodString;
+    identifierValue: z.ZodString;
+    legalName: z.ZodNullable<z.ZodString>;
+    registeredAddress: z.ZodNullable<z.ZodObject<{
+        line1: z.ZodString;
+        postalCode: z.ZodString;
+        city: z.ZodString;
+        country: z.ZodString;
+    }, z.core.$strict>>;
+    registryStatus: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/** @beta */
+export declare const companyIdentitySourceSchema: z.ZodObject<{
+    providerKind: z.ZodString;
+    status: z.ZodEnum<{
+        partial: "partial";
+        invalid: "invalid";
+        found: "found";
+        not_found: "not_found";
+        ambiguous: "ambiguous";
+        provider_unavailable: "provider_unavailable";
+    }>;
+    observedAt: z.ZodString;
+    evidenceHash: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/** Lookup coordinates with optional manual identity for registry reconciliation.
+ * Country is an open ISO-3166 alpha-2 code. Parsing uppercases country and
+ * lowercases identifier kind; national tax-id rules belong to extensions. */
+/** @beta */
+export declare const companyIdentityLookupRequestSchema: z.ZodPipe<z.ZodObject<{
+    country: z.ZodString;
+    identifierKind: z.ZodString;
+    identifierValue: z.ZodString;
+    purpose: z.ZodEnum<{
+        checkout_invoice: "checkout_invoice";
+        customer_billing_profile: "customer_billing_profile";
+    }>;
+    manualCompany: z.ZodOptional<z.ZodObject<{
+        country: z.ZodOptional<z.ZodString>;
+        identifierKind: z.ZodOptional<z.ZodString>;
+        identifierValue: z.ZodOptional<z.ZodString>;
+        legalName: z.ZodNullable<z.ZodString>;
+        registeredAddress: z.ZodNullable<z.ZodObject<{
+            line1: z.ZodString;
+            postalCode: z.ZodString;
+            city: z.ZodString;
+            country: z.ZodString;
+        }, z.core.$strict>>;
+        registryStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodTransform<NormalizableCompanyIdentityLookupRequest, {
+    country: string;
+    identifierKind: string;
+    identifierValue: string;
+    purpose: "checkout_invoice" | "customer_billing_profile";
+    manualCompany?: {
+        legalName: string | null;
+        registeredAddress: {
+            line1: string;
+            postalCode: string;
+            city: string;
+            country: string;
+        } | null;
+        country?: string | undefined;
+        identifierKind?: string | undefined;
+        identifierValue?: string | undefined;
+        registryStatus?: string | null | undefined;
+    } | undefined;
+}>>;
+/** 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 declare const companyIdentityLookupResponseSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"company_identity.lookup.v1">;
+    status: z.ZodEnum<{
+        partial: "partial";
+        invalid: "invalid";
+        found: "found";
+        not_found: "not_found";
+        ambiguous: "ambiguous";
+        unsupported_country: "unsupported_country";
+        provider_unavailable: "provider_unavailable";
+    }>;
+    verificationLevel: z.ZodEnum<{
+        registry_verified: "registry_verified";
+        provider_verified: "provider_verified";
+        manual_unverified: "manual_unverified";
+        invalid: "invalid";
+    }>;
+    company: z.ZodNullable<z.ZodObject<{
+        country: z.ZodString;
+        identifierKind: z.ZodString;
+        identifierValue: z.ZodString;
+        legalName: z.ZodNullable<z.ZodString>;
+        registeredAddress: z.ZodNullable<z.ZodObject<{
+            line1: z.ZodString;
+            postalCode: z.ZodString;
+            city: z.ZodString;
+            country: z.ZodString;
+        }, z.core.$strict>>;
+        registryStatus: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    sources: z.ZodArray<z.ZodObject<{
+        providerKind: z.ZodString;
+        status: z.ZodEnum<{
+            partial: "partial";
+            invalid: "invalid";
+            found: "found";
+            not_found: "not_found";
+            ambiguous: "ambiguous";
+            provider_unavailable: "provider_unavailable";
+        }>;
+        observedAt: z.ZodString;
+        evidenceHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$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>;
+}
+/** @beta */
+export declare function normalizeCompanyIdentityLookupRequest(request: NormalizableCompanyIdentityLookupRequest): NormalizableCompanyIdentityLookupRequest;
+/** 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 declare function isCompleteCompanyIdentity(company: CompanyIdentityCompany | null): boolean;
+export {};

package/dist/company-identity/contracts.js

@@ -0,0 +1,167 @@
+import { z } from "zod";
+/** @beta */
+export const COMPANY_IDENTITY_CONTRACT_VERSION = "company_identity.lookup.v1";
+/** 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();
+/** Lookup coordinates with optional manual identity for registry reconciliation.
+ * Country is an open ISO-3166 alpha-2 code. Parsing uppercases country and
+ * lowercases identifier kind; national tax-id rules belong to extensions. */
+/** @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));
+/** 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 function normalizeCompanyIdentityLookupRequest(request) {
+    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) {
+    return Boolean(company?.legalName &&
+        company.registeredAddress?.line1 &&
+        company.registeredAddress.postalCode &&
+        company.registeredAddress.city &&
+        company.registeredAddress.country);
+}

package/dist/company-identity/index.d.ts

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

package/dist/company-identity/index.js

@@ -0,0 +1,2 @@
+/** @beta */
+export { COMPANY_IDENTITY_CONTRACT_VERSION, companyIdentityAddressSchema, companyIdentityCompanySchema, companyIdentityIdentifierKindSchema, companyIdentityLookupRequestSchema, companyIdentityLookupResponseSchema, companyIdentityLookupStatusSchema, companyIdentityPurposeSchema, companyIdentitySourceSchema, companyIdentitySourceStatusSchema, companyIdentityVerificationLevelSchema, isCompleteCompanyIdentity, normalizeCompanyIdentityLookupRequest, } from "./contracts.js";

package/dist/company-identity/ports.d.ts

@@ -0,0 +1,13 @@
+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>;
+}

package/dist/company-identity/ports.js

@@ -0,0 +1 @@
+export {};