@wildo-ai/saas-models 1.0.1 → 1.1.0

package/dist/esm/companion/provider-discovery.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-discovery.shared.schemas.js","sourceRoot":"","sources":["../../../../src/companion/provider-discovery.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\nimport { AppFrontendType } from '../config/app-frontend-type.shared.schemas';\nimport { EngineCapability } from '../external-providers/engine-capabilities.shared.schemas';\nimport { FrontendProviderEntrySchema } from '../external-providers/frontend-bootstrap.shared.schemas';\n\n/**\n * Companion-safe provider implementation declaration.\n *\n * App/runtime-owner packages expose these entries through their `./companion`\n * default export so tooling can discover which provider refs are actually\n * reachable from which runtime owners before materializing generated artifacts.\n */\n\n/**\n * Discriminator branch for `frontendService` runtime targets.\n *\n * Targets a frontend service by its `AppFrontendType` (the closed kind set\n * — SAAS_APP, STATIC_WEBSITE, TECH_DOC) rather than by an app-defined\n * `serviceKey` string. Engine-shipped packages (`external-connectors-public`,\n * etc.) have no way to know app-defined service keys, so the discovery\n * contract is keyed on the type. Apps with multiple frontend services of\n * the same type currently broadcast the contribution to all of them; if\n * per-service-key targeting becomes a need, add a second variant.\n */\nexport const ProviderFrontendServiceRuntimeTargetSchema = z.strictObject({\n  kind: z.literal('frontendService'),\n  serviceType: z.enum(AppFrontendType),\n});\nexport type ProviderFrontendServiceRuntimeTarget = z.infer<typeof ProviderFrontendServiceRuntimeTargetSchema>;\n\nexport const ProviderCompanionRuntimeTargetSchema = z.discriminatedUnion('kind', [\n  z.strictObject({\n    kind: z.literal('backend'),\n  }),\n  z.strictObject({\n    kind: z.literal('companion'),\n  }),\n  ProviderFrontendServiceRuntimeTargetSchema,\n  z.strictObject({\n    kind: z.literal('minion'),\n    minionKey: z.string().min(1),\n  }),\n  z.strictObject({\n    kind: z.literal('worker'),\n    workerKey: z.string().min(1),\n  }),\n]);\nexport type ProviderCompanionRuntimeTarget = z.infer<typeof ProviderCompanionRuntimeTargetSchema>;\n\n/**\n * Values-free projection of one backend provider secret requirement.\n *\n * The stable provider-owned `slug` is preserved separately from the concrete\n * environment-variable name so a rename on either axis changes the lockfile\n * integrity digest. Secret values never cross this companion-safe boundary.\n */\nexport const ProviderSecretContractShapeEntrySchema = z.strictObject({\n  slug: z.string().min(1),\n  envVarName: z.string().min(1),\n  required: z.boolean(),\n  description: z.string().min(1),\n});\nexport type ProviderSecretContractShapeEntry = z.infer<typeof ProviderSecretContractShapeEntrySchema>;\n\n/**\n * Deterministic, values-free secret-contract shape used by provider discovery\n * and lockfile integrity checks.\n *\n * Every contribution must declare this field. `[]` means the provider is\n * authoritatively known to require no secrets; omission is rejected rather\n * than being silently interpreted as an empty contract. Entries must be\n * sorted by `slug`, and both slugs and environment-variable names are unique,\n * so independently contributed facets cannot produce order-dependent digests.\n */\nexport const ProviderSecretContractShapeSchema = z.array(ProviderSecretContractShapeEntrySchema).superRefine((entries, context) => {\n  const seenSlugs = new Set<string>();\n  const seenEnvVarNames = new Set<string>();\n\n  for (const [index, entry] of entries.entries()) {\n    if (seenSlugs.has(entry.slug)) {\n      context.addIssue({\n        code: 'custom',\n        path: [index, 'slug'],\n        message: `Duplicate provider secret-contract slug \"${entry.slug}\".`,\n      });\n    }\n    seenSlugs.add(entry.slug);\n\n    if (seenEnvVarNames.has(entry.envVarName)) {\n      context.addIssue({\n        code: 'custom',\n        path: [index, 'envVarName'],\n        message: `Duplicate provider secret-contract envVarName \"${entry.envVarName}\".`,\n      });\n    }\n    seenEnvVarNames.add(entry.envVarName);\n\n    if (index > 0 && entries[index - 1].slug.localeCompare(entry.slug) >= 0) {\n      context.addIssue({\n        code: 'custom',\n        path: [index, 'slug'],\n        message: 'Provider secret-contract entries must be sorted by slug.',\n      });\n    }\n  }\n});\nexport type ProviderSecretContractShape = z.infer<typeof ProviderSecretContractShapeSchema>;\n\nexport const ProviderCompanionContributionSchema = z.strictObject({\n  ref: z.string().min(1),\n  /**\n   * Stable package import path that makes the provider implementation reachable\n   * from the contributing package at runtime. This validates owner-package\n   * reachability without coupling discovery to source-file paths.\n   */\n  runtimeImportPath: z.string().min(1),\n  runtimeTargets: z.array(ProviderCompanionRuntimeTargetSchema).min(1),\n  engineCapabilities: z.array(z.enum(EngineCapability)).default([]),\n  providerCapabilities: z.array(z.string().min(1)).default([]),\n  protocols: z.array(z.string().min(1)).default([]),\n  secretsContractShape: ProviderSecretContractShapeSchema,\n  /**\n   * Optional frontend-safe provider payload for `frontendService` runtime\n   * targets. Tooling materializes this into generated runtime artifacts so the\n   * backend bootstrap endpoint can serve app-owned public providers without\n   * importing frontend packages at runtime.\n   */\n  frontendEntry: FrontendProviderEntrySchema.optional(),\n  /**\n   * Optional app module owner when the provider implementation belongs to one\n   * concrete module instead of the whole package/runtime.\n   */\n  sourceModuleId: z.string().min(1).optional(),\n});\nexport type ProviderCompanionContribution = z.infer<typeof ProviderCompanionContributionSchema>;\n\nexport interface RuntimeOwnerCompanionExports {\n  providerContributions?: ProviderCompanionContribution[];\n}\n"]}

