@wildo-ai/saas-models 1.1.5 → 1.1.7

package/dist/esm/external-providers/provider-capability.shared.schemas.js

@@ -28,6 +28,18 @@
 export const BUILTIN_PROVIDER_CAPABILITY = {
     EMAIL_TRANSACTIONAL: 'EMAIL_TRANSACTIONAL',
     EMAIL_MARKETING: 'EMAIL_MARKETING',
+    /**
+     * Provider RECEIVES email for the application: it hosts the MX for a receiving domain, notifies the
+     * application of each message through a signed webhook, and serves the message (bodies,
+     * authentication results, attachments) on request. Maps to `EngineCapability.EMAIL_INBOUND`.
+     *
+     * A token of its own rather than a reading of `EMAIL_TRANSACTIONAL`, because sending and receiving
+     * are separate procurement decisions: one vendor may send and another receive, and threading only
+     * needs standard headers, so the two never have to agree (#1630). Delivery of the notification is
+     * NOT this capability — like billing's, it rides the `WEBHOOK_ORIGINATOR` protocol through an
+     * endpoint whose `capability` names this token.
+     */
+    EMAIL_INBOUND: 'EMAIL_INBOUND',
     SMS: 'SMS',
     /**
      * Single billing-engagement capability covering everything from
@@ -75,9 +87,31 @@ export const BUILTIN_PROVIDER_CAPABILITY = {
     IMAGE_GENERATION: 'IMAGE_GENERATION',
     FRONTEND_ERROR_MONITORING: 'FRONTEND_ERROR_MONITORING',
     FRONTEND_PRODUCT_ANALYTICS: 'FRONTEND_PRODUCT_ANALYTICS',
+    /**
+     * A hosted search a browser module brings to a surface. The engine ships no provider for it since #1737
+     * (Algolia DocSearch loaded nothing; the documentation site searches its own generated index). Kept
+     * because an application or package module may still declare one, and the consent classification and the
+     * privacy disclosure map both answer for it.
+     */
     FRONTEND_SEARCH: 'FRONTEND_SEARCH',
     FRONTEND_FILE_PICKER: 'FRONTEND_FILE_PICKER',
     FRONTEND_CAPTCHA: 'FRONTEND_CAPTCHA',
+    /**
+     * A browser component that turns what a person types into a STRUCTURED postal address — the
+     * `z_address()` value — optionally with the vendor's own identifier for the place it matched (#1702,
+     * consumed by the address field of #561).
+     *
+     * The component's contract is `ProviderAddressLookupProps` (`@wildo-ai/saas-models`): it hands back a
+     * `ProviderAddressLookupSelection`. Whether the vendor's place id comes back at all is a static
+     * declaration on the component (`placeIdRetention`), refused at the framework boundary when a selection
+     * contradicts it — the #383 pattern — and the id is never stored (#561 D3). The component reaches its
+     * vendor through the application backend's provider-operation door, never from the page (#561 D2).
+     *
+     * Fills no engine slot: nothing in the engine requires an address lookup to exist, and a field that
+     * finds none is typed by hand. Needs no consent at the capability floor (the person asked for the
+     * lookup); a vendor whose terms make it more than that adds purposes on its own module.
+     */
+    FRONTEND_ADDRESS_LOOKUP: 'FRONTEND_ADDRESS_LOOKUP',
     /**
      * Backend LLM-call observability — a provider that ingests per-`invokeAgent`
      * generation traces (model / tokens / cost / latency), e.g. PostHog

package/dist/esm/external-providers/provider-capability.shared.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"provider-capability.shared.schemas.js","sourceRoot":"","sources":["../../../../src/external-providers/provider-capability.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG;IACzC,mBAAmB,EAAE,qBAAqB;IAC1C,eAAe,EAAE,iBAAiB;IAClC,GAAG,EAAE,KAAK;IACV;;;;;;;;OAQG;IACH,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,YAAY;IACxB,sEAAsE;IACtE,QAAQ,EAAE,UAAU;IACpB,QAAQ,EAAE,UAAU;IACpB,cAAc,EAAE,gBAAgB;IAChC;;;;;;;;;;;;;;OAcG;IACH,wBAAwB,EAAE,0BAA0B;IACpD;;;;;;;;;;OAUG;IACH,YAAY,EAAE,cAAc;IAC5B,gBAAgB,EAAE,kBAAkB;IACpC,yBAAyB,EAAE,2BAA2B;IACtD,0BAA0B,EAAE,4BAA4B;IACxD,eAAe,EAAE,iBAAiB;IAClC,oBAAoB,EAAE,sBAAsB;IAC5C,gBAAgB,EAAE,kBAAkB;IACpC;;;;;OAKG;IACH,iBAAiB,EAAE,mBAAmB;IACtC;;;;;OAKG;IACH,uBAAuB,EAAE,yBAAyB;IAClD;;;;;;;OAOG;IACH,sBAAsB,EAAE,wBAAwB;CACxC,CAAC","sourcesContent":["/**\n * `ProviderCapability` — the closed vocabulary of standardized behaviors\n * a provider claims to implement.\n *\n * Distinct from `EngineCapability` (closed, engine-defined slots that\n * may require fulfillment): a provider CLAIMS a `ProviderCapability`, and\n * `PROVIDER_CAPABILITY_TO_ENGINE_CAPABILITY` projects the claims that fill\n * an engine slot.\n *\n * This header described the vocabulary as \"open, app-extensible\", with a\n * kebab-case convention for app-augmented values, until 2026-09-12. The\n * augmentation point was removed by #502 (see below), so no second namespace\n * exists; the `.cursor/plans/` citation it carried named a directory that no\n * longer exists.\n */\n\n/** @wildo_source:part:start saas.models.provider-capabilities facet:kind:api facet:audience:app-developer\n *\n * Built-in provider capabilities shipped by the framework.\n *\n * Authoring rule: keep this list narrow and stable. Adding a new\n * built-in capability is a framework-level decision (it implies the\n * engine knows how to consume the capability via a transformer or a\n * platform binding). There is no app-side extension point: an application\n * needing a capability this vocabulary does not name is a decision to widen\n * the vocabulary, taken with the resolution path that would make it mean\n * something (#502).\n */\nexport const BUILTIN_PROVIDER_CAPABILITY = {\n  EMAIL_TRANSACTIONAL: 'EMAIL_TRANSACTIONAL',\n  EMAIL_MARKETING: 'EMAIL_MARKETING',\n  SMS: 'SMS',\n  /**\n   * Single billing-engagement capability covering everything from\n   * Checkout-style hosted flows to first-party PaymentIntent flows.\n   * Webhook delivery is NOT a separate capability — it is modelled at\n   * the protocol layer (e.g. Stripe declares both a `BILLING_PROVIDER`\n   * and a `WEBHOOK_ORIGINATOR` protocol but a single `BILLING`\n   * capability). This 1:1 matches the billing slot from the older\n   * external connector transformer vocabulary.\n   */\n  BILLING: 'BILLING',\n  SSO_OAUTH2: 'SSO_OAUTH2',\n  /** Reserved for future SAML-based SSO providers (none ship today). */\n  SSO_SAML: 'SSO_SAML',\n  LLM_CHAT: 'LLM_CHAT',\n  LLM_EMBEDDINGS: 'LLM_EMBEDDINGS',\n  /**\n   * Provider turns DOCUMENT BYTES into text — OCR over scans and photographs of pages, not merely\n   * a read of a PDF's existing text layer. Maps to `EngineCapability.AI_DOCUMENT_EXTRACTION`.\n   *\n   * A NEW token was genuinely required rather than convenient: `IMAGE_GENERATION` is an OUTPUT\n   * capability (text → image), and PDF *generation* — the `pdfTemplates` surface — is this\n   * capability's exact opposite. Nothing in the existing vocabulary claimed the document-INPUT\n   * slot. (This paragraph used to name `EngineCapability.DOCUMENT_GENERATION`; that member was\n   * withdrawn because no provider capability could fill it.)\n   *\n   * Distinct from `LLM_CHAT` even where a vendor serves both from one API key: the work is\n   * different (a page-layout model, billed per page, with no sampling parameters), and fusing\n   * them would make the OCR provider unselectable independently of the chat provider — the exact\n   * defect that splitting `AI_EMBEDDINGS` out of `AI_LLM` existed to fix.\n   */\n  DOCUMENT_TEXT_EXTRACTION: 'DOCUMENT_TEXT_EXTRACTION',\n  /**\n   * Provider ships an autonomous CODING AGENT: a process that reads and writes\n   * a workspace, runs commands, and requests authorisation, reachable over the\n   * Agent Client Protocol.\n   *\n   * Distinct from `LLM_CHAT` because the WORK is\n   * different, not merely its transport. A chat model returns text for a caller\n   * to act on; a coding agent acts, and the resulting obligations — permission\n   * decisions, mutation scope, change attribution, verification — have no\n   * counterpart in a completion call.\n   */\n  CODING_AGENT: 'CODING_AGENT',\n  IMAGE_GENERATION: 'IMAGE_GENERATION',\n  FRONTEND_ERROR_MONITORING: 'FRONTEND_ERROR_MONITORING',\n  FRONTEND_PRODUCT_ANALYTICS: 'FRONTEND_PRODUCT_ANALYTICS',\n  FRONTEND_SEARCH: 'FRONTEND_SEARCH',\n  FRONTEND_FILE_PICKER: 'FRONTEND_FILE_PICKER',\n  FRONTEND_CAPTCHA: 'FRONTEND_CAPTCHA',\n  /**\n   * Backend LLM-call observability — a provider that ingests per-`invokeAgent`\n   * generation traces (model / tokens / cost / latency), e.g. PostHog\n   * `$ai_generation`. Maps to `EngineCapability.LLM_OBSERVABILITY`. The engine\n   * consumes it via the `AgentCallTraceSink` (not a request/response transformer).\n   */\n  LLM_OBSERVABILITY: 'LLM_OBSERVABILITY',\n  /**\n   * Operational-telemetry sink — a provider that ingests OpenTelemetry traces,\n   * metrics, and logs over OTLP (e.g. BetterStack). Maps to\n   * `EngineCapability.OBSERVABILITY_TELEMETRY`. Consumed by the OTel SDK preload\n   * (env-var-driven), NOT a request/response transformer or a DI sink.\n   */\n  OBSERVABILITY_TELEMETRY: 'OBSERVABILITY_TELEMETRY',\n  /**\n   * Audit-log sink — a provider that stores or forwards compliance audit\n   * events (who-did-what-when), e.g. immudb (tamper-evident) or a SIEM\n   * webhook. Maps to `EngineCapability.COMPLIANCE_AUDIT_TRAIL`, a FAN_OUT\n   * capability: every declared audit provider receives every event (see\n   * `getEngineCapabilityResolutionMode`). The engine consumes it via the\n   * `AuditLogSink` DI fan-out, layered on the always-on database audit store.\n   */\n  COMPLIANCE_AUDIT_TRAIL: 'COMPLIANCE_AUDIT_TRAIL',\n} as const;\n/** @wildo_source:part:end saas.models.provider-capabilities */\n\nexport type BuiltinProviderCapability =\n  (typeof BUILTIN_PROVIDER_CAPABILITY)[keyof typeof BUILTIN_PROVIDER_CAPABILITY];\n\n/*\n * The app-side augmentation point was REMOVED here (#502, decided 2026-09-08).\n *\n * `AppCustomProviderCapabilities` was an empty interface, extended by no application in the\n * repository, whose own docstring described wiring it into `getProvidersByProviderCapability()` as a\n * later phase nobody scheduled. It offered a choice that did not exist: `keyof` an empty interface is\n * `never`, so the union below already resolved to `BuiltinProviderCapability` and removing it changes\n * the resolved type for none of its consumers.\n *\n * If an application genuinely needs a capability the built-in vocabulary does not name, that is a\n * decision about widening a CLOSED semantic vocabulary — with a resolution path built at the same\n * time — not an empty interface left open in advance. An extension point with no resolver is not\n * extensibility; it is a promise nothing can keep.\n */\n\n/**\n * Every provider capability — exactly the closed built-in set. There is no\n * app-side augmentation (removed by #502, see above), so this is a name for\n * `BuiltinProviderCapability` that consumers (the provider registries, the\n * provider component registry, lock-file digests) accept.\n */\nexport type ProviderCapability = BuiltinProviderCapability;\n"]}
+{"version":3,"file":"provider-capability.shared.schemas.js","sourceRoot":"","sources":["../../../src/external-providers/provider-capability.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG;IACzC,mBAAmB,EAAE,qBAAqB;IAC1C,eAAe,EAAE,iBAAiB;IAClC;;;;;;;;;;OAUG;IACH,aAAa,EAAE,eAAe;IAC9B,GAAG,EAAE,KAAK;IACV;;;;;;;;OAQG;IACH,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,YAAY;IACxB,sEAAsE;IACtE,QAAQ,EAAE,UAAU;IACpB,QAAQ,EAAE,UAAU;IACpB,cAAc,EAAE,gBAAgB;IAChC;;;;;;;;;;;;;;OAcG;IACH,wBAAwB,EAAE,0BAA0B;IACpD;;;;;;;;;;OAUG;IACH,YAAY,EAAE,cAAc;IAC5B,gBAAgB,EAAE,kBAAkB;IACpC,yBAAyB,EAAE,2BAA2B;IACtD,0BAA0B,EAAE,4BAA4B;IACxD;;;;;OAKG;IACH,eAAe,EAAE,iBAAiB;IAClC,oBAAoB,EAAE,sBAAsB;IAC5C,gBAAgB,EAAE,kBAAkB;IACpC;;;;;;;;;;;;;;OAcG;IACH,uBAAuB,EAAE,yBAAyB;IAClD;;;;;OAKG;IACH,iBAAiB,EAAE,mBAAmB;IACtC;;;;;OAKG;IACH,uBAAuB,EAAE,yBAAyB;IAClD;;;;;;;OAOG;IACH,sBAAsB,EAAE,wBAAwB;CACxC,CAAC","sourcesContent":["/**\n * `ProviderCapability` — the closed vocabulary of standardized behaviors\n * a provider claims to implement.\n *\n * Distinct from `EngineCapability` (closed, engine-defined slots that\n * may require fulfillment): a provider CLAIMS a `ProviderCapability`, and\n * `PROVIDER_CAPABILITY_TO_ENGINE_CAPABILITY` projects the claims that fill\n * an engine slot.\n *\n * This header described the vocabulary as \"open, app-extensible\", with a\n * kebab-case convention for app-augmented values, until 2026-09-12. The\n * augmentation point was removed by #502 (see below), so no second namespace\n * exists; the `.cursor/plans/` citation it carried named a directory that no\n * longer exists.\n */\n\n/** @wildo_source:part:start saas.models.provider-capabilities facet:kind:api facet:audience:app-developer\n *\n * Built-in provider capabilities shipped by the framework.\n *\n * Authoring rule: keep this list narrow and stable. Adding a new\n * built-in capability is a framework-level decision (it implies the\n * engine knows how to consume the capability via a transformer or a\n * platform binding). There is no app-side extension point: an application\n * needing a capability this vocabulary does not name is a decision to widen\n * the vocabulary, taken with the resolution path that would make it mean\n * something (#502).\n */\nexport const BUILTIN_PROVIDER_CAPABILITY = {\n  EMAIL_TRANSACTIONAL: 'EMAIL_TRANSACTIONAL',\n  EMAIL_MARKETING: 'EMAIL_MARKETING',\n  /**\n   * Provider RECEIVES email for the application: it hosts the MX for a receiving domain, notifies the\n   * application of each message through a signed webhook, and serves the message (bodies,\n   * authentication results, attachments) on request. Maps to `EngineCapability.EMAIL_INBOUND`.\n   *\n   * A token of its own rather than a reading of `EMAIL_TRANSACTIONAL`, because sending and receiving\n   * are separate procurement decisions: one vendor may send and another receive, and threading only\n   * needs standard headers, so the two never have to agree (#1630). Delivery of the notification is\n   * NOT this capability — like billing's, it rides the `WEBHOOK_ORIGINATOR` protocol through an\n   * endpoint whose `capability` names this token.\n   */\n  EMAIL_INBOUND: 'EMAIL_INBOUND',\n  SMS: 'SMS',\n  /**\n   * Single billing-engagement capability covering everything from\n   * Checkout-style hosted flows to first-party PaymentIntent flows.\n   * Webhook delivery is NOT a separate capability — it is modelled at\n   * the protocol layer (e.g. Stripe declares both a `BILLING_PROVIDER`\n   * and a `WEBHOOK_ORIGINATOR` protocol but a single `BILLING`\n   * capability). This 1:1 matches the billing slot from the older\n   * external connector transformer vocabulary.\n   */\n  BILLING: 'BILLING',\n  SSO_OAUTH2: 'SSO_OAUTH2',\n  /** Reserved for future SAML-based SSO providers (none ship today). */\n  SSO_SAML: 'SSO_SAML',\n  LLM_CHAT: 'LLM_CHAT',\n  LLM_EMBEDDINGS: 'LLM_EMBEDDINGS',\n  /**\n   * Provider turns DOCUMENT BYTES into text — OCR over scans and photographs of pages, not merely\n   * a read of a PDF's existing text layer. Maps to `EngineCapability.AI_DOCUMENT_EXTRACTION`.\n   *\n   * A NEW token was genuinely required rather than convenient: `IMAGE_GENERATION` is an OUTPUT\n   * capability (text → image), and PDF *generation* — the `pdfTemplates` surface — is this\n   * capability's exact opposite. Nothing in the existing vocabulary claimed the document-INPUT\n   * slot. (This paragraph used to name `EngineCapability.DOCUMENT_GENERATION`; that member was\n   * withdrawn because no provider capability could fill it.)\n   *\n   * Distinct from `LLM_CHAT` even where a vendor serves both from one API key: the work is\n   * different (a page-layout model, billed per page, with no sampling parameters), and fusing\n   * them would make the OCR provider unselectable independently of the chat provider — the exact\n   * defect that splitting `AI_EMBEDDINGS` out of `AI_LLM` existed to fix.\n   */\n  DOCUMENT_TEXT_EXTRACTION: 'DOCUMENT_TEXT_EXTRACTION',\n  /**\n   * Provider ships an autonomous CODING AGENT: a process that reads and writes\n   * a workspace, runs commands, and requests authorisation, reachable over the\n   * Agent Client Protocol.\n   *\n   * Distinct from `LLM_CHAT` because the WORK is\n   * different, not merely its transport. A chat model returns text for a caller\n   * to act on; a coding agent acts, and the resulting obligations — permission\n   * decisions, mutation scope, change attribution, verification — have no\n   * counterpart in a completion call.\n   */\n  CODING_AGENT: 'CODING_AGENT',\n  IMAGE_GENERATION: 'IMAGE_GENERATION',\n  FRONTEND_ERROR_MONITORING: 'FRONTEND_ERROR_MONITORING',\n  FRONTEND_PRODUCT_ANALYTICS: 'FRONTEND_PRODUCT_ANALYTICS',\n  /**\n   * A hosted search a browser module brings to a surface. The engine ships no provider for it since #1737\n   * (Algolia DocSearch loaded nothing; the documentation site searches its own generated index). Kept\n   * because an application or package module may still declare one, and the consent classification and the\n   * privacy disclosure map both answer for it.\n   */\n  FRONTEND_SEARCH: 'FRONTEND_SEARCH',\n  FRONTEND_FILE_PICKER: 'FRONTEND_FILE_PICKER',\n  FRONTEND_CAPTCHA: 'FRONTEND_CAPTCHA',\n  /**\n   * A browser component that turns what a person types into a STRUCTURED postal address — the\n   * `z_address()` value — optionally with the vendor's own identifier for the place it matched (#1702,\n   * consumed by the address field of #561).\n   *\n   * The component's contract is `ProviderAddressLookupProps` (`@wildo-ai/saas-models`): it hands back a\n   * `ProviderAddressLookupSelection`. Whether the vendor's place id comes back at all is a static\n   * declaration on the component (`placeIdRetention`), refused at the framework boundary when a selection\n   * contradicts it — the #383 pattern — and the id is never stored (#561 D3). The component reaches its\n   * vendor through the application backend's provider-operation door, never from the page (#561 D2).\n   *\n   * Fills no engine slot: nothing in the engine requires an address lookup to exist, and a field that\n   * finds none is typed by hand. Needs no consent at the capability floor (the person asked for the\n   * lookup); a vendor whose terms make it more than that adds purposes on its own module.\n   */\n  FRONTEND_ADDRESS_LOOKUP: 'FRONTEND_ADDRESS_LOOKUP',\n  /**\n   * Backend LLM-call observability — a provider that ingests per-`invokeAgent`\n   * generation traces (model / tokens / cost / latency), e.g. PostHog\n   * `$ai_generation`. Maps to `EngineCapability.LLM_OBSERVABILITY`. The engine\n   * consumes it via the `AgentCallTraceSink` (not a request/response transformer).\n   */\n  LLM_OBSERVABILITY: 'LLM_OBSERVABILITY',\n  /**\n   * Operational-telemetry sink — a provider that ingests OpenTelemetry traces,\n   * metrics, and logs over OTLP (e.g. BetterStack). Maps to\n   * `EngineCapability.OBSERVABILITY_TELEMETRY`. Consumed by the OTel SDK preload\n   * (env-var-driven), NOT a request/response transformer or a DI sink.\n   */\n  OBSERVABILITY_TELEMETRY: 'OBSERVABILITY_TELEMETRY',\n  /**\n   * Audit-log sink — a provider that stores or forwards compliance audit\n   * events (who-did-what-when), e.g. immudb (tamper-evident) or a SIEM\n   * webhook. Maps to `EngineCapability.COMPLIANCE_AUDIT_TRAIL`, a FAN_OUT\n   * capability: every declared audit provider receives every event (see\n   * `getEngineCapabilityResolutionMode`). The engine consumes it via the\n   * `AuditLogSink` DI fan-out, layered on the always-on database audit store.\n   */\n  COMPLIANCE_AUDIT_TRAIL: 'COMPLIANCE_AUDIT_TRAIL',\n} as const;\n/** @wildo_source:part:end saas.models.provider-capabilities */\n\nexport type BuiltinProviderCapability =\n  (typeof BUILTIN_PROVIDER_CAPABILITY)[keyof typeof BUILTIN_PROVIDER_CAPABILITY];\n\n/*\n * The app-side augmentation point was REMOVED here (#502, decided 2026-09-08).\n *\n * `AppCustomProviderCapabilities` was an empty interface, extended by no application in the\n * repository, whose own docstring described wiring it into `getProvidersByProviderCapability()` as a\n * later phase nobody scheduled. It offered a choice that did not exist: `keyof` an empty interface is\n * `never`, so the union below already resolved to `BuiltinProviderCapability` and removing it changes\n * the resolved type for none of its consumers.\n *\n * If an application genuinely needs a capability the built-in vocabulary does not name, that is a\n * decision about widening a CLOSED semantic vocabulary — with a resolution path built at the same\n * time — not an empty interface left open in advance. An extension point with no resolver is not\n * extensibility; it is a promise nothing can keep.\n */\n\n/**\n * Every provider capability — exactly the closed built-in set. There is no\n * app-side augmentation (removed by #502, see above), so this is a name for\n * `BuiltinProviderCapability` that consumers (the provider registries, the\n * provider component registry, lock-file digests) accept.\n */\nexport type ProviderCapability = BuiltinProviderCapability;\n"]}

package/dist/esm/external-providers/provider-compliance-profile.shared.schemas.d.ts

@@ -27,7 +27,53 @@ export declare enum ProviderDeploymentModel {
     SELF_HOSTED = "SELF_HOSTED"
 }
 /**
- * The compliance-relevant facts a PROVIDER MODULE knows about itself.
+ * Whether a provider's compliance facts have been ESTABLISHED at all (#1708).
+ *
+ * The profile could only be a guess or absent until this existed: `deploymentModels` is non-empty and a
+ * vendor-hosted profile must name a region, so a catalogue vendor nobody has researched had two options —
+ * invent a profile, or carry none, which every reader reports as NOT ESTABLISHED with no way to tell "nobody
+ * looked" from "the module forgot". UNDETERMINED is that first answer, stated: the provider is known, its facts
+ * are not, and a reader treats it as a gap to fill — never as an empty answer, and never as vendor-hosted.
+ */
+export declare enum ProviderComplianceDetermination {
+    /** The facts below were stated by the module's author or the catalogue record, from a source. */
+    ESTABLISHED = "ESTABLISHED",
+    /** Nobody has established who runs this provider or where it processes. A gap, reported as one. */
+    UNDETERMINED = "UNDETERMINED"
+}
+/**
+ * The facts an ESTABLISHED profile can state, each of which a piece of {@link ProviderComplianceFactEvidenceSchema}
+ * can cite. Named so a staleness report can say WHICH fact is old, not merely that "the profile" is.
+ */
+export declare enum ProviderComplianceFact {
+    DEPLOYMENT_MODELS = "DEPLOYMENT_MODELS",
+    PROCESSING_REGIONS = "PROCESSING_REGIONS",
+    VENDOR_LEGAL_ENTITY = "VENDOR_LEGAL_ENTITY",
+    SUBPROCESSOR_LIST = "SUBPROCESSOR_LIST",
+    DATA_PROCESSING_AGREEMENT = "DATA_PROCESSING_AGREEMENT"
+}
+/**
+ * Where one or more facts of a profile were READ, and when (#1708, #1744).
+ *
+ * A vendor fact has a shelf life: vendors reorganise, open data centres and change their sub-processors, and a
+ * fact that was true when a module was written can be false when a notice is published. So a researched fact
+ * carries the page it was read from and the date it was read, which is what makes a staleness report possible
+ * and what lets an operator check the suggestion before adopting it into its own register.
+ *
+ * Required for every fact a CATALOGUE vendor states (the transposer refuses a profile without it); optional on
+ * an engine module, whose author states facts in code review, and reported as UNDATED there.
+ */
+export declare const ProviderComplianceFactEvidenceSchema: z.ZodObject<{
+    /** The facts this source establishes. */
+    facts: z.ZodArray<z.ZodEnum<typeof ProviderComplianceFact>>;
+    /** The vendor page the facts were read from — its own legal, trust or documentation page. */
+    source: z.ZodURL;
+    /** The day the page was read, `YYYY-MM-DD`. */
+    verifiedAt: z.ZodISODate;
+}, z.core.$strict>;
+export type ProviderComplianceFactEvidence = z.infer<typeof ProviderComplianceFactEvidenceSchema>;
+/**
+ * The compliance-relevant facts a PROVIDER MODULE knows about itself, once they are ESTABLISHED.
  *
  * ## Why these live on the provider and not on the application
  *
@@ -40,6 +86,13 @@ export declare enum ProviderDeploymentModel {
  * So the split is: possibilities here, choice in `wildo.saas.config.ts`, and the register entry
  * derived from both (issue #130).
  *
+ * ## These are SUGGESTIONS to the operator, never the operator's answer (#1744)
+ *
+ * The legal facts below (entity, sub-processor list, data processing agreement) are what the framework READ,
+ * on a date, at a URL. They reach a published document only after the operator copies them into its own
+ * processor register and commits it — Paul's decision of 2026-09-25. A reader offers them as the question
+ * to answer, never as the answer.
+ *
  * ## What is deliberately NOT here
  *
  * **A transfer mechanism.** Adequacy decisions move by court ruling rather than by release cycle, so
@@ -51,7 +104,13 @@ export declare enum ProviderDeploymentModel {
  * `BUILTIN_PROVIDER_CAPABILITY` describes the data flow per member. Restating it here would be a
  * second authority for one fact.
  */
-export declare const ProviderComplianceProfileSchema: z.ZodObject<{
+export declare const EstablishedProviderComplianceProfileSchema: z.ZodObject<{
+    /**
+     * Optional, and absent reads as ESTABLISHED: the facts below ARE the establishment, and the engine's own
+     * modules state them without the marker. The transposer always writes it, so a generated profile is
+     * explicit either way.
+     */
+    determination: z.ZodOptional<z.ZodLiteral<ProviderComplianceDetermination.ESTABLISHED>>;
     /**
      * The deployment models this provider SUPPORTS — one, or both where the provider genuinely offers
      * a choice (immudb: a hosted service and a container you run).
@@ -84,15 +143,153 @@ export declare const ProviderComplianceProfileSchema: z.ZodObject<{
      * makes it checkable.
      */
     vendorLegalEntityName: z.ZodOptional<z.ZodString>;
+    /** Where the vendor publishes its own list of sub-processors. A suggestion for the register entry's `subprocessors`. */
+    subprocessorListUrl: z.ZodOptional<z.ZodURL>;
+    /**
+     * Where the vendor offers its data processing agreement — its AVAILABILITY. Whether THIS operator signed one
+     * is the operator's fact and lives on its register entry (#1709), never here.
+     */
+    dataProcessingAgreementUrl: z.ZodOptional<z.ZodURL>;
+    /** Where each stated fact was read, and when. See {@link ProviderComplianceFactEvidenceSchema}. */
+    evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** The facts this source establishes. */
+        facts: z.ZodArray<z.ZodEnum<typeof ProviderComplianceFact>>;
+        /** The vendor page the facts were read from — its own legal, trust or documentation page. */
+        source: z.ZodURL;
+        /** The day the page was read, `YYYY-MM-DD`. */
+        verifiedAt: z.ZodISODate;
+    }, z.core.$strict>>>;
+    /**
+     * What the VENDOR keeps about a data subject, and whether an erasure can reach it (#1710) — the D6 stance
+     * vocabulary: `NO_SUBJECT_DATA`, or `EXTERNAL_ERASURE_OPERATION` when an erasure effect reaches this vendor.
+     *
+     * Optional, and absent means UNDECLARED: a subject erasure then reports this vendor UNMEASURED — incomplete, never
+     * a silent pass. Declare it only with a source: `NO_SUBJECT_DATA` is a claim about the vendor's product that a
+     * reviewer must be able to check, and it closes the erasure question for every application using the provider.
+     */
+    subjectErasure: z.ZodOptional<z.ZodObject<{
+        stance: z.ZodEnum<{
+            readonly NO_SUBJECT_DATA: import("..").HttpApiErasureStance.NO_SUBJECT_DATA;
+            readonly EXTERNAL_ERASURE_OPERATION: import("..").HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION;
+        }>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
+export type EstablishedProviderComplianceProfile = z.infer<typeof EstablishedProviderComplianceProfileSchema>;
+/**
+ * A provider whose compliance facts nobody has established (#1708). A provider carries this until its facts are
+ * researched — for a registry provider, into its module's own profile in `providers-registry/<ref>/` (the archived
+ * catalogue's vendors kept theirs in `_code_archive/providers/catalogue-record/`) — and a reader reports it as a gap
+ * to fill.
+ */
+export declare const UndeterminedProviderComplianceProfileSchema: z.ZodObject<{
+    determination: z.ZodLiteral<ProviderComplianceDetermination.UNDETERMINED>;
+    /** Why the facts are not established, and where the operator establishes them instead. */
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type UndeterminedProviderComplianceProfile = z.infer<typeof UndeterminedProviderComplianceProfileSchema>;
+/**
+ * What a provider declares about who runs it and where it processes: ESTABLISHED facts, or UNDETERMINED.
+ *
+ * A provider that declares NO profile at all is a third state, and a different gap: its author said nothing.
+ * Every reader keeps the three apart — UNDETERMINED names research owed, absence names a module to fix.
+ */
+export declare const ProviderComplianceProfileSchema: z.ZodUnion<readonly [z.ZodObject<{
+    /**
+     * Optional, and absent reads as ESTABLISHED: the facts below ARE the establishment, and the engine's own
+     * modules state them without the marker. The transposer always writes it, so a generated profile is
+     * explicit either way.
+     */
+    determination: z.ZodOptional<z.ZodLiteral<ProviderComplianceDetermination.ESTABLISHED>>;
+    /**
+     * The deployment models this provider SUPPORTS — one, or both where the provider genuinely offers
+     * a choice (immudb: a hosted service and a container you run).
+     *
+     * A single entry means the answer is not the operator's to make and no configuration should offer
+     * it. Two means the application must choose, and a register entry cannot be derived until it has.
+     */
+    deploymentModels: z.ZodArray<z.ZodEnum<typeof ProviderDeploymentModel>>;
+    /**
+     * The regions this vendor can process in — POSSIBILITIES the operator chooses from, never a
+     * choice already made.
+     *
+     * Open strings, deliberately, because these are the VENDOR's own labels (`eu-west-1`,
+     * `us-east-1`, `EU`) and a closed enum here would be this repository inventing a vocabulary it
+     * does not own. The compliance question a transfer statement asks is about JURISDICTION rather
+     * than datacentre, and mapping one to the other is part of the legal determination that is
+     * deliberately not modelled (see above).
+     *
+     * EMPTY is meaningful and is the honest answer for a provider that is only ever self-hosted: the
+     * region is wherever the operator runs it, which the framework cannot know. A configuration
+     * choosing `SELF_HOSTED` therefore needs no region from this list.
+     */
+    processingRegions: z.ZodArray<z.ZodString>;
+    /**
+     * The vendor's legal entity, where the provider module's author can state it.
+     *
+     * OPTIONAL, and the reason is that this is the field most likely to go stale: vendors reorganise,
+     * and a stale legal entity published as a current one is worse than an absent one. Absent means
+     * the application must declare it on the register entry, which is where an operator's own contract
+     * makes it checkable.
+     */
+    vendorLegalEntityName: z.ZodOptional<z.ZodString>;
+    /** Where the vendor publishes its own list of sub-processors. A suggestion for the register entry's `subprocessors`. */
+    subprocessorListUrl: z.ZodOptional<z.ZodURL>;
+    /**
+     * Where the vendor offers its data processing agreement — its AVAILABILITY. Whether THIS operator signed one
+     * is the operator's fact and lives on its register entry (#1709), never here.
+     */
+    dataProcessingAgreementUrl: z.ZodOptional<z.ZodURL>;
+    /** Where each stated fact was read, and when. See {@link ProviderComplianceFactEvidenceSchema}. */
+    evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** The facts this source establishes. */
+        facts: z.ZodArray<z.ZodEnum<typeof ProviderComplianceFact>>;
+        /** The vendor page the facts were read from — its own legal, trust or documentation page. */
+        source: z.ZodURL;
+        /** The day the page was read, `YYYY-MM-DD`. */
+        verifiedAt: z.ZodISODate;
+    }, z.core.$strict>>>;
+    /**
+     * What the VENDOR keeps about a data subject, and whether an erasure can reach it (#1710) — the D6 stance
+     * vocabulary: `NO_SUBJECT_DATA`, or `EXTERNAL_ERASURE_OPERATION` when an erasure effect reaches this vendor.
+     *
+     * Optional, and absent means UNDECLARED: a subject erasure then reports this vendor UNMEASURED — incomplete, never
+     * a silent pass. Declare it only with a source: `NO_SUBJECT_DATA` is a claim about the vendor's product that a
+     * reviewer must be able to check, and it closes the erasure question for every application using the provider.
+     */
+    subjectErasure: z.ZodOptional<z.ZodObject<{
+        stance: z.ZodEnum<{
+            readonly NO_SUBJECT_DATA: import("..").HttpApiErasureStance.NO_SUBJECT_DATA;
+            readonly EXTERNAL_ERASURE_OPERATION: import("..").HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION;
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    determination: z.ZodLiteral<ProviderComplianceDetermination.UNDETERMINED>;
+    /** Why the facts are not established, and where the operator establishes them instead. */
+    reason: z.ZodString;
+}, z.core.$strict>]>;
 export type ProviderComplianceProfile = z.infer<typeof ProviderComplianceProfileSchema>;
-/** True when this provider can only ever be run by the operator, so it is never a third-party recipient. */
+/** The facts an established profile states — the population its evidence may cite and a staleness report dates. */
+export declare function statedProviderComplianceFacts(profile: Pick<EstablishedProviderComplianceProfile, 'vendorLegalEntityName' | 'subprocessorListUrl' | 'dataProcessingAgreementUrl'>): ReadonlySet<ProviderComplianceFact>;
+/** The established profile, or `null` for an UNDETERMINED one or none. The one narrowing every reader uses. */
+export declare function establishedProviderComplianceProfile(profile: ProviderComplianceProfile | null | undefined): EstablishedProviderComplianceProfile | null;
+/**
+ * The oldest `verifiedAt` across an established profile's evidence, or `null` when it cites none (UNDATED).
+ *
+ * The OLDEST, because a profile is only as current as its most stale fact: a fresh region list beside a legal
+ * entity read two years ago is a profile whose entity may be wrong.
+ */
+export declare function oldestProviderComplianceEvidenceDate(profile: EstablishedProviderComplianceProfile): string | null;
+/**
+ * True when this provider can only ever be run by the operator, so it is never a third-party recipient.
+ * An UNDETERMINED profile answers `false`: nobody established it, so it is not established as operator-run.
+ */
 export declare function providerIsAlwaysSelfHosted(profile: ProviderComplianceProfile): boolean;
 /**
  * True when the operator must CHOOSE, because the provider supports both.
  *
  * A register entry for such a provider cannot be derived from the provider module alone — the
- * application's configuration decides whether it is a recipient at all.
+ * application's configuration decides whether it is a recipient at all. An UNDETERMINED profile answers
+ * `false`: what it offers is unknown, which is a research gap rather than a known choice.
  */
 export declare function providerDeploymentModelIsAnOperatorChoice(profile: ProviderComplianceProfile): boolean;
 /** @wildo_source:part:start saas.models.providers.compliance-choice facet:layer:shared facet:audience:app-developer */
@@ -136,6 +333,27 @@ export declare const ApplicationProviderComplianceChoiceSchema: z.ZodObject<{
      * comparison.
      */
     processingRegion: z.ZodOptional<z.ZodString>;
+    /**
+     * The processing PURPOSES sending data to this recipient serves, by the `purposeRef` of a lawful basis in
+     * `operatorComplianceIdentity.lawfulBases` (#1709). Keyed like every choice: a provider ref, or a
+     * `systemsOfRecord.<name>` instance.
+     *
+     * Here, on the operator's compliance statement about the recipient, and deliberately NOT on the runtime provider
+     * selection (`providers.scopes.<scope>.providers.<ref>`): a purpose is a compliance fact no runtime reads, and the
+     * selection schema has four strict copies (config, backend app-config, runtime artifact, lockfile) that would each
+     * refuse a key the others admit. Absent means no purpose is linked, which the recipients report names as such;
+     * a ref naming no declared purpose is reported as a broken link, never refused.
+     */
+    purposeRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    /**
+     * The operator ACKNOWLEDGES that erasure does not reach this recipient (#1710) — the D6 stance
+     * CONTROLLER_ACKNOWLEDGED_NON_ERASURE for a provider. An erasure then reports ACKNOWLEDGED_NON_ERASURE for it,
+     * which is still incomplete: the data stays live at the vendor. The controller's decision, which is why it lives
+     * here on the operator's statement and never on the provider's profile.
+     */
+    subjectErasureAcknowledgement: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ApplicationProviderComplianceChoice = z.infer<typeof ApplicationProviderComplianceChoiceSchema>;
 /** Per configured provider ref, the operator's compliance choice. */
@@ -167,8 +385,76 @@ export declare const ApplicationProviderComplianceChoicesSchema: z.ZodRecord<z.Z
      * comparison.
      */
     processingRegion: z.ZodOptional<z.ZodString>;
+    /**
+     * The processing PURPOSES sending data to this recipient serves, by the `purposeRef` of a lawful basis in
+     * `operatorComplianceIdentity.lawfulBases` (#1709). Keyed like every choice: a provider ref, or a
+     * `systemsOfRecord.<name>` instance.
+     *
+     * Here, on the operator's compliance statement about the recipient, and deliberately NOT on the runtime provider
+     * selection (`providers.scopes.<scope>.providers.<ref>`): a purpose is a compliance fact no runtime reads, and the
+     * selection schema has four strict copies (config, backend app-config, runtime artifact, lockfile) that would each
+     * refuse a key the others admit. Absent means no purpose is linked, which the recipients report names as such;
+     * a ref naming no declared purpose is reported as a broken link, never refused.
+     */
+    purposeRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    /**
+     * The operator ACKNOWLEDGES that erasure does not reach this recipient (#1710) — the D6 stance
+     * CONTROLLER_ACKNOWLEDGED_NON_ERASURE for a provider. An erasure then reports ACKNOWLEDGED_NON_ERASURE for it,
+     * which is still incomplete: the data stays live at the vendor. The controller's decision, which is why it lives
+     * here on the operator's statement and never on the provider's profile.
+     */
+    subjectErasureAcknowledgement: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>>;
 export type ApplicationProviderComplianceChoices = z.infer<typeof ApplicationProviderComplianceChoicesSchema>;
+/**
+ * How an operator's compliance CHOICE for one provider stands against what the provider DECLARES possible (#1708).
+ *
+ * Five answers, because they are five different pieces of work and a reader must not round one into another:
+ * a region the vendor does not list is a typo or a stale profile; a deployment model it does not offer is a
+ * configuration error; an UNDETERMINED profile is research owed; no profile at all is a module that states
+ * nothing. Reported, never refused — the choice schema's own rule.
+ */
+export declare enum ProviderComplianceChoiceAssessment {
+    /** The chosen deployment model is offered, and a vendor-hosted choice names a region the provider lists. */
+    WITHIN_DECLARED_POSSIBILITIES = "WITHIN_DECLARED_POSSIBILITIES",
+    /** The provider does not offer the deployment model the operator chose. */
+    DEPLOYMENT_MODEL_NOT_OFFERED = "DEPLOYMENT_MODEL_NOT_OFFERED",
+    /** A vendor-hosted choice names a region the provider does not list — APP-ASSERTED. */
+    REGION_NOT_OFFERED = "REGION_NOT_OFFERED",
+    /** The provider's profile is UNDETERMINED, so the choice cannot be checked against anything. */
+    PROFILE_UNDETERMINED = "PROFILE_UNDETERMINED",
+    /** The provider declares no compliance profile at all. */
+    NO_PROFILE = "NO_PROFILE"
+}
+/** One choice, assessed. */
+export interface ProviderComplianceChoiceAssessmentEntry {
+    readonly providerRef: string;
+    readonly choice: ApplicationProviderComplianceChoice;
+    readonly assessment: ProviderComplianceChoiceAssessment;
+    /** What the provider offers, when established — so a report can name both sides of a divergence. */
+    readonly offered: {
+        readonly deploymentModels: readonly ProviderDeploymentModel[];
+        readonly processingRegions: readonly string[];
+    } | null;
+}
+/** Assess ONE choice against the provider's profile. See {@link ProviderComplianceChoiceAssessment}. */
+export declare function assessProviderComplianceChoice(choice: ApplicationProviderComplianceChoice, profile: ProviderComplianceProfile | null | undefined): ProviderComplianceChoiceAssessment;
+/**
+ * Every choice assessed against the profiles the application's providers declare, sorted by provider ref.
+ *
+ * `profilesByProviderRef` maps a ref to what its package declares; a ref absent from it declares nothing
+ * ({@link ProviderComplianceChoiceAssessment.NO_PROFILE}). The one comparison the brief, the recipient population
+ * and the evidence collector all make — never re-derived beside it.
+ *
+ * assurance-control: WILDO.PRIVACY.THIRD_PARTY_PROCESSING — each operator choice of a processor's deployment and
+ * region is checked against what the processor declares possible, and an unresearched processor is named.
+ */
+export declare function assessProviderComplianceChoices(params: {
+    readonly choices: ApplicationProviderComplianceChoices;
+    readonly profilesByProviderRef: Readonly<Record<string, ProviderComplianceProfile>>;
+}): readonly ProviderComplianceChoiceAssessmentEntry[];
 /**
  * Regions an application asserts that the provider does not declare.
  *
@@ -176,6 +462,9 @@ export type ApplicationProviderComplianceChoices = z.infer<typeof ApplicationPro
  * operator who genuinely knows better than a stale framework list should be able to say so. What the
  * framework owes is that the divergence is VISIBLE, which is the same trade the personal-data
  * declaration report makes.
+ *
+ * The {@link ProviderComplianceChoiceAssessment.REGION_NOT_OFFERED} slice of {@link assessProviderComplianceChoices};
+ * an UNDETERMINED profile or none is a different gap and is not reported here.
  */
 export declare function appAssertedProcessingRegions(params: {
     readonly choices: ApplicationProviderComplianceChoices;
@@ -185,6 +474,54 @@ export declare function appAssertedProcessingRegions(params: {
     readonly region: string;
 }>;
 /** @wildo_source:part:end saas.models.providers.compliance-choice */
+/**
+ * One provider a FRONTEND service serves, beside the compliance profile its facet module declares.
+ *
+ * `complianceProfile: null` is an answer, not an omission: the module's author stated nothing, so
+ * whether that browser vendor is a third-party recipient is NOT ESTABLISHED. A reader must report
+ * it; skipping it would make the least-documented browser vendor the one a notice never names.
+ */
+export interface ServedFrontendProviderCompliance {
+    /** The frontend service declaration key (`app`, `website`, `docs`, …) the provider is served on. */
+    readonly serviceKey: string;
+    /** The provider ref as the application selects it under that service's provider scope. */
+    readonly providerRef: string;
+    readonly complianceProfile: ProviderComplianceProfile | null;
+}
+/**
+ * Every provider the application's frontend services SERVE, with the profile its facet declares
+ * (#1743) — the browser half of a recipient population.
+ *
+ * ## The join point
+ *
+ * The input is `frontendProviderBootstraps` from the application's generated frontend-services
+ * runtime artifact (`.wildo-saas/generated/providers/frontend-services.runtime-providers.generated.json`,
+ * written by `wildo config sync`), i.e. a `Record<serviceKey, { providers: Record<ref, entry> }>`.
+ * Each entry is a `FrontendProviderEntry`, and since #1743 it carries the facet module's
+ * `complianceProfile`. That record is the right population on its own: materialized per service,
+ * for exactly the providers the service is configured to serve, and readable as JSON without
+ * loading a provider package.
+ *
+ * Typed STRUCTURALLY rather than as `FrontendProvidersBlock`, so this module does not import the
+ * frontend-entry module that imports it, and so a caller holding raw parsed JSON can pass it.
+ *
+ * ## What it does NOT decide
+ *
+ * Whether a browser vendor is the operator's sub-processor or the person's own vendor. A browser SDK
+ * the application keys with its OWN public key (an error-monitoring DSN, an analytics project key, a
+ * captcha site key, a search app id) is engaged by the operator; a file picker opening a person's own
+ * Drive under THEIR vendor account is not. That classification belongs to the recipient population
+ * (#1707), which reads this list rather than re-walking the artifact.
+ *
+ * The same ref served on two services appears twice, deliberately — a per-service record is what
+ * lets a reader say WHICH surface loads the vendor, and the two facets of one vendor may declare
+ * different profiles. Sorted by service, then provider, so the output is deterministic.
+ */
+export declare function listServedFrontendProviderCompliance(bootstraps: Readonly<Record<string, {
+    readonly providers?: Readonly<Record<string, {
+        readonly complianceProfile?: ProviderComplianceProfile;
+    }>>;
+}>> | undefined): readonly ServedFrontendProviderCompliance[];
 /**
  * The configured providers that are THIRD-PARTY RECIPIENTS — vendor-hosted, and therefore processors.
  *

package/dist/esm/external-providers/provider-compliance-profile.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider-compliance-profile.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/external-providers/provider-compliance-profile.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;GAaG;AACH,oBAAY,uBAAuB;IACjC;;;OAGG;IACH,aAAa,kBAAkB;IAC/B;;;;OAIG;IACH,WAAW,gBAAgB;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,+BAA+B;IAC1C;;;;;;OAMG;;IAEH;;;;;;;;;;;;;OAaG;;IAEH;;;;;;;OAOG;;kBAkBH,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF,4GAA4G;AAC5G,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAEtF;AAED;;;;;GAKG;AACH,wBAAgB,yCAAyC,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAErG;AAED,uHAAuH;AACvH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yCAAyC;IACpD;;;;;;;OAOG;;IAEH;;;;;;;;;;;;;;;;OAgBG;;kBAyBH,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAE5G,qEAAqE;AACrE,eAAO,MAAM,0CAA0C;IAtDrD;;;;;;;OAOG;;IAEH;;;;;;;;;;;;;;;;OAgBG;;mBAgCJ,CAAC;AACF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0CAA0C,CAAC,CAAC;AAE9G;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE;IACnD,QAAQ,CAAC,OAAO,EAAE,oCAAoC,CAAC;IACvD,QAAQ,CAAC,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC,CAAC;CACrF,GAAG,aAAa,CAAC;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAc3E;AACD,qEAAqE;AAErE;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,oCAAoC,GAAG,SAAS,MAAM,EAAE,CAKzG"}
+{"version":3,"file":"provider-compliance-profile.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/external-providers/provider-compliance-profile.shared.schemas.ts"],"names":[],"mappings":"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"}