@wildo-ai/saas-models 1.1.5 → 1.1.6

package/dist/esm/systems-of-record/system-of-record-facet.shared.schemas.d.ts

@@ -56,7 +56,10 @@ import '@wildo-ai/zod-decorators';
 import { z } from 'zod';
 import { HttpApiTransportDialect } from '../http-api-binding/http-api-transport-dialect.shared';
 import { HttpApiKeyComponentCodec } from '../http-api-binding/http-api-binding.shared.schemas';
+import { ExternalDataIncrementalExtractionMode } from '../external-data/external-data-pipeline.shared.schemas';
 import { SystemOfRecordCredentialKind } from './system-of-record-credential-kind.shared';
+import { SystemOfRecordActionCallShape } from './system-of-record-actions.shared.schemas';
+import { SystemOfRecordErrorCode } from './system-of-record-error-codes.shared';
 /** @wildo_source:part:start saas.models.systems-of-record facet:layer:shared facet:audience:app-developer */
 /**
  * One input an instance must supply — an address slot (non-secret, authored in the infra env
@@ -251,7 +254,9 @@ export type SystemOfRecordCredentialOffer = z.infer<typeof SystemOfRecordCredent
  */
 export declare enum SystemOfRecordODataListPaging {
     /**
-     * `$top` + `$skip` — one request for any page, which is what a page-numbered contract wants.
+     * `$top` + `$skip` — one request for any page, which is what a page-numbered contract wants, unless the
+     * service serves fewer rows than `$top` and hands back a continuation: the page is then read to its end
+     * along the continuation (#1998), so the next page's `$skip` does not jump the rows the service held back.
      *
      * The default, because it is what OData v4 defines and what an uncatalogued service serves.
      */
@@ -260,8 +265,12 @@ export declare enum SystemOfRecordODataListPaging {
      * `@odata.nextLink` only: the service hands back a continuation URL and refuses to be addressed by
      * offset.
      *
-     * The consequence is structural rather than a detail — a cursor has no page NUMBER, so page N costs
-     * N requests. The engine walks forward and refuses past a bound rather than pretending otherwise.
+     * The consequence is structural rather than a detail — a cursor has no page NUMBER, so reaching a page
+     * costs one request per page before it. The engine asks for the page size with `Prefer:
+     * odata.maxpagesize` on v4 (v2 has no such preference, so the service's own size decides) — never with
+     * `$top`, which would cap the whole collection (#1991) — walks forward
+     * counting ROWS rather than links (the service may serve a page size of its own, #1998), and refuses
+     * past a bound rather than pretending otherwise.
      */
     NEXT_LINK_ONLY = "next-link-only"
 }
@@ -327,6 +336,35 @@ export declare const SystemOfRecordPartitionSupportSchema: z.ZodObject<{
     valueShape: z.ZodEnum<typeof SystemOfRecordPartitionValueShape>;
 }, z.core.$strict>;
 export type SystemOfRecordPartitionSupport = z.infer<typeof SystemOfRecordPartitionSupportSchema>;
+/**
+ * A step a vendor requires before it accepts ANY modifying request — a row write or a writing action — beyond the
+ * credential every request carries (#1726).
+ *
+ * Declared by the FACET because it is a fact about the product, and refused at startup by the engine for every step it
+ * does not perform (`WRITE_PREREQUISITE_NOT_SUPPORTED`): a write the vendor is known to refuse must not be opened, since
+ * it would only surface as a remote `403` at the first request, under a code that names nothing.
+ */
+export declare enum SystemOfRecordWritePrerequisite {
+    /**
+     * SAP Gateway's cross-site-request-forgery protection: a modifying request must carry an `X-CSRF-Token` obtained by a
+     * prior NON-modifying request sent with `X-CSRF-Token: Fetch`, together with the session cookie that request set.
+     * spec-cite: SAP Help Portal, SAP Gateway Foundation — "Cross-Site Request Forgery Protection"
+     * (https://help.sap.com/saphelp_gateway20sp12/helpdata/en/e6/cae27d5e8d4996add4067280c8714e/frameset.htm).
+     */
+    CSRF_TOKEN_HANDSHAKE = "csrf-token-handshake"
+}
+/**
+ * The OData v4 control information that carries an entity's ETag in a JSON row (#1726) — the only row version an OData
+ * vendor can declare in `rowVersionField`, and the value the OData write dialect sends as `If-Match`.
+ *
+ * The OData 4.0 spelling. A payload that is not OData-Version 4.0 omits the `odata.` infix (`@etag`); the engine asks
+ * for 4.0 on its OData requests (`OData-MaxVersion: 4.0`), so a conformant service answers this spelling. A field MAPPED
+ * onto the tag, and a `VERSION_CHECKED` comparison, read this spelling only; the write dialect alone also reads the
+ * short form when it derives `If-Match`, which only widens what it can condition on.
+ * spec-cite: OData JSON Format Version 4.01 §4.5.10 (Control Information: etag (odata.etag)) and §4.5 ("In requests and
+ * responses with an OData-Version header with a value of 4.0 control information names are prefixed with @odata.").
+ */
+export declare const ODATA_ENTITY_TAG_CONTROL_INFORMATION = "@odata.etag";
 /**
  * What a vendor is, as a system of record. Parsed rather than trusted because #1057 lets a PACKAGE
  * ship one — a record produced by one package version and read by another.
@@ -428,9 +466,264 @@ export declare const SystemOfRecordVendorFacetSchema: z.ZodObject<{
         codec: z.ZodEnum<typeof HttpApiKeyComponentCodec>;
         valueShape: z.ZodEnum<typeof SystemOfRecordPartitionValueShape>;
     }, z.core.$strict>>;
+    /**
+     * The change-tracking mechanisms this vendor's deployments support, which a pipeline may read
+     * incrementally through (#1682). A pipeline declaring `incremental.mode` outside this list is refused
+     * at startup, naming the vendor.
+     *
+     * A VENDOR property rather than a dialect constant: whether a deployment can say what changed is a
+     * fact about the product (Odoo's ORM stamps `write_date` on every model that logs access; an OData
+     * service may or may not enable change tracking, #1722), not about the wire language.
+     *
+     * ABSENT means none — a real answer: that vendor's pipelines run full passes only.
+     */
+    incrementalExtractionModes: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof ExternalDataIncrementalExtractionMode>>>;
+    /**
+     * The service-defined OData error codes with which this vendor says a tracked change position has EXPIRED (#1722), for a
+     * vendor that answers it with its own code rather than the protocol's `410 Gone` / `404 Not Found`.
+     *
+     * A delta-link pass whose link the vendor no longer honours starts over with a full pass. The protocol names the status
+     * for an expired URL, and the engine recognises it for every vendor; a vendor that answers something else instead
+     * states its code here, so the fallback does not depend on guessing which `400` means "too old". Dataverse documents
+     * `0x80044352` (`ExpiredVersionStamp`, "Please perform a full sync").
+     *
+     * ABSENT means the vendor answers the protocol's status, or has no change tracking.
+     */
+    odataExpiredChangePositionErrorCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    /**
+     * The ACTION call shapes this vendor's product supports (#1678) — how a declared action is called on it: Odoo's
+     * `execute_kw` on a model method, an OData bound action, an OData unbound action import.
+     *
+     * A VENDOR property, like `partition`: whether a product exposes callable operations beyond row reads is a fact about
+     * the product, and a generic OData service may expose none. A binding declaring an action whose shape its vendor does
+     * not list is refused at boot, naming the vendor. ABSENT means none — the vendor is read (and perhaps written) only.
+     * Each listed shape must be spoken over one of the facet's own `dialects`.
+     */
+    actionCallShapes: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof SystemOfRecordActionCallShape>>>;
+    /**
+     * The remote field this vendor's product maintains on EVERY row as its version — changed by the product itself on every
+     * write, never by a caller (#1724, #1726). Odoo: `write_date`, the ORM's "Last Updated on". An OData v4 vendor that
+     * serves entity tags: {@link ODATA_ENTITY_TAG_CONTROL_INFORMATION} (`@odata.etag`), and nothing else.
+     *
+     * A binding may declare `writeConcurrency: VERSION_CHECKED` only against a vendor that names one, and only with a
+     * version field that maps onto it (refused at boot, `WRITE_ROW_VERSION_NOT_SUPPORTED_BY_VENDOR`). The engine then
+     * compares the version a caller read with the one it reads just before the write.
+     *
+     * ## What that comparison is worth depends on the DIALECT, not on this field
+     *
+     * - **Odoo (best-effort).** Its external API has no conditional write — `write(ids, vals)` applies the values, with no
+     *   precondition — so the comparison and the write are two separate calls, and a change landing between them is
+     *   overwritten. The check NARROWS the lost-update window to the gap between two calls; it does not close it.
+     * - **OData v4 (atomic).** The OData write dialect sends the version as `If-Match` on the `PATCH` or `DELETE`, and the
+     *   service itself refuses a mismatch with `412 Precondition Failed` and applies nothing. The engine's comparison
+     *   before sending is then only a fast refusal; the guarantee is the vendor's.
+     *   spec-cite: OData Version 4.01 Part 1: Protocol §8.2.4 (Header If-Match) — "the service MUST respond with 412
+     *   Precondition Failed and MUST ensure that no observable change occurs as a result of the request".
+     *
+     * Declaring it for an OData vendor is also what lets its writes send the row's own entity tag rather than `*`: the
+     * write dialect reads `@odata.etag` from the row it reads first, so a row moved (into another partition, say) between
+     * that read and the write is refused by the vendor instead of written.
+     *
+     * A VENDOR property, like `incrementalExtractionModes`: whether a product maintains a per-row version is a fact about the
+     * product. ABSENT means none, and a binding against such a vendor states `LAST_WRITER_WINS` instead.
+     */
+    rowVersionField: z.ZodOptional<z.ZodString>;
+    /**
+     * What this vendor requires before any modifying request (#1726) — see {@link SystemOfRecordWritePrerequisite}. ABSENT
+     * means nothing beyond the credential. A binding opening writes against a vendor listing a step the engine does not
+     * perform is refused at startup.
+     */
+    writePrerequisites: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof SystemOfRecordWritePrerequisite>>>;
 }, z.core.$strict>;
 export type SystemOfRecordVendorFacet = z.infer<typeof SystemOfRecordVendorFacetSchema>;
+/**
+ * The export a package's `./systems-of-record` module presents: a record of facets keyed by vendor id. The
+ * backend's facet resolver and `wildo secrets` (which lists the credential slots an instance needs) both read
+ * a facet module through this name, so it is declared once, beside the shape it carries.
+ */
+export declare const SYSTEM_OF_RECORD_FACET_RECORD_EXPORT = "PROVIDER_CATALOGUE_SYSTEM_OF_RECORD_FACETS";
+/** The subpath a package exports its facet module under: `<package>/systems-of-record`. */
+export declare const SYSTEM_OF_RECORD_FACET_MODULE_SUBPATH = "/systems-of-record";
 /** @wildo_source:part:end saas.models.systems-of-record */
+/**
+ * The specifier of `packageName`'s facet module. ONE spelling for the backend's resolver, `wildo secrets` and the
+ * discovery that records the modules, so the three cannot disagree about where a package's facets live (#1675).
+ */
+export declare function systemOfRecordFacetModuleSpecifier(packageName: string): string;
+/** The package a facet module specifier belongs to: `@acme/erp/systems-of-record` → `@acme/erp`. */
+export declare function packageOfSystemOfRecordFacetModule(specifier: string): string;
+/** A vendor's BASE facet as one source presents it, before it is chosen. */
+export interface SystemOfRecordBaseFacetCandidate {
+    /** Who presents it: `the engine`, `package @wildo-ai/systems-of-record`. */
+    readonly source: string;
+    /** The facet as presented — parsed here, since it was produced by one package version and is read by another. */
+    readonly raw: unknown;
+}
+export type SystemOfRecordBaseFacetSelection = {
+    readonly facet: SystemOfRecordVendorFacet;
+    readonly source: string;
+} | {
+    readonly conflict: string;
+    readonly detail: Readonly<Record<string, unknown>>;
+};
+/**
+ * The ONE base facet for a vendor, or a refusal naming both sources when two present one (#1675).
+ *
+ * Refused rather than "the first in authority order wins": a base facet carries the vendor's partition, and module
+ * order is the sorted order of discovered package names, so which package's partition confined a tenant's rows would
+ * otherwise depend on how two names sort — and a newly installed package could replace the library's facet with
+ * no opt-in at all. A package that knows more about a vendor it does not own ADDS to the base through an augmentation
+ * an instance opts into; it never presents a second base.
+ *
+ * `undefined` when no source presents the vendor — the caller's own refusal names the vendor.
+ *
+ * assurance-control: WILDO.DATA.TENANT_ISOLATION WILDO.SECURITY.FAIL_CLOSED — two base facets for one vendor refuse,
+ * so a tenant-confinement declaration never comes from whichever of two packages sorts first.
+ */
+export declare function selectSystemOfRecordBaseFacet(input: {
+    readonly vendor: string;
+    readonly candidates: readonly SystemOfRecordBaseFacetCandidate[];
+}): SystemOfRecordBaseFacetSelection | undefined;
+/** @wildo_source:part:start saas.models.systems-of-record.facet-augmentation facet:kind:api facet:audience:app-developer */
+/**
+ * What a package ADDS to a vendor facet it does not own (#1675) — the facet counterpart of a provider
+ * augmentation (#1672), with its own code path.
+ *
+ * One base facet per vendor answers — the one package module that presents it; two refuse, naming both. An
+ * augmentation adds to it: a PARTITION declaration for a vendor whose base declares none (say a `company_id`
+ * FIELD every row of an ERP carries, shipped by a package that knows the vendor better), or further
+ * CREDENTIAL OFFERS. It never replaces or removes anything the base declares — two declarations of one
+ * partition, or one credential kind offered twice, refuse at startup naming both sources.
+ *
+ * Only a FIELD partition can be confined. A PATH-SEGMENT partition (a company chosen in the request path) is
+ * refused when an instance sets `partition: true`, augmented or not, because nothing narrows a read the path
+ * already scoped — so augmenting one declares something no instance can use.
+ *
+ * INERT until an instance opts in: `systemsOfRecord.<name>.facetAugmentations` names the PACKAGES whose
+ * augmentation applies to that instance. The facet is the single partition authority, so a partition
+ * arriving from a package is a tenant-confinement change and is never applied because a package happens
+ * to be installed.
+ *
+ * A package presents its augmentations beside its facets, from its `./systems-of-record` export, as a
+ * record keyed by vendor id under {@link SYSTEM_OF_RECORD_FACET_AUGMENTATION_RECORD_EXPORT}. A package
+ * may ship augmentations and no facet at all. Its module is found the way every facet module is: by the
+ * provider discovery walk `wildo config sync` runs, which reads the framework's names, the application's own
+ * scope, and any package the application lists in `providers.packages` (#1676). Listing ADMITS the package;
+ * an instance's opt-in ACTIVATES its augmentation. A package the walk did not record is refused by name.
+ *
+ * Entity descriptions are not augmentable: the facet declares none today, so there is nothing to add to.
+ */
+export declare const SystemOfRecordVendorFacetAugmentationSchema: z.ZodObject<{
+    /** The vendor this augments — must equal the key it is recorded under. */
+    vendor: z.ZodString;
+    /** A partition declaration for a vendor whose base facet declares none. */
+    partition: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<typeof SystemOfRecordPartitionKind>;
+        /** The remote field carrying the partition key (`company_id`, `subsidiary`, `CompanyCode`). */
+        remoteField: z.ZodString;
+        /**
+         * How a key is spelled on the wire. Reused from the KEY component vocabulary rather than given its
+         * own: a partition key is addressed exactly as a key component is — decoded from an operator's
+         * authored string, compiled into a remote predicate — and two vocabularies for one job would drift.
+         */
+        codec: z.ZodEnum<typeof HttpApiKeyComponentCodec>;
+        valueShape: z.ZodEnum<typeof SystemOfRecordPartitionValueShape>;
+    }, z.core.$strict>>;
+    /** Credential kinds the base facet does not offer, each with this vendor's policy for it. */
+    credentialOffers: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodLiteral<SystemOfRecordCredentialKind.ODOO_API_KEY_IN_ARGS>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodLiteral<SystemOfRecordCredentialKind.API_KEY_HEADER>>;
+        /** The header the key travels in — `Authorization`, `X-API-Key`, `apikey`, whatever the vendor reads. */
+        headerName: z.ZodString;
+        /** What precedes the key in the header value, INCLUDING its trailing space (`"Bearer "`). Omitted when the key stands alone. */
+        valuePrefix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodLiteral<SystemOfRecordCredentialKind.API_KEY_QUERY>>;
+        /** The query parameter the key is appended as. */
+        parameterName: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodLiteral<SystemOfRecordCredentialKind.BASIC>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodLiteral<SystemOfRecordCredentialKind.OAUTH2_CLIENT_CREDENTIALS_SECRET>>;
+        clientAuthentication: z.ZodEnum<typeof SystemOfRecordClientAuthenticationPlacement>;
+        tokenLifetimeFallbackSeconds: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodLiteral<SystemOfRecordCredentialKind.OAUTH2_CLIENT_CREDENTIALS_CERTIFICATE>>;
+        assertionHeaderPolicy: z.ZodEnum<typeof SystemOfRecordAssertionHeaderPolicy>;
+        assertionSigningAlgorithm: z.ZodEnum<typeof SystemOfRecordAssertionSigningAlgorithm>;
+        /** How long the ASSERTION is valid — minutes, not hours; it is consumed once at the token endpoint. */
+        assertionLifetimeSeconds: z.ZodNumber;
+        tokenLifetimeFallbackSeconds: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodLiteral<SystemOfRecordCredentialKind.OAUTH2_JWT_BEARER>>;
+        assertionSigningAlgorithm: z.ZodEnum<typeof SystemOfRecordAssertionSigningAlgorithm>;
+        assertionLifetimeSeconds: z.ZodNumber;
+        tokenLifetimeFallbackSeconds: z.ZodNumber;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>;
+export type SystemOfRecordVendorFacetAugmentation = z.infer<typeof SystemOfRecordVendorFacetAugmentationSchema>;
+/** The export a package's `./systems-of-record` module presents its facet augmentations under: a record keyed by vendor id. */
+export declare const SYSTEM_OF_RECORD_FACET_AUGMENTATION_RECORD_EXPORT = "PROVIDER_CATALOGUE_SYSTEM_OF_RECORD_FACET_AUGMENTATIONS";
+/** @wildo_source:part:end saas.models.systems-of-record.facet-augmentation */
+/**
+ * Where each thing a RESOLVED facet declares came from, once an instance's opted-in augmentations were applied
+ * (#1675). Written only by {@link applySystemOfRecordFacetAugmentations}: a facet a package ships is parsed through
+ * a strict schema with no such field, so a package cannot claim to have been augmented, nor attribute a partition
+ * to someone else.
+ */
+export interface SystemOfRecordFacetAugmentationProvenance {
+    /** The package whose augmentation declared the instance's partition. */
+    readonly partition?: string;
+    /** Credential kind → the package whose augmentation offered it. */
+    readonly credentialKinds: Readonly<Record<string, string>>;
+}
+/** Why an instance's opted-in augmentations cannot be applied. */
+export declare enum SystemOfRecordFacetAugmentationRefusalKind {
+    /** A package the instance opted in ships no augmentation for its vendor. */
+    NOT_FOUND = "not-found",
+    /** Two sources declare the same partition or credential kind. */
+    CONFLICT = "conflict",
+    /** An augmentation, or the facet it produces once merged, fails the facet schema. */
+    INVALID = "invalid"
+}
+export type SystemOfRecordFacetAugmentationResult = {
+    readonly facet: SystemOfRecordVendorFacet;
+    readonly augmentedBy: SystemOfRecordFacetAugmentationProvenance;
+} | {
+    readonly refusal: SystemOfRecordFacetAugmentationRefusalKind;
+    readonly message: string;
+    readonly detail: Readonly<Record<string, unknown>>;
+};
+/**
+ * Folds an instance's opted-in augmentations into its base facet — and refuses, naming both sources, the moment two
+ * of them declare the same thing. ONE implementation for the backend's facet resolver and `wildo secrets`, so a
+ * listing cannot ask for a credential the backend would refuse, or miss one an augmentation offers.
+ *
+ * `augmentations` is in the instance's declared opt-in order; each `raw` is what the package's module presents under
+ * {@link SYSTEM_OF_RECORD_FACET_AUGMENTATION_RECORD_EXPORT} for this vendor (`undefined` when it presents none),
+ * parsed here like a facet because it was produced by one package version and is read by another.
+ *
+ * assurance-control: WILDO.DATA.TENANT_ISOLATION WILDO.SECURITY.FAIL_CLOSED — a partition declaration (how a tenant's
+ * rows are confined) is admitted from a package only when the instance opted that package in, only for a vendor whose
+ * base facet declares none, never twice, and every admitted one is recorded with the package that contributed it.
+ */
+export declare function applySystemOfRecordFacetAugmentations(input: {
+    readonly vendor: string;
+    readonly base: {
+        readonly facet: SystemOfRecordVendorFacet;
+        readonly source: string;
+    };
+    readonly augmentations: ReadonlyArray<{
+        readonly packageName: string;
+        readonly raw: unknown;
+        /**
+         * Why the package's facet module could not be read at all — it was not discovered, or its import failed — named in
+         * the NOT_FOUND refusal, never swallowed. A full clause, since the reader supplies the remedy it knows.
+         */
+        readonly unreadable?: string;
+    }>;
+}): SystemOfRecordFacetAugmentationResult;
 /**
  * How this vendor pages an OData collection read — the ONE place an absent declaration becomes an
  * answer (#1292).
@@ -453,6 +746,23 @@ export interface SystemOfRecordInstanceSlots {
  * at every call, while the slot union is a boot-time question asked once.
  */
 export declare function findSystemOfRecordCredentialOffer(facet: SystemOfRecordVendorFacet, credentialKind: SystemOfRecordCredentialKind): SystemOfRecordCredentialOffer | undefined;
+/**
+ * Which credential kind an instance uses — decided ONCE, for the backend registry that enforces it at boot
+ * and for `wildo secrets`, which lists the secret slots that kind needs (#1637). Two readers deriving it
+ * separately is how a listing comes to ask for a secret the backend will not read.
+ *
+ * DECLARED when the instance names one the facet offers; DERIVED when the instance names none and the
+ * facet offers exactly one, because an author asked to choose between one option is being asked a question
+ * the mechanism already holds the answer to (`derive-before-you-ask.md`). Otherwise a refusal, carrying
+ * what the facet does offer so the reader can name it: a kind the vendor does not offer, or several on
+ * offer and none chosen — the day the author acquires a real decision.
+ */
+export declare function chooseSystemOfRecordCredentialKind(declaredKind: SystemOfRecordCredentialKind | undefined, facet: SystemOfRecordVendorFacet): {
+    readonly kind: SystemOfRecordCredentialKind;
+} | {
+    readonly refusal: SystemOfRecordErrorCode.CREDENTIAL_KIND_NOT_OFFERED | SystemOfRecordErrorCode.CREDENTIAL_KIND_AMBIGUOUS;
+    readonly offered: readonly SystemOfRecordCredentialKind[];
+};
 /**
  * The ONE place the vendor's slots and the credential kind's slots are joined.
  *

package/dist/esm/systems-of-record/system-of-record-facet.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-of-record-facet.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/systems-of-record/system-of-record-facet.shared.schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"system-of-record-facet.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/systems-of-record/system-of-record-facet.shared.schemas.ts"],"names":[],"mappings":"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"}