package/dist/esm/companion/shared-library-companion.shared.definitions.d.ts

@@ -0,0 +1,6 @@
+import type { SharedSaaSModule } from '../runtime/domain-module.shared.definitions';
+import type { RuntimeOwnerCompanionExports } from './provider-discovery.shared.schemas';
+export interface SharedLibraryCompanionExports<TSharedModule extends SharedSaaSModule = SharedSaaSModule> extends RuntimeOwnerCompanionExports {
+    loadSharedModules: () => Promise<TSharedModule[]>;
+}
+//# sourceMappingURL=shared-library-companion.shared.definitions.d.ts.map

package/dist/esm/companion/shared-library-companion.shared.definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-library-companion.shared.definitions.d.ts","sourceRoot":"","sources":["../../../../src/companion/shared-library-companion.shared.definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AACpF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qCAAqC,CAAC;AAExF,MAAM,WAAW,6BAA6B,CAC5C,aAAa,SAAS,gBAAgB,GAAG,gBAAgB,CACzD,SAAQ,4BAA4B;IACpC,iBAAiB,EAAE,MAAM,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;CACnD"}

package/dist/esm/companion/shared-library-companion.shared.definitions.js

@@ -0,0 +1 @@
+//# sourceMappingURL=shared-library-companion.shared.definitions.js.map

package/dist/esm/companion/shared-library-companion.shared.definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-library-companion.shared.definitions.js","sourceRoot":"","sources":["../../../../src/companion/shared-library-companion.shared.definitions.ts"],"names":[],"mappings":"","sourcesContent":["import type { SharedSaaSModule } from '../runtime/domain-module.shared.definitions';\nimport type { RuntimeOwnerCompanionExports } from './provider-discovery.shared.schemas';\n\nexport interface SharedLibraryCompanionExports<\n  TSharedModule extends SharedSaaSModule = SharedSaaSModule,\n> extends RuntimeOwnerCompanionExports {\n  loadSharedModules: () => Promise<TSharedModule[]>;\n}\n"]}

package/dist/esm/companion-exports.d.ts

@@ -0,0 +1,4 @@
+export * from './companion/artifact-placement.shared.definitions';
+export * from './companion/provider-discovery.shared.schemas';
+export * from './companion/shared-library-companion.shared.definitions';
+//# sourceMappingURL=companion-exports.d.ts.map

package/dist/esm/companion-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"companion-exports.d.ts","sourceRoot":"","sources":["../../../src/companion-exports.ts"],"names":[],"mappings":"AAAA,cAAc,mDAAmD,CAAC;AAClE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,yDAAyD,CAAC"}

package/dist/esm/companion-exports.js

@@ -0,0 +1,4 @@
+export * from './companion/artifact-placement.shared.definitions.js';
+export * from './companion/provider-discovery.shared.schemas.js';
+export * from './companion/shared-library-companion.shared.definitions.js';
+//# sourceMappingURL=companion-exports.js.map

package/dist/esm/companion-exports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"companion-exports.js","sourceRoot":"","sources":["../../../src/companion-exports.ts"],"names":[],"mappings":"AAAA,cAAc,mDAAmD,CAAC;AAClE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,yDAAyD,CAAC","sourcesContent":["export * from './companion/artifact-placement.shared.definitions';\nexport * from './companion/provider-discovery.shared.schemas';\nexport * from './companion/shared-library-companion.shared.definitions';\n"]}

package/dist/esm/compliance/audit-trails/audit-actor.shared.schemas.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Audit ACTOR vocabulary — what goes in an audit event's `*By` field when there is no acting user.
+ *
+ * Every auditable-event payload carries an actor field (`deletedBy`, `changedBy`, `removedBy`,
+ * `requestedBy`, …) typed as a plain string, whose contract is: **the acting user's id, or a
+ * sentinel from this enum saying why there is no user.** A reader can always tell the two apart —
+ * these values are not id-shaped.
+ *
+ * ## Why this exists
+ *
+ * Every emitter used to fall back to the bare literal `'unknown'`, which merged three genuinely
+ * different facts into one token:
+ *
+ * - the scheduled `organization-purge` batch destroying a tenant — the actor is precisely known, it
+ *   is the system;
+ * - a machine principal acting on an API key or OAuth client — non-human, but attributable;
+ * - a request that should have carried a principal and did not — a real anomaly.
+ *
+ * An auditor reading `'unknown'` cannot distinguish "routine automation" from "we failed to
+ * attribute a privileged action", so the one case worth investigating was hidden inside the two that
+ * are not. Merging semantically distinct concepts because they share a wire value is exactly what
+ * the framework forbids; naming them separately restores the distinction.
+ *
+ * Discovered 2026-08-04 by the `organization-purge-batch-audit` e2e lane, which observed a
+ * batch-purged tenant recorded as deleted by `'unknown'`.
+ *
+ * assurance-control: WILDO.AUDIT.ATTRIBUTION — a security-relevant action must record who performed
+ * it, and must not disguise an unattributable action as an ordinary automated one.
+ */
+/**
+ * Sentinel actors for audit `*By` fields. Resolve one with
+ * `resolveAuditActorId(executionContext)` from `@wildo-ai/saas-backend-lib` rather than choosing by
+ * hand — the mapping from execution type to sentinel belongs in one place.
+ */
+export declare enum AuditActorSentinel {
+    /**
+     * The system acted with no human principal BY DESIGN — a scheduled batch, a cron job, or an
+     * internally initiated workflow. This is an ATTRIBUTED outcome: the actor is the application
+     * itself, and a reviewer should read it as routine automation.
+     */
+    SYSTEM = "system",
+    /**
+     * A machine principal acted: an organization or application API key, or an OAuth client. Non-human
+     * but legitimate and traceable — the specific credential is recorded on the execution context
+     * (`initiatorIds.machineCredential`) and on the machine-authentication event trail, so this field
+     * records the KIND of actor rather than duplicating a second id shape into a user-id slot.
+     */
+    MACHINE = "machine",
+    /**
+     * A principal was expected and could not be resolved. Unlike the two above this is an ANOMALY, and
+     * it is the value a reviewer should alert on: a privileged action happened and the trail cannot
+     * say who performed it.
+     */
+    UNATTRIBUTED = "unattributed"
+}
+/** Every sentinel value, for consumers that need to tell a sentinel from a real user id. */
+export declare const AUDIT_ACTOR_SENTINELS: readonly string[];
+/**
+ * Whether an audit `*By` value is a sentinel rather than a user id.
+ *
+ * Use this instead of comparing against literals at a call site — a consumer that hard-codes
+ * `=== 'system'` silently stops matching if the vocabulary grows.
+ */
+export declare function isAuditActorSentinel(actorId: string): boolean;
+//# sourceMappingURL=audit-actor.shared.schemas.d.ts.map

package/dist/esm/compliance/audit-trails/audit-actor.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-actor.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/compliance/audit-trails/audit-actor.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;GAIG;AACH,oBAAY,kBAAkB;IAC5B;;;;OAIG;IACH,MAAM,WAAW;IACjB;;;;;OAKG;IACH,OAAO,YAAY;IACnB;;;;OAIG;IACH,YAAY,iBAAiB;CAC9B;AAED,4FAA4F;AAC5F,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAAqD,CAAC;AAEzG;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE7D"}

package/dist/esm/compliance/audit-trails/audit-actor.shared.schemas.js

@@ -0,0 +1,68 @@
+/**
+ * Audit ACTOR vocabulary — what goes in an audit event's `*By` field when there is no acting user.
+ *
+ * Every auditable-event payload carries an actor field (`deletedBy`, `changedBy`, `removedBy`,
+ * `requestedBy`, …) typed as a plain string, whose contract is: **the acting user's id, or a
+ * sentinel from this enum saying why there is no user.** A reader can always tell the two apart —
+ * these values are not id-shaped.
+ *
+ * ## Why this exists
+ *
+ * Every emitter used to fall back to the bare literal `'unknown'`, which merged three genuinely
+ * different facts into one token:
+ *
+ * - the scheduled `organization-purge` batch destroying a tenant — the actor is precisely known, it
+ *   is the system;
+ * - a machine principal acting on an API key or OAuth client — non-human, but attributable;
+ * - a request that should have carried a principal and did not — a real anomaly.
+ *
+ * An auditor reading `'unknown'` cannot distinguish "routine automation" from "we failed to
+ * attribute a privileged action", so the one case worth investigating was hidden inside the two that
+ * are not. Merging semantically distinct concepts because they share a wire value is exactly what
+ * the framework forbids; naming them separately restores the distinction.
+ *
+ * Discovered 2026-08-04 by the `organization-purge-batch-audit` e2e lane, which observed a
+ * batch-purged tenant recorded as deleted by `'unknown'`.
+ *
+ * assurance-control: WILDO.AUDIT.ATTRIBUTION — a security-relevant action must record who performed
+ * it, and must not disguise an unattributable action as an ordinary automated one.
+ */
+/**
+ * Sentinel actors for audit `*By` fields. Resolve one with
+ * `resolveAuditActorId(executionContext)` from `@wildo-ai/saas-backend-lib` rather than choosing by
+ * hand — the mapping from execution type to sentinel belongs in one place.
+ */
+export var AuditActorSentinel;
+(function (AuditActorSentinel) {
+    /**
+     * The system acted with no human principal BY DESIGN — a scheduled batch, a cron job, or an
+     * internally initiated workflow. This is an ATTRIBUTED outcome: the actor is the application
+     * itself, and a reviewer should read it as routine automation.
+     */
+    AuditActorSentinel["SYSTEM"] = "system";
+    /**
+     * A machine principal acted: an organization or application API key, or an OAuth client. Non-human
+     * but legitimate and traceable — the specific credential is recorded on the execution context
+     * (`initiatorIds.machineCredential`) and on the machine-authentication event trail, so this field
+     * records the KIND of actor rather than duplicating a second id shape into a user-id slot.
+     */
+    AuditActorSentinel["MACHINE"] = "machine";
+    /**
+     * A principal was expected and could not be resolved. Unlike the two above this is an ANOMALY, and
+     * it is the value a reviewer should alert on: a privileged action happened and the trail cannot
+     * say who performed it.
+     */
+    AuditActorSentinel["UNATTRIBUTED"] = "unattributed";
+})(AuditActorSentinel || (AuditActorSentinel = {}));
+/** Every sentinel value, for consumers that need to tell a sentinel from a real user id. */
+export const AUDIT_ACTOR_SENTINELS = Object.freeze(Object.values(AuditActorSentinel));
+/**
+ * Whether an audit `*By` value is a sentinel rather than a user id.
+ *
+ * Use this instead of comparing against literals at a call site — a consumer that hard-codes
+ * `=== 'system'` silently stops matching if the vocabulary grows.
+ */
+export function isAuditActorSentinel(actorId) {
+    return AUDIT_ACTOR_SENTINELS.includes(actorId);
+}
+//# sourceMappingURL=audit-actor.shared.schemas.js.map

package/dist/esm/compliance/audit-trails/audit-actor.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-actor.shared.schemas.js","sourceRoot":"","sources":["../../../../../src/compliance/audit-trails/audit-actor.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;GAIG;AACH,MAAM,CAAN,IAAY,kBAoBX;AApBD,WAAY,kBAAkB;IAC5B;;;;OAIG;IACH,uCAAiB,CAAA;IACjB;;;;;OAKG;IACH,yCAAmB,CAAA;IACnB;;;;OAIG;IACH,mDAA6B,CAAA;AAC/B,CAAC,EApBW,kBAAkB,KAAlB,kBAAkB,QAoB7B;AAED,4FAA4F;AAC5F,MAAM,CAAC,MAAM,qBAAqB,GAAsB,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC;AAEzG;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAAe;IAClD,OAAO,qBAAqB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;AACjD,CAAC","sourcesContent":["/**\n * Audit ACTOR vocabulary — what goes in an audit event's `*By` field when there is no acting user.\n *\n * Every auditable-event payload carries an actor field (`deletedBy`, `changedBy`, `removedBy`,\n * `requestedBy`, …) typed as a plain string, whose contract is: **the acting user's id, or a\n * sentinel from this enum saying why there is no user.** A reader can always tell the two apart —\n * these values are not id-shaped.\n *\n * ## Why this exists\n *\n * Every emitter used to fall back to the bare literal `'unknown'`, which merged three genuinely\n * different facts into one token:\n *\n * - the scheduled `organization-purge` batch destroying a tenant — the actor is precisely known, it\n *   is the system;\n * - a machine principal acting on an API key or OAuth client — non-human, but attributable;\n * - a request that should have carried a principal and did not — a real anomaly.\n *\n * An auditor reading `'unknown'` cannot distinguish \"routine automation\" from \"we failed to\n * attribute a privileged action\", so the one case worth investigating was hidden inside the two that\n * are not. Merging semantically distinct concepts because they share a wire value is exactly what\n * the framework forbids; naming them separately restores the distinction.\n *\n * Discovered 2026-08-04 by the `organization-purge-batch-audit` e2e lane, which observed a\n * batch-purged tenant recorded as deleted by `'unknown'`.\n *\n * assurance-control: WILDO.AUDIT.ATTRIBUTION — a security-relevant action must record who performed\n * it, and must not disguise an unattributable action as an ordinary automated one.\n */\n\n/**\n * Sentinel actors for audit `*By` fields. Resolve one with\n * `resolveAuditActorId(executionContext)` from `@wildo-ai/saas-backend-lib` rather than choosing by\n * hand — the mapping from execution type to sentinel belongs in one place.\n */\nexport enum AuditActorSentinel {\n  /**\n   * The system acted with no human principal BY DESIGN — a scheduled batch, a cron job, or an\n   * internally initiated workflow. This is an ATTRIBUTED outcome: the actor is the application\n   * itself, and a reviewer should read it as routine automation.\n   */\n  SYSTEM = 'system',\n  /**\n   * A machine principal acted: an organization or application API key, or an OAuth client. Non-human\n   * but legitimate and traceable — the specific credential is recorded on the execution context\n   * (`initiatorIds.machineCredential`) and on the machine-authentication event trail, so this field\n   * records the KIND of actor rather than duplicating a second id shape into a user-id slot.\n   */\n  MACHINE = 'machine',\n  /**\n   * A principal was expected and could not be resolved. Unlike the two above this is an ANOMALY, and\n   * it is the value a reviewer should alert on: a privileged action happened and the trail cannot\n   * say who performed it.\n   */\n  UNATTRIBUTED = 'unattributed',\n}\n\n/** Every sentinel value, for consumers that need to tell a sentinel from a real user id. */\nexport const AUDIT_ACTOR_SENTINELS: readonly string[] = Object.freeze(Object.values(AuditActorSentinel));\n\n/**\n * Whether an audit `*By` value is a sentinel rather than a user id.\n *\n * Use this instead of comparing against literals at a call site — a consumer that hard-codes\n * `=== 'system'` silently stops matching if the vocabulary grows.\n */\nexport function isAuditActorSentinel(actorId: string): boolean {\n  return AUDIT_ACTOR_SENTINELS.includes(actorId);\n}\n"]}

package/dist/esm/compliance/audit-trails/audit-log-sink.shared.schemas.d.ts

@@ -0,0 +1,147 @@
+import type { AuditableEvent } from './auditable-events.shared.schema';
+/**
+ * A per-org target VERIFIED as trusted for the current user — an org id the flow confirmed the
+ * authenticated user is a genuine ACTIVE member of (via `resolveActiveMemberOrgIds`), or that came
+ * from a cryptographically-validated connection.
+ *
+ * This is the CANONICAL type for ANY per-user org used to ROUTE DATA to a tenant or to SCOPE a
+ * resource read/query by tenant — not audit routing alone. Per-org audit dispatch already routes
+ * ONLY on this brand; new data-routing / tenant-scoping surfaces should take `VerifiedOrgId` too, so
+ * the untrusted email-domain→org guess (`session.organizationId` / `DomainOrgLookupResult.scopeId`)
+ * can NEVER reach them without a deliberate, reviewable cast (routing the audit trail on that guess
+ * was the 2026-07-09 cross-tenant leak).
+ *
+ * NOT for the SSO-ENFORCEMENT boundary: the domain-scoped SSO gates (e.g. `_checkSSOGraceLoginAllowed`)
+ * legitimately key on the domain-ownership hint and must NOT be forced to take a membership org —
+ * that is a different, fail-safe boundary by design.
+ *
+ * The brand is a COMPILE-TIME guard: a plain `string` / `string[]` cannot be passed where a
+ * `VerifiedOrgId` is expected without a deliberate cast — which is the resolver's job
+ * (`resolveActiveMemberOrgIds`), never a raw caller value.
+ */
+export type VerifiedOrgId = string & {
+    readonly __brand: 'VerifiedOrgId';
+};
+/**
+ * The event payload handed to an `AuditLogSink` — the persisted audit event
+ * MINUS the DB primary key (`_id`), which is store-specific and not yet
+ * assigned at fan-out time (the emit runs INDEPENDENTLY of, and possibly before,
+ * the DB write completes). The store-agnostic `eventId` (see
+ * `AuditableEvent.eventId`) IS present and is the stable cross-store correlation
+ * key every sink should record — the same id the Phase-3 reconciler and
+ * `AuditLogVerification.verifyAuditEvent` key on.
+ *
+ * A DEDICATED emission type (rather than the raw persisted `AuditableEvent`)
+ * mirrors `AgentCallTraceEmission`: the write path never has a DB `_id` to give,
+ * so the contract must not demand one — and sinks can gain fields here without a
+ * signature change at every call site.
+ */
+export type AuditLogEventEmission = Omit<AuditableEvent, '_id'>;
+/**
+ * `AuditLogSink` — a destination for compliance audit events (the FAN_OUT
+ * side of `EngineCapability.COMPLIANCE_AUDIT_TRAIL`). One sink per provider
+ * (immudb, a SIEM webhook, …); the engine's composite fans EVERY event out to
+ * EVERY declared sink, layered on the always-on database audit store.
+ *
+ * The interface lives in `saas-models` so the engine + apps depend on the
+ * contract without importing any provider SDK (the dependency-cycle break,
+ * mirroring `AgentCallTraceSink`).
+ *
+ * DELIVERY CONTRACT — deliberately STRONGER than the best-effort, sampled,
+ * droppable `AgentCallTraceSink`; mirror that sink's WIRING (lazy resolution,
+ * DI, never-throw) but NOT its guarantees:
+ * - **At-least-once + unsampled** — every event must reach every sink; no
+ *   sampling, no drop-on-load. A sink that forwards asynchronously owns its own
+ *   durable buffering + retry.
+ * - **Immutable / append-only** — a sink never updates or deletes a recorded
+ *   event.
+ * - **Non-blocking** — the engine calls sinks fire-and-forget; a sink failure
+ *   is isolated + observable, never thrown onto the business-op path.
+ *   Completeness vs the authoritative DB store is the provider's reconciliation
+ *   concern, not the caller's.
+ */
+export interface AuditLogSink {
+    /**
+     * Record one audit event to this destination, honoring the delivery contract
+     * above. Resolves when the event is durably accepted by the sink's own
+     * buffering — not necessarily when persisted at the far end.
+     *
+     * MUST NOT throw synchronously NOR return a rejecting promise — buffer-and-
+     * return. The engine's composite isolates each sink, but that isolation is a
+     * backstop, not a licence: a sink that rejects here still breaks the contract,
+     * and any future direct (non-composite) caller would inherit an unhandled
+     * rejection on the audit path.
+     */
+    recordAuditEvent(event: AuditLogEventEmission): void | Promise<void>;
+    /**
+     * Optional flush/cleanup, best-effort on host shutdown. A sink that batches
+     * asynchronously MUST drain here so short-lived hosts (minion/worker) don't
+     * lose queued events.
+     */
+    shutdown?(): void | Promise<void>;
+}
+/**
+ * Outcome of an `AuditLogVerification.verifyAuditEvent` check.
+ *
+ * Distinguishes the two very different `verified: false` cases an external auditor must NOT
+ * conflate — an event that was never recorded at the destination vs. one that WAS recorded but whose
+ * cryptographic proof now fails (the actual tamper signal). The prior contract collapsed both into a
+ * bare boolean + free-text `detail`, so a tampered entry was indistinguishable from a missing one.
+ */
+export declare enum AuditLogVerificationStatus {
+    /** Present AND its cryptographic proof verified — genuinely untampered. */
+    Verified = "verified",
+    /** Not present at the destination (never recorded, or the reconciler has not caught up). NOT a tamper. */
+    Absent = "absent",
+    /** Present but the proof FAILED — the entry was altered since it was written. The tamper signal. */
+    Tampered = "tampered",
+    /** Could not be determined (store unreachable / no proof obtainable) — neither confirmed nor refuted. */
+    Unverifiable = "unverifiable"
+}
+/**
+ * Result of an `AuditLogVerification` proof check. `verified` is retained as the fast boolean
+ * (`status === Verified`); `status` is the discriminator auditors branch on (absent vs tampered vs
+ * unverifiable) — a tamper must never read the same as a not-yet-recorded event.
+ */
+export interface AuditLogVerificationResult {
+    verified: boolean;
+    /** Discriminated outcome — the authoritative field; `verified` is `status === Verified`. */
+    status: AuditLogVerificationStatus;
+    /** Technology-specific proof detail (e.g. immudb tx id + inclusion proof). */
+    detail?: string;
+}
+/**
+ * Optional, technology-aware verification a provider MAY expose when its store
+ * supports cryptographic proofs (e.g. immudb inclusion/consistency proofs).
+ *
+ * Day-to-day the audit pipeline is WRITE-ONLY; verification is an
+ * external-auditor concern, resolved separately from the write path. This
+ * contract is reserved in Phase 1 and implemented for immudb in Phase 5 —
+ * providers whose technology cannot prove non-tampering simply don't expose it.
+ */
+export interface AuditLogVerification {
+    /**
+     * Verify a previously-recorded event is present + untampered at the
+     * destination, returning the technology's proof result.
+     */
+    verifyAuditEvent(eventId: string): Promise<AuditLogVerificationResult>;
+}
+/**
+ * Optional capability a sink exposes when it can persist the completeness reconciler's
+ * high-water mark IN ITS OWN store (e.g. immudb under a reserved key) — so the reconciler
+ * needs no separate state resource and no `AUDIT_LOGS` schema change. A sink whose
+ * technology can't hold a cursor (a fire-and-forget SIEM webhook) simply doesn't
+ * implement it, and the reconciler falls back to a bounded windowed replay.
+ *
+ * The mark is an opaque, monotonic cursor the reconciler defines (today: the ISO
+ * `createdAt` of the last event confirmed synced); the store round-trips it verbatim.
+ * The reconciler pairs this with an IDEMPOTENT `AuditLogSink.recordAuditEvent`
+ * (write-if-absent) so replaying an already-synced event is a no-op.
+ */
+export interface AuditReconcileCheckpointStore {
+    /** The last persisted high-water mark, or `null` when the reconciler has never run (or the store is unreachable). */
+    getAuditReconcileCheckpoint(): Promise<string | null>;
+    /** Persist the high-water mark after a reconcile batch is confirmed in the store. */
+    setAuditReconcileCheckpoint(mark: string): Promise<void>;
+}
+//# sourceMappingURL=audit-log-sink.shared.schemas.d.ts.map

package/dist/esm/compliance/audit-trails/audit-log-sink.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-log-sink.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/compliance/audit-trails/audit-log-sink.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;CAAE,CAAC;AAE3E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;;;;OAUG;IACH,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrE;;;;OAIG;IACH,QAAQ,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,oBAAY,0BAA0B;IACpC,2EAA2E;IAC3E,QAAQ,aAAa;IACrB,0GAA0G;IAC1G,MAAM,WAAW;IACjB,oGAAoG;IACpG,QAAQ,aAAa;IACrB,yGAAyG;IACzG,YAAY,iBAAiB;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,OAAO,CAAC;IAClB,4FAA4F;IAC5F,MAAM,EAAE,0BAA0B,CAAC;IACnC,8EAA8E;IAC9E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;CACxE;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,6BAA6B;IAC5C,qHAAqH;IACrH,2BAA2B,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACtD,qFAAqF;IACrF,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D"}

package/dist/esm/compliance/audit-trails/audit-log-sink.shared.schemas.js

@@ -0,0 +1,20 @@
+/**
+ * Outcome of an `AuditLogVerification.verifyAuditEvent` check.
+ *
+ * Distinguishes the two very different `verified: false` cases an external auditor must NOT
+ * conflate — an event that was never recorded at the destination vs. one that WAS recorded but whose
+ * cryptographic proof now fails (the actual tamper signal). The prior contract collapsed both into a
+ * bare boolean + free-text `detail`, so a tampered entry was indistinguishable from a missing one.
+ */
+export var AuditLogVerificationStatus;
+(function (AuditLogVerificationStatus) {
+    /** Present AND its cryptographic proof verified — genuinely untampered. */
+    AuditLogVerificationStatus["Verified"] = "verified";
+    /** Not present at the destination (never recorded, or the reconciler has not caught up). NOT a tamper. */
+    AuditLogVerificationStatus["Absent"] = "absent";
+    /** Present but the proof FAILED — the entry was altered since it was written. The tamper signal. */
+    AuditLogVerificationStatus["Tampered"] = "tampered";
+    /** Could not be determined (store unreachable / no proof obtainable) — neither confirmed nor refuted. */
+    AuditLogVerificationStatus["Unverifiable"] = "unverifiable";
+})(AuditLogVerificationStatus || (AuditLogVerificationStatus = {}));
+//# sourceMappingURL=audit-log-sink.shared.schemas.js.map

package/dist/esm/compliance/audit-trails/audit-log-sink.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-log-sink.shared.schemas.js","sourceRoot":"","sources":["../../../../../src/compliance/audit-trails/audit-log-sink.shared.schemas.ts"],"names":[],"mappings":"AAoFA;;;;;;;GAOG;AACH,MAAM,CAAN,IAAY,0BASX;AATD,WAAY,0BAA0B;IACpC,2EAA2E;IAC3E,mDAAqB,CAAA;IACrB,0GAA0G;IAC1G,+CAAiB,CAAA;IACjB,oGAAoG;IACpG,mDAAqB,CAAA;IACrB,yGAAyG;IACzG,2DAA6B,CAAA;AAC/B,CAAC,EATW,0BAA0B,KAA1B,0BAA0B,QASrC","sourcesContent":["import type { AuditableEvent } from './auditable-events.shared.schema';\n\n/**\n * A per-org target VERIFIED as trusted for the current user — an org id the flow confirmed the\n * authenticated user is a genuine ACTIVE member of (via `resolveActiveMemberOrgIds`), or that came\n * from a cryptographically-validated connection.\n *\n * This is the CANONICAL type for ANY per-user org used to ROUTE DATA to a tenant or to SCOPE a\n * resource read/query by tenant — not audit routing alone. Per-org audit dispatch already routes\n * ONLY on this brand; new data-routing / tenant-scoping surfaces should take `VerifiedOrgId` too, so\n * the untrusted email-domain→org guess (`session.organizationId` / `DomainOrgLookupResult.scopeId`)\n * can NEVER reach them without a deliberate, reviewable cast (routing the audit trail on that guess\n * was the 2026-07-09 cross-tenant leak).\n *\n * NOT for the SSO-ENFORCEMENT boundary: the domain-scoped SSO gates (e.g. `_checkSSOGraceLoginAllowed`)\n * legitimately key on the domain-ownership hint and must NOT be forced to take a membership org —\n * that is a different, fail-safe boundary by design.\n *\n * The brand is a COMPILE-TIME guard: a plain `string` / `string[]` cannot be passed where a\n * `VerifiedOrgId` is expected without a deliberate cast — which is the resolver's job\n * (`resolveActiveMemberOrgIds`), never a raw caller value.\n */\nexport type VerifiedOrgId = string & { readonly __brand: 'VerifiedOrgId' };\n\n/**\n * The event payload handed to an `AuditLogSink` — the persisted audit event\n * MINUS the DB primary key (`_id`), which is store-specific and not yet\n * assigned at fan-out time (the emit runs INDEPENDENTLY of, and possibly before,\n * the DB write completes). The store-agnostic `eventId` (see\n * `AuditableEvent.eventId`) IS present and is the stable cross-store correlation\n * key every sink should record — the same id the Phase-3 reconciler and\n * `AuditLogVerification.verifyAuditEvent` key on.\n *\n * A DEDICATED emission type (rather than the raw persisted `AuditableEvent`)\n * mirrors `AgentCallTraceEmission`: the write path never has a DB `_id` to give,\n * so the contract must not demand one — and sinks can gain fields here without a\n * signature change at every call site.\n */\nexport type AuditLogEventEmission = Omit<AuditableEvent, '_id'>;\n\n/**\n * `AuditLogSink` — a destination for compliance audit events (the FAN_OUT\n * side of `EngineCapability.COMPLIANCE_AUDIT_TRAIL`). One sink per provider\n * (immudb, a SIEM webhook, …); the engine's composite fans EVERY event out to\n * EVERY declared sink, layered on the always-on database audit store.\n *\n * The interface lives in `saas-models` so the engine + apps depend on the\n * contract without importing any provider SDK (the dependency-cycle break,\n * mirroring `AgentCallTraceSink`).\n *\n * DELIVERY CONTRACT — deliberately STRONGER than the best-effort, sampled,\n * droppable `AgentCallTraceSink`; mirror that sink's WIRING (lazy resolution,\n * DI, never-throw) but NOT its guarantees:\n * - **At-least-once + unsampled** — every event must reach every sink; no\n *   sampling, no drop-on-load. A sink that forwards asynchronously owns its own\n *   durable buffering + retry.\n * - **Immutable / append-only** — a sink never updates or deletes a recorded\n *   event.\n * - **Non-blocking** — the engine calls sinks fire-and-forget; a sink failure\n *   is isolated + observable, never thrown onto the business-op path.\n *   Completeness vs the authoritative DB store is the provider's reconciliation\n *   concern, not the caller's.\n */\nexport interface AuditLogSink {\n  /**\n   * Record one audit event to this destination, honoring the delivery contract\n   * above. Resolves when the event is durably accepted by the sink's own\n   * buffering — not necessarily when persisted at the far end.\n   *\n   * MUST NOT throw synchronously NOR return a rejecting promise — buffer-and-\n   * return. The engine's composite isolates each sink, but that isolation is a\n   * backstop, not a licence: a sink that rejects here still breaks the contract,\n   * and any future direct (non-composite) caller would inherit an unhandled\n   * rejection on the audit path.\n   */\n  recordAuditEvent(event: AuditLogEventEmission): void | Promise<void>;\n  /**\n   * Optional flush/cleanup, best-effort on host shutdown. A sink that batches\n   * asynchronously MUST drain here so short-lived hosts (minion/worker) don't\n   * lose queued events.\n   */\n  shutdown?(): void | Promise<void>;\n}\n\n/**\n * Outcome of an `AuditLogVerification.verifyAuditEvent` check.\n *\n * Distinguishes the two very different `verified: false` cases an external auditor must NOT\n * conflate — an event that was never recorded at the destination vs. one that WAS recorded but whose\n * cryptographic proof now fails (the actual tamper signal). The prior contract collapsed both into a\n * bare boolean + free-text `detail`, so a tampered entry was indistinguishable from a missing one.\n */\nexport enum AuditLogVerificationStatus {\n  /** Present AND its cryptographic proof verified — genuinely untampered. */\n  Verified = 'verified',\n  /** Not present at the destination (never recorded, or the reconciler has not caught up). NOT a tamper. */\n  Absent = 'absent',\n  /** Present but the proof FAILED — the entry was altered since it was written. The tamper signal. */\n  Tampered = 'tampered',\n  /** Could not be determined (store unreachable / no proof obtainable) — neither confirmed nor refuted. */\n  Unverifiable = 'unverifiable',\n}\n\n/**\n * Result of an `AuditLogVerification` proof check. `verified` is retained as the fast boolean\n * (`status === Verified`); `status` is the discriminator auditors branch on (absent vs tampered vs\n * unverifiable) — a tamper must never read the same as a not-yet-recorded event.\n */\nexport interface AuditLogVerificationResult {\n  verified: boolean;\n  /** Discriminated outcome — the authoritative field; `verified` is `status === Verified`. */\n  status: AuditLogVerificationStatus;\n  /** Technology-specific proof detail (e.g. immudb tx id + inclusion proof). */\n  detail?: string;\n}\n\n/**\n * Optional, technology-aware verification a provider MAY expose when its store\n * supports cryptographic proofs (e.g. immudb inclusion/consistency proofs).\n *\n * Day-to-day the audit pipeline is WRITE-ONLY; verification is an\n * external-auditor concern, resolved separately from the write path. This\n * contract is reserved in Phase 1 and implemented for immudb in Phase 5 —\n * providers whose technology cannot prove non-tampering simply don't expose it.\n */\nexport interface AuditLogVerification {\n  /**\n   * Verify a previously-recorded event is present + untampered at the\n   * destination, returning the technology's proof result.\n   */\n  verifyAuditEvent(eventId: string): Promise<AuditLogVerificationResult>;\n}\n\n/**\n * Optional capability a sink exposes when it can persist the completeness reconciler's\n * high-water mark IN ITS OWN store (e.g. immudb under a reserved key) — so the reconciler\n * needs no separate state resource and no `AUDIT_LOGS` schema change. A sink whose\n * technology can't hold a cursor (a fire-and-forget SIEM webhook) simply doesn't\n * implement it, and the reconciler falls back to a bounded windowed replay.\n *\n * The mark is an opaque, monotonic cursor the reconciler defines (today: the ISO\n * `createdAt` of the last event confirmed synced); the store round-trips it verbatim.\n * The reconciler pairs this with an IDEMPOTENT `AuditLogSink.recordAuditEvent`\n * (write-if-absent) so replaying an already-synced event is a no-op.\n */\nexport interface AuditReconcileCheckpointStore {\n  /** The last persisted high-water mark, or `null` when the reconciler has never run (or the store is unreachable). */\n  getAuditReconcileCheckpoint(): Promise<string | null>;\n  /** Persist the high-water mark after a reconcile batch is confirmed in the store. */\n  setAuditReconcileCheckpoint(mark: string): Promise<void>;\n}\n"]}

package/dist/esm/compliance/audit-trails/audit-logs.shared.resources-config.schemas.d.ts

@@ -1,43 +1,87 @@
 import { z } from 'zod';
-import { AuditEventCategory, AuditEventSeverity } from './auditable-events.shared.schema.js';
-import { CoreResourceOperation } from '../../resources/resources.shared.core.definitions.js';
-import { ResourceOperationRiskLevel, ResourceRelationship } from '../../resources/resources.shared.schemas.js';
+import { AuditEventCategory, AuditEventSeverity } from './auditable-events.shared.schema';
+import { CoreResourceOperation } from '../../resources/resources.shared.core.definitions';
+import { ResourceOperationRiskLevel, ResourceRelationship } from '../../resources/resources.shared.schemas';
 export declare enum AuditLogs_Operations {
     EXPORT_AUDIT_LOGS = "exportAuditLogs"
 }
 export declare const AuditLogs_ExportRequestDto: z.ZodObject<{
-    format: z.ZodDefault<z.ZodEnum<{
-        json: "json";
-        csv: "csv";
-    }>>;
     eventType: z.ZodOptional<z.ZodString>;
     eventCategory: z.ZodOptional<z.ZodEnum<typeof AuditEventCategory>>;
     severity: z.ZodOptional<z.ZodEnum<typeof AuditEventSeverity>>;
     userId: z.ZodOptional<z.ZodString>;
-    organizationId: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodOptional<z.ZodObject<{
         startDate: z.ZodOptional<z.ZodDate>;
         endDate: z.ZodOptional<z.ZodDate>;
-    }, z.core.$strip, core.$ZodObjectExtra>>;
-    maxRecords: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip, core.$ZodObjectExtra>;
+    }, z.core.$strip>>;
+    maxRecords: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
 export type AuditLogs_ExportRequestDtoType = z.infer<typeof AuditLogs_ExportRequestDto>;
+/**
+ * The named runtime source for the audit-log export-format vocabulary.
+ *
+ * Single-member on purpose, and deliberately NOT `ResourceCollectionExportFormat` (which also
+ * carries `JSON`): that enum governs listing/collection exports with their CSV option and
+ * content-type/extension tables, while this one names what the SYNCHRONOUS audit-log export
+ * operation can return — a JSON window in the HTTP 200 response, nothing else. Merging them
+ * because the wire value overlaps would silently grant this operation every format the
+ * collection-export vocabulary ever gains. A future archival/export delivery mechanism must
+ * introduce its own request and response contract (and its own members here) rather than
+ * extending this one implicitly.
+ */
+export declare enum AuditLogs_ExportFormat {
+    JSON = "json"
+}
+/**
+ * The complete synchronous audit-log export payload.
+ *
+ * There is deliberately no CSV option, download URL, or asynchronous job
+ * handle here — see {@link AuditLogs_ExportFormat} for why the format
+ * vocabulary is closed at JSON.
+ */
+export declare const AuditLogs_ExportResponseDto: z.ZodObject<{
+    records: z.ZodArray<z.ZodObject<{
+        _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+        eventId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+        userId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+        organizationId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+        applicationId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+        correlationId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+        frontendServiceName: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+        clientInstanceId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+        riskLevel: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ResourceOperationRiskLevel>>;
+        eventType: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+        eventData: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        eventCategory: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof AuditEventCategory>>;
+        severity: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof AuditEventSeverity>>;
+        createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>>;
+        updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
+    }, z.core.$strip>>;
+    format: z.ZodLiteral<AuditLogs_ExportFormat>;
+    totalCount: z.ZodNumber;
+}, z.core.$strict>;
+export type AuditLogs_ExportResponseDtoType = z.infer<typeof AuditLogs_ExportResponseDto>;
 /**
  * Audit Logs Resource Configuration
  * - REPOSITORY_ONLY CREATE for internal writes
  * - API_CALL READ/LIST for org members and app admins (enables frontend routes)
- * - EXPORT_AUDIT_LOGS custom operation for streaming export
+ * - EXPORT_AUDIT_LOGS custom operation for bounded synchronous JSON retrieval
  */
-export declare const auditLogsResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => import("../../index.js").ResourceConfiguration<typeof AuditLogs_Operations, CoreResourceOperation.READ | CoreResourceOperation.CREATE | CoreResourceOperation.LIST | CoreResourceOperation.SEARCH, z.ZodObject<{
+export declare const auditLogsResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => import("../..").ResourceConfiguration<typeof AuditLogs_Operations, CoreResourceOperation.READ | CoreResourceOperation.CREATE | CoreResourceOperation.LIST | CoreResourceOperation.SEARCH, z.ZodObject<{
     _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    eventId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
     userId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
     organizationId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    applicationId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    correlationId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    frontendServiceName: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    clientInstanceId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
     riskLevel: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ResourceOperationRiskLevel>>;
-    eventType: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    eventData: z.ZodRecord<z.ZodString, z.ZodAny>;
+    eventType: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    eventData: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodRecord<z.ZodString, z.ZodAny>>;
     eventCategory: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof AuditEventCategory>>;
     severity: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof AuditEventSeverity>>;
     createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>>;
     updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
-}, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip>>;
 //# sourceMappingURL=audit-logs.shared.resources-config.schemas.d.ts.map

package/dist/esm/compliance/audit-trails/audit-logs.shared.resources-config.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audit-logs.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../../src/compliance/audit-trails/audit-logs.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAA6B,MAAM,kCAAkC,CAAC;AAErH,OAAO,EAAE,qBAAqB,EAAwD,MAAM,mDAAmD,CAAC;AAChJ,OAAO,EACL,0BAA0B,EAE1B,oBAAoB,EAGrB,MAAM,0CAA0C,CAAC;AAMlD,oBAAY,oBAAoB;IAC9B,iBAAiB,oBAAoB;CACtC;AAID,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;uCASrC,CAAC;AAEH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAOxF;;;;;GAKG;AACH,eAAO,MAAM,oDAAoD,GAC/D,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;wCAyG9C,CAAC"}
+{"version":3,"file":"audit-logs.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/compliance/audit-trails/audit-logs.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAA6B,MAAM,kCAAkC,CAAC;AAErH,OAAO,EAAE,qBAAqB,EAAwD,MAAM,mDAAmD,CAAC;AAChJ,OAAO,EACL,0BAA0B,EAE1B,oBAAoB,EAErB,MAAM,0CAA0C,CAAC;AAOlD,oBAAY,oBAAoB;IAC9B,iBAAiB,oBAAoB;CACtC;AAID,eAAO,MAAM,0BAA0B;;;;;;;;;;kBAa5B,CAAC;AAEZ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAExF;;;;;;;;;;;GAWG;AACH,oBAAY,sBAAsB;IAChC,IAAI,SAAS;CACd;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;kBAI7B,CAAC;AAEZ,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAO1F;;;;;GAKG;AACH,eAAO,MAAM,oDAAoD,GAC/D,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;kBA4I9C,CAAC"}