@wildo-ai/saas-models 1.1.5 → 1.1.7

package/dist/esm/external-data/external-data-pipeline.shared.schemas.d.ts

@@ -14,16 +14,62 @@
  * these members, and the paper's ledger rows (PR-…) are cited per surface.
  */
 import { z } from 'zod';
+import { HttpApiWriteConcurrencyMode, HttpApiWriteVerb } from '../http-api-binding/http-api-binding.shared.schemas';
 import { HttpApiTransportDialect } from '../http-api-binding/http-api-transport-dialect.shared';
+import { HttpApiErasureStance } from '../http-api-binding/http-api-erasure-stance.shared';
+import { ExternalDataConflictPolicy } from './external-data-pipeline-pass-mode.shared';
 /**
- * Pipeline direction (PR-19). A SINGLE-member enum on purpose: reverse ETL (local→remote) and
- * bidirectional sync belong to the outbound-writes gate (ETL plan Step 5, concurrency contract),
- * but the DECLARATION is direction-extensible NOW so those arrive as new members instead of a
- * schema reshape — the immutability-needs-a-paired-path lesson applied to a vocabulary.
+ * Pipeline direction (PR-19). Declared per pipeline; `INBOUND` when omitted.
+ *
+ * The vocabulary was single-member until the write path (#1679) existed, so reverse ETL arrived as a new member
+ * rather than a schema reshape. Keeping one row correct when BOTH sides change it is a third member, with its own
+ * conflict policy (#1723) — neither of these two decides a conflict.
  */
 /** @wildo_source:part:start saas.models.external-data-pipeline facet:layer:shared facet:audience:app-developer */
 export declare enum ExternalDataPipelineDirection {
-    INBOUND = "inbound"
+    /**
+     * The system of record is the source: a pass reads its rows and loads them into the destination. The mapped fields
+     * are remote-authoritative, so callers may not write them.
+     */
+    INBOUND = "inbound",
+    /**
+     * The destination is the source (#1690): a row created or changed locally is sent to the system of record on the
+     * next pass — created there when it has no remote key yet, updated when it has one. The mapped fields are the
+     * application's own, so callers write them; the remote key is written by the engine, once, from the create's answer.
+     *
+     * Only rows of the organization that owns the application are ever sent (a system of record belongs to it alone),
+     * and on a partitioned instance only rows whose organization unit is assigned to a partition. A local DELETE is not
+     * sent: a system of record keeps its own records, and removing one is its operator's decision, not a side effect of
+     * a local edit.
+     */
+    OUTBOUND = "outbound",
+    /**
+     * Both sides change the row (#1723): a pass LOADS what the system of record changed and SENDS what the application
+     * changed, field by field, as each mapping entry's `owner` declares — REMOTE fields are loaded and read-only locally,
+     * LOCAL fields are sent and never loaded, BOTH fields are loaded AND sent. A row whose BOTH fields changed on both
+     * sides since they last agreed is a CONFLICT, decided by the declared `conflictPolicy`.
+     *
+     * "Since they last agreed" is the system of record's own row version (Odoo `write_date`, an OData entity tag), kept
+     * per row by the engine — so the direction is legal only on an instance whose vendor declares one. A local DELETE is
+     * not sent, as on OUTBOUND.
+     */
+    BIDIRECTIONAL = "bidirectional"
+}
+/**
+ * Which side OWNS a mapped field of a BIDIRECTIONAL pipeline (#1723). Declared on each `REMOTE_FIELD` / `REMOTE_REFERENCE`
+ * entry as `owner`, and refused on any other direction (an INBOUND pipeline's fields are all the system of record's, an
+ * OUTBOUND pipeline's all the application's).
+ *
+ * Only BOTH fields can conflict, which keeps the common case — remote master data plus a few locally-owned fields —
+ * out of conflict handling entirely.
+ */
+export declare enum ExternalDataFieldOwner {
+    /** The system of record's: loaded, read-only for callers, never sent. The default when `owner` is omitted. */
+    REMOTE = "remote",
+    /** The application's: written by callers, sent, never loaded. */
+    LOCAL = "local",
+    /** Both sides': written by callers AND loaded, sent AND read back — the only kind of field that can conflict. */
+    BOTH = "both"
 }
 /**
  * Who owns the destination's row population (D-P8, v3.1 §1).
@@ -65,17 +111,153 @@ export declare enum ExternalDataOrphanPolicy {
     /** Touch nothing; surface the diff in the run ledger. The DEFAULT — least surprise. */
     REPORT = "report"
 }
-/** The two shapes a mapping entry can take — a closed discriminator, never inferred from keys. */
+/**
+ * The shapes a mapping entry can take — a closed discriminator, never inferred from keys.
+ *
+ * ## The DECLARED EXPRESSIONS (#1685), and the open function slot they replace
+ *
+ * `ENUM_MAP`, `CONCATENATION`, `ARITHMETIC` and `CONDITIONAL` derive a local value from remote values. They are
+ * the first of the T's recorded widenings (D-P4: computed transforms, then multi-source joins, then transforms
+ * authored by the app-creation lane's agents) and they are DATA: every one names the remote fields it reads, the
+ * local field it writes, and a closed operation with declared constants. Nothing in them executes code the
+ * declaration does not show, so each is checked at startup against the destination schema (target type, enum
+ * membership, absence) and requested by the extraction like any mapped field.
+ *
+ * An open function slot (`transform: (row) => value`) is refused on purpose: it would put arbitrary code inside the
+ * load with no declaration anyone can review, validate or fingerprint. A derivation beyond these four stays a
+ * pre-load step in the application's own code, run by its own job.
+ */
 export declare enum ExternalDataMappingEntryKind {
     /** Copy (and coerce) one remote field into one local field. */
     REMOTE_FIELD = "remote-field",
     /** Fill one local field with a declared constant (destination-required fields with no remote source). */
-    CONSTANT = "constant"
+    CONSTANT = "constant",
+    /**
+     * Turn a remote REFERENCE into a real local foreign key (#1684) — an Odoo many2one (`parent_id`,
+     * `partner_id`), an OData navigation key. The remote value names a row of ANOTHER remote entity (or of
+     * the same one); the pipeline writes the local foreign key to that row's LOCAL copy, never the remote
+     * id. See {@link ExternalDataRemoteReferenceMappingEntrySchema}.
+     */
+    REMOTE_REFERENCE = "remote-reference",
+    /**
+     * Map a remote CODE onto a member of a local enum (#1685) — an Odoo selection (`draft`/`posted`), a vendor status
+     * code. Every mapped code is declared; a code the declaration does not name either rejects the row or lands a
+     * declared default. See {@link ExternalDataEnumMappingEntrySchema}.
+     */
+    ENUM_MAP = "enum-map",
+    /**
+     * Join remote fields and literals into one local string (#1685) — a display name from a first and a last name.
+     * See {@link ExternalDataConcatenationMappingEntrySchema}.
+     */
+    CONCATENATION = "concatenation",
+    /**
+     * `remote × factor + offset` on one numeric remote field (#1685) — a unit conversion, or a currency conversion at
+     * a DECLARED constant rate. See {@link ExternalDataArithmeticMappingEntrySchema}.
+     */
+    ARITHMETIC = "arithmetic",
+    /**
+     * Choose the local value by ONE remote field's value (#1685): a list of cases, each an exact value, and an
+     * `otherwise`. See {@link ExternalDataConditionalMappingEntrySchema}.
+     */
+    CONDITIONAL = "conditional"
+}
+/**
+ * The mapping entry kinds an OUTBOUND pipeline may declare (#1690): a local field sent as one remote field, and a local
+ * foreign key sent as the target row's REMOTE key. The declared expressions (#1685) derive one local value from remote
+ * ones and have no inverse — a concatenation cannot be split back into its parts — and a CONSTANT names no remote field.
+ */
+export declare const EXTERNAL_DATA_OUTBOUND_MAPPING_ENTRY_KINDS: ReadonlySet<ExternalDataMappingEntryKind>;
+/**
+ * The write verbs an OUTBOUND pipeline may open on its binding (#1690): a create for a row with no remote key yet, and
+ * an update for one that has one. DELETE is not among them — see {@link ExternalDataPipelineDirection.OUTBOUND}.
+ */
+export declare const EXTERNAL_DATA_OUTBOUND_WRITE_VERBS: ReadonlySet<HttpApiWriteVerb>;
+/**
+ * What an `ENUM_MAP` does with a remote code its declaration does not name (#1685).
+ */
+export declare enum ExternalDataUnmappedValuePolicy {
+    /**
+     * The DEFAULT. The row is REJECTED and reported, and its previous local version survives. A vendor that adds a
+     * code is then visible on the next run's report instead of being folded silently into some other member.
+     */
+    REJECT_ROW = "reject-row",
+    /** The row lands the declared `localValue`. Choose it only where every future code genuinely means the same thing. */
+    USE_DEFAULT = "use-default"
+}
+/** The two things a `CONCATENATION` part can be (#1685). */
+export declare enum ExternalDataConcatenationPartKind {
+    /** The value of one remote field. An absent or empty value drops the part. */
+    REMOTE_FIELD = "remote-field",
+    /** A declared literal, written as-is. */
+    LITERAL = "literal"
+}
+/** The two things a `CONDITIONAL` outcome can be (#1685). */
+export declare enum ExternalDataConditionalOutcomeKind {
+    /** A declared constant, checked against the local field's type at startup. */
+    CONSTANT = "constant",
+    /** Another remote field's value, copied as a `REMOTE_FIELD` entry copies it. */
+    REMOTE_FIELD = "remote-field"
+}
+/**
+ * How a REMOTE_REFERENCE's remote value becomes the target's key (#1684). A closed vocabulary, one
+ * member per wire shape, because the shapes differ in kind and guessing between them silently resolves
+ * nothing.
+ */
+export declare enum ExternalDataRemoteReferenceValueShape {
+    /**
+     * Odoo's many2one: `search_read` answers `[id, display_name]`, or `false` when the reference is empty.
+     * The key is the pair's FIRST element; the display name is ignored (it is a label, not an identity).
+     * spec-cite: Odoo 18.0 developer reference, External API — "Read records" / "Search and read"
+     * (`odoo/documentation/18.0/content/developer/reference/external_api.rst`) — a many2one reads as
+     * `[21, 'Belgium']`; `false` for an unset one is the ORM's null spelling (measured shape recorded on the
+     * provider simulator, `odoo-jsonrpc-mock.ts`).
+     */
+    ODOO_MANY2ONE = "odoo-many2one",
+    /**
+     * The remote value IS the target's key component, as a plain scalar — an OData navigation property's
+     * foreign-key field (`ParentAccountID`), a REST id column. `null` or an empty string is an empty reference.
+     */
+    SCALAR = "scalar"
+}
+/**
+ * What a run does with a reference whose target has no local row yet (#1684).
+ *
+ * Resolution happens AFTER the load, in its own phase, so a reference to a row loaded by the same run —
+ * including a child extracted before its parent, and a self-reference — always resolves. What remains
+ * "unresolved" is a target the destination does not hold at all: outside the pipeline's `sourceFilter`,
+ * in a partition nobody assigned, not yet loaded by the target's own pipeline.
+ */
+export declare enum ExternalDataUnresolvedReferencePolicy {
+    /**
+     * The DEFAULT. The row loads with the foreign key EMPTY, and the reference is kept in the pipeline's
+     * pending-resolution set. The set is retried at the end of EVERY later run of the pipeline, incremental
+     * ones included — which is the only way such a row is ever resolved under incremental extraction (#1682),
+     * because a child that did not change is never re-read. Counted on every run's report and summary.
+     */
+    LEAVE_PENDING = "leave-pending",
+    /**
+     * The row is REJECTED (reported per row; its previous local version survives) when its target is not
+     * already loaded and not among the rows of the same PAGE — a run loads page by page (#1689), so a target
+     * on a LATER page of the same run is not loaded yet. It is retried only when the row is extracted again
+     * — every full pass, or an incremental pass after it changes — and a pass that reads parents before their
+     * children never meets the case. For a self-referencing entity whose source order you do not control,
+     * `LEAVE_PENDING` resolves the link at the end of the same run instead. A reference to a VIRTUAL (read-through)
+     * target never rejects: its key is its local id, and there is nothing local to be missing.
+     *
+     * The check runs BEFORE the load, against the target as it stands then. A self-referenced target that the same
+     * full pass's orphan walk deletes (`orphanPolicy: DELETE`) saved the row from rejection and is then gone, so that
+     * row loads with its foreign key empty and pending — the one case this policy cannot rule out.
+     */
+    REJECT_ROW = "reject-row"
 }
 /**
  * Built-in, closed coercion vocabulary for REMOTE_FIELD entries (v3.1 §3 / PR-8). Slice 1 ships
- * exactly the coercions the two generic dialects force; arbitrary transforms are the recorded
- * widenings (W-FK resolution, W-AGENT authored transforms) — never an open function slot here.
+ * exactly the coercions the two generic dialects force. A value COMPUTED from remote fields is one of
+ * the declared expressions (#1685 — D-P4's first widening: `ENUM_MAP`, `CONCATENATION`, `ARITHMETIC`,
+ * `CONDITIONAL`), and transforms authored by the app-creation lane's agents remain a recorded widening
+ * (W-AGENT) — never an open function slot here. Foreign-key resolution,
+ * once recorded as the W-FK widening beside it, is not a coercion at all: it is its own entry kind,
+ * {@link ExternalDataMappingEntryKind.REMOTE_REFERENCE} (#1684).
  */
 export declare enum ExternalDataFieldCoercion {
     /** Value lands as extracted (after the destination schema's own Zod parse). */
@@ -89,20 +271,492 @@ export declare enum ExternalDataFieldCoercion {
     /** Parse a strict-ISO datetime string into a Date for a date-typed local field. */
     ISO_STRING_TO_DATE = "iso-string-to-date"
 }
-/** One declared T-step: remote field → local field with a built-in coercion, or a constant. */
+/**
+ * What a pipeline does with a remote row its source has ARCHIVED rather than deleted (#1732).
+ *
+ * ## Why this exists: archived is not deleted, and absence reads as deletion
+ *
+ * Odoo archives a record by setting its `active` field to `false`, and an archived record is then
+ * "invisible in most searches and listing" — a plain `search_read` leaves it out, exactly as if it
+ * had been deleted.
+ * spec-cite: Odoo 17.0 ORM API reference, "Reserved Field names" → `Model.active`
+ * (https://www.odoo.com/documentation/17.0/developer/reference/backend/orm.html).
+ *
+ * A pipeline's orphan walk reads "absent from a complete pass" as "deleted remotely", so an extraction
+ * that inherited Odoo's default visibility turned every archive into a deletion: `REPORT` reported
+ * it, `DEPRECATE` deprecated it, and `DELETE` hard-deleted the local row together with its local
+ * extension fields, files and RAG chunks. Un-archiving later re-created a bare row.
+ *
+ * So extraction ALWAYS asks Odoo for archived rows too (the `active_test: false` context), and an
+ * archived row is always OBSERVED — present in the source, never an orphan. What remains a choice is
+ * only whether it is LOADED, and that is this vocabulary. Every member keeps the row observed; no
+ * member can turn an archive into a deletion.
+ *
+ * Declared on Odoo sources only (`archivedRecords`); an OData source has no protocol-level archive
+ * state, and the declaration coherence refuses the field there.
+ */
+export declare enum ExternalDataArchivedRecordTreatment {
+    /**
+     * The DEFAULT. An archived row is loaded like any other row. Map the source's archive flag
+     * (`active` on most Odoo models) onto a local boolean like any other field, and the destination can
+     * show or filter archived rows — and an un-archive changes exactly that one value.
+     */
+    LOAD = "load",
+    /**
+     * An archived row is NOT loaded, but still counts as observed, so it is never an orphan — the same
+     * treatment rows of an unassigned partition get. A local row loaded while the record was live KEEPS
+     * its last loaded version (it is neither updated nor deleted) until the record is un-archived.
+     * Choose it to keep archived records out of a destination that never held them; choose `LOAD` with
+     * the flag mapped when the destination must reflect archival.
+     */
+    EXCLUDE_FROM_LOAD = "exclude-from-load"
+}
+/**
+ * A REMOTE_REFERENCE mapping entry (#1684): a remote reference field written as a real LOCAL foreign key.
+ *
+ * ## What the local field holds
+ *
+ * - a target that is another PIPELINE destination on the same system of record (or this one — a
+ *   self-reference such as Odoo `res.partner.parent_id`): the target's local row id, found by synthesizing
+ *   the target's key with THE TARGET BINDING's key codec and looking it up on the target's
+ *   `remoteKeyLocalField`;
+ * - a target that is a VIRTUAL (read-through) resource bound to the same system of record: the synthesized
+ *   key itself — a virtual row's `_id` IS that value, so nothing is looked up.
+ *
+ * ## When it is written
+ *
+ * After the load, in its own phase — never inside the row transform. So a child extracted before its
+ * parent, a self-reference, and a cycle between two pipelines all resolve without ordering anything. The
+ * resolution phase is the ONLY writer of the local field: the load never touches it, which is why the field
+ * is left out of the load's managed fields.
+ *
+ * ## What the declaration owes (checked at authoring and at startup)
+ *
+ * - `localField` is the foreign key of a declared relationship between this resource and `targetResourceType`,
+ *   a STRING field that accepts absence (an unresolved reference leaves it empty), and — like every
+ *   pipeline-written field — `.excludeFromCreate().excludeFromUpdate()`;
+ * - the target is a pipeline destination or a virtual resource on THIS pipeline's system of record, keyed by
+ *   ONE key field (a composite target key is a recorded widening);
+ * - when the target's orphan policy DELETES rows and the relationship tears children down with their parent,
+ *   `orphanCascadeAcknowledged: true` — a row vanishing from the target's source would otherwise take this
+ *   resource's rows with it through the ordinary `onParentDelete` rules, and nothing about this declaration
+ *   says so unless the author does.
+ */
+export declare const ExternalDataRemoteReferenceMappingEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataMappingEntryKind.REMOTE_REFERENCE>;
+    /** The remote field carrying the reference (`parent_id` on Odoo `res.partner`). */
+    remoteField: z.ZodString;
+    /** The local foreign-key field the resolved reference is written to. */
+    localField: z.ZodString;
+    /** The LOCAL resource the reference resolves to — a pipeline destination or a virtual resource. */
+    targetResourceType: z.ZodString;
+    /**
+     * How the remote value becomes the target's key. Absent = resolved at AUTHORING from the source dialect:
+     * `ODOO_MANY2ONE` on an Odoo source, `SCALAR` otherwise — the resource factory writes the resolved value
+     * into the declaration, exactly as it resolves the Odoo absent-as-false coercion.
+     */
+    valueShape: z.ZodOptional<z.ZodEnum<typeof ExternalDataRemoteReferenceValueShape>>;
+    unresolved: z.ZodDefault<z.ZodEnum<typeof ExternalDataUnresolvedReferencePolicy>>;
+    /**
+     * The author has read that the target's `orphanPolicy: DELETE` will cascade into this resource's rows
+     * through the relationship's `onParentDelete` teardown, and wants that. Only meaningful — and only
+     * demanded — when both are true; see the schema's header.
+     */
+    orphanCascadeAcknowledged: z.ZodDefault<z.ZodBoolean>;
+    /** Which side owns the reference — BIDIRECTIONAL pipelines only (#1723). Absent = REMOTE. */
+    owner: z.ZodOptional<z.ZodEnum<typeof ExternalDataFieldOwner>>;
+}, z.core.$strict>;
+export type ExternalDataRemoteReferenceMappingEntry = z.infer<typeof ExternalDataRemoteReferenceMappingEntrySchema>;
+/**
+ * An `ENUM_MAP` entry (#1685): one remote code → one member of the local field's enum.
+ *
+ * - the local field is an ENUM, and every declared `localValue` (and the default's) is one of its members — checked
+ *   at startup, so a renamed member fails the boot rather than every row;
+ * - an ABSENT remote value (the field unset: `null`, missing, or Odoo's `false` when `false` is not itself a declared
+ *   code) lands null, or rejects the row when `required`;
+ * - a PRESENT code the declaration does not name follows `unmapped`: rejected by default, or the declared member.
+ */
+export declare const ExternalDataEnumMappingEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataMappingEntryKind.ENUM_MAP>;
+    /** The remote field carrying the code (`state` on Odoo `account.move`). */
+    remoteField: z.ZodString;
+    localField: z.ZodString;
+    /** Every code the declaration maps, each to one member of the local enum. Codes are unique. */
+    values: z.ZodArray<z.ZodObject<{
+        remoteValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        localValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strict>>;
+    /** A PRESENT code no `values` entry names. Absent = reject the row. */
+    unmapped: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        policy: z.ZodLiteral<ExternalDataUnmappedValuePolicy.REJECT_ROW>;
+    }, z.core.$strict>, z.ZodObject<{
+        policy: z.ZodLiteral<ExternalDataUnmappedValuePolicy.USE_DEFAULT>;
+        localValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strict>], "policy">>;
+    /** `true`: a row whose remote code is ABSENT is rejected. `false` (default): absence lands null. */
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ExternalDataEnumMappingEntry = z.infer<typeof ExternalDataEnumMappingEntrySchema>;
+/**
+ * A `CONCATENATION` entry (#1685): remote fields and literals joined into one local STRING.
+ *
+ * Every part with a value is written, in order, joined by `separator`; a remote part whose value is absent or empty
+ * (`null`, missing, `''`, or Odoo's `false`) is DROPPED with its separator, the way SQL's `concat_ws` ignores a NULL
+ * argument — so `first` + `last` joined by a space yields `'Ada'`, never `'Ada '`, when the last name is unset. A
+ * number is written as JavaScript's shortest round-trip text (`42`, `12.5`; exponent notation only beyond `1e21` or
+ * below `1e-6`); any other value (a boolean off Odoo, a many2one pair) rejects the row.
+ *
+ * spec-cite: PostgreSQL 17 documentation, §9.4 "String Functions and Operators", `concat_ws` — "NULL arguments are
+ * ignored" (https://www.postgresql.org/docs/17/functions-string.html).
+ *
+ * When NO remote part has a value, the result is ABSENT — literals alone are decoration, not data — and lands null,
+ * or rejects the row when `required`.
+ */
+export declare const ExternalDataConcatenationMappingEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataMappingEntryKind.CONCATENATION>;
+    localField: z.ZodString;
+    /** At least two parts, at least one of them a remote field. */
+    parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataConcatenationPartKind.REMOTE_FIELD>;
+        remoteField: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataConcatenationPartKind.LITERAL>;
+        literal: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    /** Written between two parts that both have a value. Default: nothing. */
+    separator: z.ZodDefault<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ExternalDataConcatenationMappingEntry = z.infer<typeof ExternalDataConcatenationMappingEntrySchema>;
+/**
+ * An `ARITHMETIC` entry (#1685): `remote × factor + offset` onto a local NUMBER.
+ *
+ * A currency conversion is legal only as a DECLARED rate (`factor`): a live exchange rate is a second source, which
+ * is a join, and joins are a later widening. The declaration is the rate's record, so changing it changes the
+ * pipeline's extraction fingerprint and an incremental pipeline re-reads every row under the new rate.
+ *
+ * The remote value is a finite number, or a string holding a plain decimal numeral (`'12.50'` — how OData v2 and
+ * several REST APIs serialize decimals). Anything else rejects the row. `decimalPlaces` rounds the RESULT half away
+ * from zero, in binary floating point: it keeps `0.1 × 3` from landing as `0.30000000000000004`, and it does not make
+ * the value exact — an amount that must be exact to the cent belongs in a type this expression does not produce.
+ */
+export declare const ExternalDataArithmeticMappingEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataMappingEntryKind.ARITHMETIC>;
+    remoteField: z.ZodString;
+    localField: z.ZodString;
+    /** Multiplier. Never 0 — a constant result is a `CONSTANT` entry. */
+    factor: z.ZodDefault<z.ZodNumber>;
+    /** Added after the multiplication. */
+    offset: z.ZodDefault<z.ZodNumber>;
+    /** Round the result to this many decimal places. Absent = no rounding. */
+    decimalPlaces: z.ZodOptional<z.ZodNumber>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ExternalDataArithmeticMappingEntry = z.infer<typeof ExternalDataArithmeticMappingEntrySchema>;
+/** What a `CONDITIONAL` case (or its `otherwise`) writes (#1685). */
+declare const ExternalDataConditionalOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.CONSTANT>;
+    constant: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.REMOTE_FIELD>;
+    remoteField: z.ZodString;
+    /** As on a `REMOTE_FIELD` entry: Odoo's absent-as-false is resolved at authoring from the local field's type. */
+    coercion: z.ZodDefault<z.ZodEnum<typeof ExternalDataFieldCoercion>>;
+}, z.core.$strict>], "kind">;
+export type ExternalDataConditionalOutcome = z.infer<typeof ExternalDataConditionalOutcomeSchema>;
+/**
+ * A `CONDITIONAL` entry (#1685): the local value chosen by ONE remote field's value.
+ *
+ * The cases are tried in order and the first whose `equals` is exactly (`===`) the remote value wins; no case
+ * matching — an absent value included — takes `otherwise`. On an Odoo source an unset field reads `false`, so a declared
+ * `equals: false` case catches it before `otherwise` does. An outcome is a constant (checked against the local
+ * field's type, and against its members when it is an enum) or another remote field's value. Conditions over two
+ * fields, ranges and patterns are not part of the set: they are exactly what makes an expression language grow into
+ * the open function slot this set exists to avoid.
+ */
+export declare const ExternalDataConditionalMappingEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataMappingEntryKind.CONDITIONAL>;
+    /** The remote field whose value decides. */
+    remoteField: z.ZodString;
+    localField: z.ZodString;
+    cases: z.ZodArray<z.ZodObject<{
+        equals: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        then: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.CONSTANT>;
+            constant: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.REMOTE_FIELD>;
+            remoteField: z.ZodString;
+            /** As on a `REMOTE_FIELD` entry: Odoo's absent-as-false is resolved at authoring from the local field's type. */
+            coercion: z.ZodDefault<z.ZodEnum<typeof ExternalDataFieldCoercion>>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+    otherwise: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.CONSTANT>;
+        constant: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.REMOTE_FIELD>;
+        remoteField: z.ZodString;
+        /** As on a `REMOTE_FIELD` entry: Odoo's absent-as-false is resolved at authoring from the local field's type. */
+        coercion: z.ZodDefault<z.ZodEnum<typeof ExternalDataFieldCoercion>>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type ExternalDataConditionalMappingEntry = z.infer<typeof ExternalDataConditionalMappingEntrySchema>;
+/**
+ * One declared T-step: remote field → local field with a built-in coercion, a constant, a resolved reference, or one
+ * of the four declared expressions (#1685).
+ *
+ * Every entry shape is STRICT: an unknown key is refused, not dropped. That is what makes the refusal of an open
+ * function slot real — `{ kind: 'remote-field', …, transform: (value) => … }` used to parse with `transform` silently
+ * stripped, a declaration that reads as if it ran code and runs none.
+ */
 export declare const ExternalDataFieldMappingEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<ExternalDataMappingEntryKind.REMOTE_FIELD>;
     remoteField: z.ZodString;
     localField: z.ZodString;
     coercion: z.ZodDefault<z.ZodEnum<typeof ExternalDataFieldCoercion>>;
+    /**
+     * `true`: a row whose extracted value is ABSENT is REJECTED (reported per row in the run
+     * ledger; its previous local version survives). `false` (default): absent lands as null,
+     * which the declaration coherence requires the local field to accept.
+     */
     required: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
+    /** Which side owns the field — BIDIRECTIONAL pipelines only (#1723). Absent = REMOTE. */
+    owner: z.ZodOptional<z.ZodEnum<typeof ExternalDataFieldOwner>>;
+}, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<ExternalDataMappingEntryKind.CONSTANT>;
     localField: z.ZodString;
     constant: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-}, z.core.$strip>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataMappingEntryKind.REMOTE_REFERENCE>;
+    /** The remote field carrying the reference (`parent_id` on Odoo `res.partner`). */
+    remoteField: z.ZodString;
+    /** The local foreign-key field the resolved reference is written to. */
+    localField: z.ZodString;
+    /** The LOCAL resource the reference resolves to — a pipeline destination or a virtual resource. */
+    targetResourceType: z.ZodString;
+    /**
+     * How the remote value becomes the target's key. Absent = resolved at AUTHORING from the source dialect:
+     * `ODOO_MANY2ONE` on an Odoo source, `SCALAR` otherwise — the resource factory writes the resolved value
+     * into the declaration, exactly as it resolves the Odoo absent-as-false coercion.
+     */
+    valueShape: z.ZodOptional<z.ZodEnum<typeof ExternalDataRemoteReferenceValueShape>>;
+    unresolved: z.ZodDefault<z.ZodEnum<typeof ExternalDataUnresolvedReferencePolicy>>;
+    /**
+     * The author has read that the target's `orphanPolicy: DELETE` will cascade into this resource's rows
+     * through the relationship's `onParentDelete` teardown, and wants that. Only meaningful — and only
+     * demanded — when both are true; see the schema's header.
+     */
+    orphanCascadeAcknowledged: z.ZodDefault<z.ZodBoolean>;
+    /** Which side owns the reference — BIDIRECTIONAL pipelines only (#1723). Absent = REMOTE. */
+    owner: z.ZodOptional<z.ZodEnum<typeof ExternalDataFieldOwner>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataMappingEntryKind.ENUM_MAP>;
+    /** The remote field carrying the code (`state` on Odoo `account.move`). */
+    remoteField: z.ZodString;
+    localField: z.ZodString;
+    /** Every code the declaration maps, each to one member of the local enum. Codes are unique. */
+    values: z.ZodArray<z.ZodObject<{
+        remoteValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        localValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strict>>;
+    /** A PRESENT code no `values` entry names. Absent = reject the row. */
+    unmapped: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        policy: z.ZodLiteral<ExternalDataUnmappedValuePolicy.REJECT_ROW>;
+    }, z.core.$strict>, z.ZodObject<{
+        policy: z.ZodLiteral<ExternalDataUnmappedValuePolicy.USE_DEFAULT>;
+        localValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strict>], "policy">>;
+    /** `true`: a row whose remote code is ABSENT is rejected. `false` (default): absence lands null. */
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataMappingEntryKind.CONCATENATION>;
+    localField: z.ZodString;
+    /** At least two parts, at least one of them a remote field. */
+    parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataConcatenationPartKind.REMOTE_FIELD>;
+        remoteField: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataConcatenationPartKind.LITERAL>;
+        literal: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    /** Written between two parts that both have a value. Default: nothing. */
+    separator: z.ZodDefault<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataMappingEntryKind.ARITHMETIC>;
+    remoteField: z.ZodString;
+    localField: z.ZodString;
+    /** Multiplier. Never 0 — a constant result is a `CONSTANT` entry. */
+    factor: z.ZodDefault<z.ZodNumber>;
+    /** Added after the multiplication. */
+    offset: z.ZodDefault<z.ZodNumber>;
+    /** Round the result to this many decimal places. Absent = no rounding. */
+    decimalPlaces: z.ZodOptional<z.ZodNumber>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<ExternalDataMappingEntryKind.CONDITIONAL>;
+    /** The remote field whose value decides. */
+    remoteField: z.ZodString;
+    localField: z.ZodString;
+    cases: z.ZodArray<z.ZodObject<{
+        equals: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        then: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.CONSTANT>;
+            constant: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.REMOTE_FIELD>;
+            remoteField: z.ZodString;
+            /** As on a `REMOTE_FIELD` entry: Odoo's absent-as-false is resolved at authoring from the local field's type. */
+            coercion: z.ZodDefault<z.ZodEnum<typeof ExternalDataFieldCoercion>>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+    otherwise: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.CONSTANT>;
+        constant: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.REMOTE_FIELD>;
+        remoteField: z.ZodString;
+        /** As on a `REMOTE_FIELD` entry: Odoo's absent-as-false is resolved at authoring from the local field's type. */
+        coercion: z.ZodDefault<z.ZodEnum<typeof ExternalDataFieldCoercion>>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">;
+/**
+ * HOW a source says what changed — one member per remote change-tracking mechanism (#1682).
+ *
+ * A closed vocabulary shared by two parties: a system-of-record VENDOR FACET declares which modes its
+ * deployments support (`incrementalExtractionModes`), and a pipeline declaration chooses one. A
+ * pipeline asking for a mode its source's facet does not declare is refused at startup, naming both.
+ *
+ * Three modes: Odoo's `write_date`, and the two OData v4 mechanisms (#1722) — a modified-at filter and
+ * the delta-link protocol. The incremental TRACK on the state row is mode-neutral (its watermark and
+ * cursor are opaque, mode-owned text), so a new mode needed no reshape of it.
+ */
+export declare enum ExternalDataIncrementalExtractionMode {
+    /**
+     * Odoo's `write_date` — the "Last Updated on" column the ORM maintains on every model that logs
+     * access. Read in (SECOND, id) order from a watermark, with a declared lookback. See
+     * {@link ExternalDataIncrementalExtractionDeclarationSchema}.
+     */
+    ODOO_WRITE_DATE = "odoo-write-date",
+    /**
+     * OData v4, a MODIFIED-AT property the declaration names (`modifiedAtRemoteField` — per entity, not per
+     * vendor: Dataverse's `modifiedon`, Business Central's `lastModifiedDateTime`). Rows with that property at
+     * or after the watermark (less the lookback) are read in KEY order, and the watermark moves only when the
+     * pass completes. Catches no deletions: full passes find those.
+     */
+    ODATA_MODIFIED_AT = "odata-modified-at",
+    /**
+     * OData v4 CHANGE TRACKING: the first pass asks for `Prefer: odata.track-changes` and keeps the service's
+     * `@odata.deltaLink`; every later pass follows it and receives changed entities AND deleted ones, so an
+     * incremental pass applies the orphan policy to each deleted key. The vendor must track changes for the
+     * entity set (Dataverse: per table).
+     */
+    ODATA_DELTA_LINK = "odata-delta-link"
+}
+/**
+ * `incremental` — read only what changed between full passes (#1682).
+ *
+ * ## What an incremental pass does, and what it never does
+ *
+ * - It reads the rows changed since the pipeline's WATERMARK — the largest remote position a previous
+ *   incremental pass actually LOADED, never the local clock (a local clock and a remote clock disagree,
+ *   and the gap is rows nobody reads).
+ * - The watermark advances only after the rows that reached it are loaded. A crash re-reads; it never
+ *   skips.
+ * - It NEVER detects deletions. A row deleted remotely does not "change", so no incremental read can
+ *   see it. Deletions are found by FULL passes only, on `fullPassCron` — which is why that cadence is
+ *   required rather than optional: an incremental-only pipeline would keep deleted rows forever.
+ * - It runs on the pipeline's `scheduleCron`, which is therefore required too.
+ *
+ * ## The Odoo mode — why (second, id), and why a lookback
+ *
+ * Odoo STORES `write_date` with microseconds (the writing transaction's `now()`) and SERVES it cut to
+ * the second, while a domain compares the stored value. Two obvious designs fail on that gap:
+ * `write_date > w` skips the rows that share the last row's second but did not fit on the page, and a
+ * keyset on the served `(write_date, id)` re-reads its own last row forever, because a row served as
+ * `10:00:00` is stored after `10:00:00`. The extraction therefore walks (SECOND, id): it finishes one
+ * second by id (`s <= write_date < s+1s AND id > i`, ordered by id), then finds the next rows from the
+ * following second. Every row is read once per pass, however many rows share a second.
+ * spec-cite: N/A — Odoo 17.0 SOURCE, not a document: `odoo/models.py`
+ * `vals.setdefault('write_date', self.env.cr.now())`, `odoo/sql_db.py` `Cursor.now`
+ * (`SELECT (now() AT TIME ZONE 'UTC')`), `odoo/fields.py` `Datetime.to_string` (`strftime`), and no
+ * `Datetime.convert_to_column` override (the base field stores the full value).
+ *
+ * The lookback re-reads the last `lookbackSeconds` of changes at the START of every incremental pass.
+ * Odoo stamps `write_date` when the writing transaction runs, not when it commits, so a long
+ * transaction can commit a row whose `write_date` is already older than a watermark another pass
+ * advanced past in the meantime; without a lookback that row is never read — and a transaction that
+ * commits later inside the watermark's own second is caught the same way. Re-reads are free where it
+ * matters: the load compares content and writes nothing for an unchanged row. UNVERIFIED against a
+ * live Odoo — the default is a margin, not a measurement; raise it for a deployment with long batch
+ * jobs. `0` is NOT a harmless setting: without a lookback, a row written later inside a second a pass
+ * has already finished is read only when it changes again (or by a full pass).
+ *
+ * ## Changing the declaration resets the incremental track
+ *
+ * An incremental pass never re-reads a row that did not change remotely, so a change to what is
+ * extracted or how it is loaded — the binding, key fields, mapping, `sourceFilter`, partition fields,
+ * archived-record treatment, or the operator's partition ASSIGNMENTS — would otherwise never reach the
+ * rows already loaded. The run fingerprints those inputs; a different fingerprint drops the watermark,
+ * and the next incremental pass reads the whole source again. The run summary says it did.
+ */
+export declare const ExternalDataIncrementalExtractionDeclarationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<ExternalDataIncrementalExtractionMode.ODOO_WRITE_DATE>;
+    fullPassCron: z.ZodString;
+    lookbackSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<ExternalDataIncrementalExtractionMode.ODATA_MODIFIED_AT>;
+    fullPassCron: z.ZodString;
+    modifiedAtRemoteField: z.ZodString;
+    lookbackSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<ExternalDataIncrementalExtractionMode.ODATA_DELTA_LINK>;
+    fullPassCron: z.ZodString;
+}, z.core.$strip>], "mode">;
+export type ExternalDataIncrementalExtractionDeclaration = z.infer<typeof ExternalDataIncrementalExtractionDeclarationSchema>;
+/**
+ * The dialect each incremental mode is spoken over. A `Record` over the enum so a mode added without
+ * its dialect is a compile error rather than a declaration the coherence check silently waves through.
+ */
+export declare const EXTERNAL_DATA_INCREMENTAL_MODE_DIALECT: Readonly<Record<ExternalDataIncrementalExtractionMode, HttpApiTransportDialect>>;
 /** @wildo_source:part:end saas.models.external-data-pipeline */
 export type ExternalDataFieldMappingEntry = z.infer<typeof ExternalDataFieldMappingEntrySchema>;
+/**
+ * Every remote field one mapping entry READS (#1685) — the one answer to that question, total over the entry kinds.
+ *
+ * The extraction requests exactly these (with the key fields and the archive flag), so a field an expression reads is
+ * never missing from `fields` / `$select` — and a field the remote does not have fails the request loudly instead of
+ * landing null on every row. The run's contract-drift probe checks the same list. A new kind that forgets to say what
+ * it reads is a compile error here, not an extraction that silently omits a field.
+ */
+export declare function listExternalDataMappingEntryRemoteFields(entry: ExternalDataFieldMappingEntry): readonly string[];
+/** Every remote field a pipeline's mapping reads, deduplicated, in declaration order (#1685). */
+export declare function listExternalDataMappingRemoteFields(mapping: readonly ExternalDataFieldMappingEntry[]): readonly string[];
+/**
+ * The value shape a REMOTE_REFERENCE is read with (#1684) — the declared one, or the source dialect's default:
+ * Odoo answers every many2one as a pair, every other dialect names a key as a scalar.
+ *
+ * The ONE place that default lives. The resource factory writes its answer into the declaration at authoring, and
+ * the transform asks the same function, so a declaration parsed without passing through the factory (a test, a
+ * tool) reads the same shape an application does.
+ */
+export declare function resolveExternalDataRemoteReferenceValueShape(entry: Pick<ExternalDataRemoteReferenceMappingEntry, 'valueShape'>, dialect: HttpApiTransportDialect): ExternalDataRemoteReferenceValueShape;
+/**
+ * `archivedRecords` — how an Odoo pipeline treats archived rows (#1732). Absent means
+ * {@link ExternalDataArchivedRecordTreatment.LOAD}.
+ *
+ * `EXCLUDE_FROM_LOAD` must read each row's archive flag, so it names the flag's REMOTE field; the
+ * extraction requests that field. `LOAD` reads nothing extra — a pipeline that wants the flag on the
+ * destination maps it, which is an ordinary mapping entry, not part of this declaration.
+ */
+export declare const ExternalDataArchivedRecordsDeclarationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    treatment: z.ZodLiteral<ExternalDataArchivedRecordTreatment.LOAD>;
+}, z.core.$strip>, z.ZodObject<{
+    treatment: z.ZodLiteral<ExternalDataArchivedRecordTreatment.EXCLUDE_FROM_LOAD>;
+    archiveFlagRemoteField: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>], "treatment">;
+export type ExternalDataArchivedRecordsDeclaration = z.infer<typeof ExternalDataArchivedRecordsDeclarationSchema>;
 /**
  * The inbound pipeline declaration an ordinary LOCAL resource carries as `externalDataPipeline`.
  *
@@ -125,11 +779,12 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
         fieldMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
             localField: z.ZodString;
             remoteField: z.ZodString;
+            temporalKind: z.ZodOptional<z.ZodEnum<typeof import("../external-data.exports").HttpApiRemoteTemporalKind>>;
         }, z.core.$strip>>>;
         erasure: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            stance: z.ZodLiteral<import("../external-data.exports").HttpApiErasureStance.NO_SUBJECT_DATA>;
+            stance: z.ZodLiteral<HttpApiErasureStance.NO_SUBJECT_DATA>;
         }, z.core.$strip>, z.ZodObject<{
-            stance: z.ZodLiteral<import("../external-data.exports").HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION>;
+            stance: z.ZodLiteral<HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION>;
             operation: z.ZodUnion<readonly [z.ZodObject<{
                 useCanonicalDelete: z.ZodLiteral<true>;
             }, z.core.$strip>, z.ZodObject<{
@@ -141,9 +796,50 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
             }, z.core.$strip>]>;
             subjectLinkLocalField: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
-            stance: z.ZodLiteral<import("../external-data.exports").HttpApiErasureStance.CONTROLLER_ACKNOWLEDGED_NON_ERASURE>;
+            stance: z.ZodLiteral<HttpApiErasureStance.CONTROLLER_ACKNOWLEDGED_NON_ERASURE>;
             subjectLinkLocalField: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>], "stance">;
+        purposeRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writableVerbs: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof HttpApiWriteVerb>>>;
+        writeConcurrency: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<HttpApiWriteConcurrencyMode.VERSION_CHECKED>;
+            versionField: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<HttpApiWriteConcurrencyMode.LAST_WRITER_WINS>;
+        }, z.core.$strict>], "mode">>;
+        actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            target: z.ZodEnum<typeof import("../external-data.exports").SystemOfRecordActionTarget>;
+            call: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODOO_EXECUTE_KW>;
+                method: z.ZodString;
+                model: z.ZodOptional<z.ZodString>;
+                inputPlacement: z.ZodDefault<z.ZodEnum<typeof import("../external-data.exports").SystemOfRecordOdooActionInputPlacement>>;
+            }, z.core.$strict>, z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODATA_BOUND_ACTION>;
+                qualifiedName: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODATA_UNBOUND_ACTION>;
+                actionImport: z.ZodString;
+            }, z.core.$strict>], "shape">;
+            input: z.ZodCustom<z.ZodObject<Readonly<{
+                [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            }>, z.core.$strip>, z.ZodObject<Readonly<{
+                [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            }>, z.core.$strip>>;
+            output: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            writes: z.ZodBoolean;
+            retrySafe: z.ZodDefault<z.ZodBoolean>;
+            roles: z.ZodArray<z.ZodString>;
+            admitsSystemInitiation: z.ZodDefault<z.ZodBoolean>;
+            partitionStance: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionPartitionStanceKind.PARTITION_NEUTRAL>;
+                reason: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionPartitionStanceKind.MEMBER_UNIT_PARTITION>;
+                parameter: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+            operation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
         remoteCallSemantics: z.ZodDefault<z.ZodObject<{
             timeoutMs: z.ZodDefault<z.ZodNumber>;
             retry: z.ZodDefault<z.ZodObject<{
@@ -155,6 +851,89 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
             maxPartitionSetSize: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
         dialect: z.ZodLiteral<HttpApiTransportDialect.ODATA>;
+    }, z.core.$strip>, z.ZodObject<{
+        system: z.ZodString;
+        entityRef: z.ZodString;
+        keyFields: z.ZodArray<z.ZodObject<{
+            localField: z.ZodString;
+            remoteField: z.ZodString;
+            codec: z.ZodEnum<typeof import("../external-data.exports").HttpApiKeyComponentCodec>;
+        }, z.core.$strip>>;
+        fieldMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            localField: z.ZodString;
+            remoteField: z.ZodString;
+            temporalKind: z.ZodOptional<z.ZodEnum<typeof import("../external-data.exports").HttpApiRemoteTemporalKind>>;
+        }, z.core.$strip>>>;
+        erasure: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            stance: z.ZodLiteral<HttpApiErasureStance.NO_SUBJECT_DATA>;
+        }, z.core.$strip>, z.ZodObject<{
+            stance: z.ZodLiteral<HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION>;
+            operation: z.ZodUnion<readonly [z.ZodObject<{
+                useCanonicalDelete: z.ZodLiteral<true>;
+            }, z.core.$strip>, z.ZodObject<{
+                method: z.ZodEnum<typeof import("../external-data.exports").HttpApiErasureOperationMethod>;
+                pathTemplate: z.ZodString;
+                jsonRpcEnvelope: z.ZodOptional<z.ZodObject<{
+                    rpcMethod: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>]>;
+            subjectLinkLocalField: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            stance: z.ZodLiteral<HttpApiErasureStance.CONTROLLER_ACKNOWLEDGED_NON_ERASURE>;
+            subjectLinkLocalField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "stance">;
+        purposeRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writableVerbs: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof HttpApiWriteVerb>>>;
+        writeConcurrency: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<HttpApiWriteConcurrencyMode.VERSION_CHECKED>;
+            versionField: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<HttpApiWriteConcurrencyMode.LAST_WRITER_WINS>;
+        }, z.core.$strict>], "mode">>;
+        actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            target: z.ZodEnum<typeof import("../external-data.exports").SystemOfRecordActionTarget>;
+            call: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODOO_EXECUTE_KW>;
+                method: z.ZodString;
+                model: z.ZodOptional<z.ZodString>;
+                inputPlacement: z.ZodDefault<z.ZodEnum<typeof import("../external-data.exports").SystemOfRecordOdooActionInputPlacement>>;
+            }, z.core.$strict>, z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODATA_BOUND_ACTION>;
+                qualifiedName: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODATA_UNBOUND_ACTION>;
+                actionImport: z.ZodString;
+            }, z.core.$strict>], "shape">;
+            input: z.ZodCustom<z.ZodObject<Readonly<{
+                [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            }>, z.core.$strip>, z.ZodObject<Readonly<{
+                [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            }>, z.core.$strip>>;
+            output: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            writes: z.ZodBoolean;
+            retrySafe: z.ZodDefault<z.ZodBoolean>;
+            roles: z.ZodArray<z.ZodString>;
+            admitsSystemInitiation: z.ZodDefault<z.ZodBoolean>;
+            partitionStance: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionPartitionStanceKind.PARTITION_NEUTRAL>;
+                reason: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionPartitionStanceKind.MEMBER_UNIT_PARTITION>;
+                parameter: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+            operation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        remoteCallSemantics: z.ZodDefault<z.ZodObject<{
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+            retry: z.ZodDefault<z.ZodObject<{
+                maxAttempts: z.ZodDefault<z.ZodNumber>;
+                backoffMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            maxRequestsPerMinute: z.ZodOptional<z.ZodNumber>;
+            maxIdSetSize: z.ZodDefault<z.ZodNumber>;
+            maxPartitionSetSize: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        dialect: z.ZodLiteral<HttpApiTransportDialect.ODATA_V2>;
     }, z.core.$strip>, z.ZodObject<{
         operations: z.ZodObject<{
             read: z.ZodObject<{
@@ -163,6 +942,7 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
                 pagingParams: z.ZodOptional<z.ZodObject<{
                     limitParam: z.ZodString;
                     offsetParam: z.ZodString;
+                    placement: z.ZodOptional<z.ZodEnum<typeof import("../external-data.exports").HttpApiRestParameterPlacement>>;
                 }, z.core.$strip>>;
                 filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 searchParam: z.ZodOptional<z.ZodString>;
@@ -174,6 +954,9 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
                     language: z.ZodEnum<typeof import("../external-data.exports").HttpApiQueryStatementLanguage>;
                     parameterName: z.ZodString;
                     fromEntity: z.ZodOptional<z.ZodString>;
+                    keyset: z.ZodOptional<z.ZodObject<{
+                        keyRemoteField: z.ZodString;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>>;
                 cursorPath: z.ZodOptional<z.ZodString>;
                 staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -184,6 +967,7 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
                 pagingParams: z.ZodOptional<z.ZodObject<{
                     limitParam: z.ZodString;
                     offsetParam: z.ZodString;
+                    placement: z.ZodOptional<z.ZodEnum<typeof import("../external-data.exports").HttpApiRestParameterPlacement>>;
                 }, z.core.$strip>>;
                 filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 searchParam: z.ZodOptional<z.ZodString>;
@@ -195,6 +979,9 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
                     language: z.ZodEnum<typeof import("../external-data.exports").HttpApiQueryStatementLanguage>;
                     parameterName: z.ZodString;
                     fromEntity: z.ZodOptional<z.ZodString>;
+                    keyset: z.ZodOptional<z.ZodObject<{
+                        keyRemoteField: z.ZodString;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>>;
                 cursorPath: z.ZodOptional<z.ZodString>;
                 staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -205,6 +992,7 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
                 pagingParams: z.ZodOptional<z.ZodObject<{
                     limitParam: z.ZodString;
                     offsetParam: z.ZodString;
+                    placement: z.ZodOptional<z.ZodEnum<typeof import("../external-data.exports").HttpApiRestParameterPlacement>>;
                 }, z.core.$strip>>;
                 filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 searchParam: z.ZodOptional<z.ZodString>;
@@ -216,6 +1004,9 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
                     language: z.ZodEnum<typeof import("../external-data.exports").HttpApiQueryStatementLanguage>;
                     parameterName: z.ZodString;
                     fromEntity: z.ZodOptional<z.ZodString>;
+                    keyset: z.ZodOptional<z.ZodObject<{
+                        keyRemoteField: z.ZodString;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>>;
                 cursorPath: z.ZodOptional<z.ZodString>;
                 staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -226,6 +1017,7 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
                 pagingParams: z.ZodOptional<z.ZodObject<{
                     limitParam: z.ZodString;
                     offsetParam: z.ZodString;
+                    placement: z.ZodOptional<z.ZodEnum<typeof import("../external-data.exports").HttpApiRestParameterPlacement>>;
                 }, z.core.$strip>>;
                 filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 searchParam: z.ZodOptional<z.ZodString>;
@@ -237,10 +1029,46 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
                     language: z.ZodEnum<typeof import("../external-data.exports").HttpApiQueryStatementLanguage>;
                     parameterName: z.ZodString;
                     fromEntity: z.ZodOptional<z.ZodString>;
+                    keyset: z.ZodOptional<z.ZodObject<{
+                        keyRemoteField: z.ZodString;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>>;
                 cursorPath: z.ZodOptional<z.ZodString>;
                 staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, z.core.$strip>>;
+            create: z.ZodOptional<z.ZodObject<{
+                method: z.ZodEnum<typeof import("../external-data.exports").HttpApiRestWriteMethod>;
+                pathTemplate: z.ZodString;
+                createdKey: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    source: z.ZodLiteral<import("../external-data.exports").HttpApiRestCreatedKeySource.RESPONSE_BODY>;
+                    path: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    source: z.ZodLiteral<import("../external-data.exports").HttpApiRestCreatedKeySource.LOCATION_HEADER>;
+                }, z.core.$strip>], "source">>;
+                staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>>;
+            update: z.ZodOptional<z.ZodObject<{
+                method: z.ZodEnum<typeof import("../external-data.exports").HttpApiRestWriteMethod>;
+                pathTemplate: z.ZodString;
+                createdKey: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    source: z.ZodLiteral<import("../external-data.exports").HttpApiRestCreatedKeySource.RESPONSE_BODY>;
+                    path: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    source: z.ZodLiteral<import("../external-data.exports").HttpApiRestCreatedKeySource.LOCATION_HEADER>;
+                }, z.core.$strip>], "source">>;
+                staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>>;
+            delete: z.ZodOptional<z.ZodObject<{
+                method: z.ZodEnum<typeof import("../external-data.exports").HttpApiRestWriteMethod>;
+                pathTemplate: z.ZodString;
+                createdKey: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    source: z.ZodLiteral<import("../external-data.exports").HttpApiRestCreatedKeySource.RESPONSE_BODY>;
+                    path: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    source: z.ZodLiteral<import("../external-data.exports").HttpApiRestCreatedKeySource.LOCATION_HEADER>;
+                }, z.core.$strip>], "source">>;
+                staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>;
         system: z.ZodString;
         entityRef: z.ZodString;
@@ -252,11 +1080,12 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
         fieldMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
             localField: z.ZodString;
             remoteField: z.ZodString;
+            temporalKind: z.ZodOptional<z.ZodEnum<typeof import("../external-data.exports").HttpApiRemoteTemporalKind>>;
         }, z.core.$strip>>>;
         erasure: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            stance: z.ZodLiteral<import("../external-data.exports").HttpApiErasureStance.NO_SUBJECT_DATA>;
+            stance: z.ZodLiteral<HttpApiErasureStance.NO_SUBJECT_DATA>;
         }, z.core.$strip>, z.ZodObject<{
-            stance: z.ZodLiteral<import("../external-data.exports").HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION>;
+            stance: z.ZodLiteral<HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION>;
             operation: z.ZodUnion<readonly [z.ZodObject<{
                 useCanonicalDelete: z.ZodLiteral<true>;
             }, z.core.$strip>, z.ZodObject<{
@@ -268,9 +1097,50 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
             }, z.core.$strip>]>;
             subjectLinkLocalField: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
-            stance: z.ZodLiteral<import("../external-data.exports").HttpApiErasureStance.CONTROLLER_ACKNOWLEDGED_NON_ERASURE>;
+            stance: z.ZodLiteral<HttpApiErasureStance.CONTROLLER_ACKNOWLEDGED_NON_ERASURE>;
             subjectLinkLocalField: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>], "stance">;
+        purposeRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writableVerbs: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof HttpApiWriteVerb>>>;
+        writeConcurrency: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<HttpApiWriteConcurrencyMode.VERSION_CHECKED>;
+            versionField: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<HttpApiWriteConcurrencyMode.LAST_WRITER_WINS>;
+        }, z.core.$strict>], "mode">>;
+        actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            target: z.ZodEnum<typeof import("../external-data.exports").SystemOfRecordActionTarget>;
+            call: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODOO_EXECUTE_KW>;
+                method: z.ZodString;
+                model: z.ZodOptional<z.ZodString>;
+                inputPlacement: z.ZodDefault<z.ZodEnum<typeof import("../external-data.exports").SystemOfRecordOdooActionInputPlacement>>;
+            }, z.core.$strict>, z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODATA_BOUND_ACTION>;
+                qualifiedName: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODATA_UNBOUND_ACTION>;
+                actionImport: z.ZodString;
+            }, z.core.$strict>], "shape">;
+            input: z.ZodCustom<z.ZodObject<Readonly<{
+                [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            }>, z.core.$strip>, z.ZodObject<Readonly<{
+                [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            }>, z.core.$strip>>;
+            output: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            writes: z.ZodBoolean;
+            retrySafe: z.ZodDefault<z.ZodBoolean>;
+            roles: z.ZodArray<z.ZodString>;
+            admitsSystemInitiation: z.ZodDefault<z.ZodBoolean>;
+            partitionStance: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionPartitionStanceKind.PARTITION_NEUTRAL>;
+                reason: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionPartitionStanceKind.MEMBER_UNIT_PARTITION>;
+                parameter: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+            operation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
         remoteCallSemantics: z.ZodDefault<z.ZodObject<{
             timeoutMs: z.ZodDefault<z.ZodNumber>;
             retry: z.ZodDefault<z.ZodObject<{
@@ -293,11 +1163,12 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
         fieldMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
             localField: z.ZodString;
             remoteField: z.ZodString;
+            temporalKind: z.ZodOptional<z.ZodEnum<typeof import("../external-data.exports").HttpApiRemoteTemporalKind>>;
         }, z.core.$strip>>>;
         erasure: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            stance: z.ZodLiteral<import("../external-data.exports").HttpApiErasureStance.NO_SUBJECT_DATA>;
+            stance: z.ZodLiteral<HttpApiErasureStance.NO_SUBJECT_DATA>;
         }, z.core.$strip>, z.ZodObject<{
-            stance: z.ZodLiteral<import("../external-data.exports").HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION>;
+            stance: z.ZodLiteral<HttpApiErasureStance.EXTERNAL_ERASURE_OPERATION>;
             operation: z.ZodUnion<readonly [z.ZodObject<{
                 useCanonicalDelete: z.ZodLiteral<true>;
             }, z.core.$strip>, z.ZodObject<{
@@ -309,9 +1180,50 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
             }, z.core.$strip>]>;
             subjectLinkLocalField: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
-            stance: z.ZodLiteral<import("../external-data.exports").HttpApiErasureStance.CONTROLLER_ACKNOWLEDGED_NON_ERASURE>;
+            stance: z.ZodLiteral<HttpApiErasureStance.CONTROLLER_ACKNOWLEDGED_NON_ERASURE>;
             subjectLinkLocalField: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>], "stance">;
+        purposeRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writableVerbs: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof HttpApiWriteVerb>>>;
+        writeConcurrency: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<HttpApiWriteConcurrencyMode.VERSION_CHECKED>;
+            versionField: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<HttpApiWriteConcurrencyMode.LAST_WRITER_WINS>;
+        }, z.core.$strict>], "mode">>;
+        actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            target: z.ZodEnum<typeof import("../external-data.exports").SystemOfRecordActionTarget>;
+            call: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODOO_EXECUTE_KW>;
+                method: z.ZodString;
+                model: z.ZodOptional<z.ZodString>;
+                inputPlacement: z.ZodDefault<z.ZodEnum<typeof import("../external-data.exports").SystemOfRecordOdooActionInputPlacement>>;
+            }, z.core.$strict>, z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODATA_BOUND_ACTION>;
+                qualifiedName: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                shape: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionCallShape.ODATA_UNBOUND_ACTION>;
+                actionImport: z.ZodString;
+            }, z.core.$strict>], "shape">;
+            input: z.ZodCustom<z.ZodObject<Readonly<{
+                [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            }>, z.core.$strip>, z.ZodObject<Readonly<{
+                [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            }>, z.core.$strip>>;
+            output: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            writes: z.ZodBoolean;
+            retrySafe: z.ZodDefault<z.ZodBoolean>;
+            roles: z.ZodArray<z.ZodString>;
+            admitsSystemInitiation: z.ZodDefault<z.ZodBoolean>;
+            partitionStance: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionPartitionStanceKind.PARTITION_NEUTRAL>;
+                reason: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<import("../external-data.exports").SystemOfRecordActionPartitionStanceKind.MEMBER_UNIT_PARTITION>;
+                parameter: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+            operation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
         remoteCallSemantics: z.ZodDefault<z.ZodObject<{
             timeoutMs: z.ZodDefault<z.ZodNumber>;
             retry: z.ZodDefault<z.ZodObject<{
@@ -332,17 +1244,138 @@ export declare const ExternalDataPipelineDeclarationSchema: z.ZodObject<{
         remoteField: z.ZodString;
         localField: z.ZodString;
         coercion: z.ZodDefault<z.ZodEnum<typeof ExternalDataFieldCoercion>>;
+        /**
+         * `true`: a row whose extracted value is ABSENT is REJECTED (reported per row in the run
+         * ledger; its previous local version survives). `false` (default): absent lands as null,
+         * which the declaration coherence requires the local field to accept.
+         */
         required: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>, z.ZodObject<{
+        /** Which side owns the field — BIDIRECTIONAL pipelines only (#1723). Absent = REMOTE. */
+        owner: z.ZodOptional<z.ZodEnum<typeof ExternalDataFieldOwner>>;
+    }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<ExternalDataMappingEntryKind.CONSTANT>;
         localField: z.ZodString;
         constant: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-    }, z.core.$strip>], "kind">>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataMappingEntryKind.REMOTE_REFERENCE>;
+        /** The remote field carrying the reference (`parent_id` on Odoo `res.partner`). */
+        remoteField: z.ZodString;
+        /** The local foreign-key field the resolved reference is written to. */
+        localField: z.ZodString;
+        /** The LOCAL resource the reference resolves to — a pipeline destination or a virtual resource. */
+        targetResourceType: z.ZodString;
+        /**
+         * How the remote value becomes the target's key. Absent = resolved at AUTHORING from the source dialect:
+         * `ODOO_MANY2ONE` on an Odoo source, `SCALAR` otherwise — the resource factory writes the resolved value
+         * into the declaration, exactly as it resolves the Odoo absent-as-false coercion.
+         */
+        valueShape: z.ZodOptional<z.ZodEnum<typeof ExternalDataRemoteReferenceValueShape>>;
+        unresolved: z.ZodDefault<z.ZodEnum<typeof ExternalDataUnresolvedReferencePolicy>>;
+        /**
+         * The author has read that the target's `orphanPolicy: DELETE` will cascade into this resource's rows
+         * through the relationship's `onParentDelete` teardown, and wants that. Only meaningful — and only
+         * demanded — when both are true; see the schema's header.
+         */
+        orphanCascadeAcknowledged: z.ZodDefault<z.ZodBoolean>;
+        /** Which side owns the reference — BIDIRECTIONAL pipelines only (#1723). Absent = REMOTE. */
+        owner: z.ZodOptional<z.ZodEnum<typeof ExternalDataFieldOwner>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataMappingEntryKind.ENUM_MAP>;
+        /** The remote field carrying the code (`state` on Odoo `account.move`). */
+        remoteField: z.ZodString;
+        localField: z.ZodString;
+        /** Every code the declaration maps, each to one member of the local enum. Codes are unique. */
+        values: z.ZodArray<z.ZodObject<{
+            remoteValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            localValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        }, z.core.$strict>>;
+        /** A PRESENT code no `values` entry names. Absent = reject the row. */
+        unmapped: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            policy: z.ZodLiteral<ExternalDataUnmappedValuePolicy.REJECT_ROW>;
+        }, z.core.$strict>, z.ZodObject<{
+            policy: z.ZodLiteral<ExternalDataUnmappedValuePolicy.USE_DEFAULT>;
+            localValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        }, z.core.$strict>], "policy">>;
+        /** `true`: a row whose remote code is ABSENT is rejected. `false` (default): absence lands null. */
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataMappingEntryKind.CONCATENATION>;
+        localField: z.ZodString;
+        /** At least two parts, at least one of them a remote field. */
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<ExternalDataConcatenationPartKind.REMOTE_FIELD>;
+            remoteField: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<ExternalDataConcatenationPartKind.LITERAL>;
+            literal: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        /** Written between two parts that both have a value. Default: nothing. */
+        separator: z.ZodDefault<z.ZodString>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataMappingEntryKind.ARITHMETIC>;
+        remoteField: z.ZodString;
+        localField: z.ZodString;
+        /** Multiplier. Never 0 — a constant result is a `CONSTANT` entry. */
+        factor: z.ZodDefault<z.ZodNumber>;
+        /** Added after the multiplication. */
+        offset: z.ZodDefault<z.ZodNumber>;
+        /** Round the result to this many decimal places. Absent = no rounding. */
+        decimalPlaces: z.ZodOptional<z.ZodNumber>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<ExternalDataMappingEntryKind.CONDITIONAL>;
+        /** The remote field whose value decides. */
+        remoteField: z.ZodString;
+        localField: z.ZodString;
+        cases: z.ZodArray<z.ZodObject<{
+            equals: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            then: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.CONSTANT>;
+                constant: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.REMOTE_FIELD>;
+                remoteField: z.ZodString;
+                /** As on a `REMOTE_FIELD` entry: Odoo's absent-as-false is resolved at authoring from the local field's type. */
+                coercion: z.ZodDefault<z.ZodEnum<typeof ExternalDataFieldCoercion>>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>>;
+        otherwise: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.CONSTANT>;
+            constant: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<ExternalDataConditionalOutcomeKind.REMOTE_FIELD>;
+            remoteField: z.ZodString;
+            /** As on a `REMOTE_FIELD` entry: Odoo's absent-as-false is resolved at authoring from the local field's type. */
+            coercion: z.ZodDefault<z.ZodEnum<typeof ExternalDataFieldCoercion>>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>], "kind">>;
     sourceFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
     population: z.ZodDefault<z.ZodEnum<typeof ExternalDataDestinationPopulation>>;
+    archivedRecords: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        treatment: z.ZodLiteral<ExternalDataArchivedRecordTreatment.LOAD>;
+    }, z.core.$strip>, z.ZodObject<{
+        treatment: z.ZodLiteral<ExternalDataArchivedRecordTreatment.EXCLUDE_FROM_LOAD>;
+        archiveFlagRemoteField: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>], "treatment">>;
     orphanPolicy: z.ZodDefault<z.ZodEnum<typeof ExternalDataOrphanPolicy>>;
+    conflictPolicy: z.ZodOptional<z.ZodEnum<typeof ExternalDataConflictPolicy>>;
     scheduleCron: z.ZodOptional<z.ZodString>;
+    incremental: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<ExternalDataIncrementalExtractionMode.ODOO_WRITE_DATE>;
+        fullPassCron: z.ZodString;
+        lookbackSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<ExternalDataIncrementalExtractionMode.ODATA_MODIFIED_AT>;
+        fullPassCron: z.ZodString;
+        modifiedAtRemoteField: z.ZodString;
+        lookbackSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<ExternalDataIncrementalExtractionMode.ODATA_DELTA_LINK>;
+        fullPassCron: z.ZodString;
+    }, z.core.$strip>], "mode">>;
     maxRowsPerRun: z.ZodDefault<z.ZodNumber>;
+    maxRunDurationMs: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 /** @wildo_source:part:end saas.models.external-data-pipeline */
 export type ExternalDataPipelineDeclaration = z.infer<typeof ExternalDataPipelineDeclarationSchema>;
@@ -365,4 +1398,19 @@ export type ExternalDataPipelineDeclarationAuthored = z.input<typeof ExternalDat
  * mirroring `assertHttpApiBindingDialectCoherence`'s contract.
  */
 export declare function assertExternalDataPipelineDeclarationCoherence(declaration: ExternalDataPipelineDeclaration): void;
+/** Which side owns one mapping entry of a BIDIRECTIONAL pipeline (#1723): its declared `owner`, REMOTE when omitted. */
+export declare function resolveExternalDataFieldOwner(entry: ExternalDataPipelineDeclaration['mapping'][number]): ExternalDataFieldOwner;
+/** The conflict policy a BIDIRECTIONAL pipeline applies (#1723): its declared one, REFUSE_AND_REPORT when omitted. */
+export declare function resolveExternalDataConflictPolicy(declaration: Pick<ExternalDataPipelineDeclaration, 'conflictPolicy'>): ExternalDataConflictPolicy;
+/**
+ * Whether a pipeline LOADS this entry: every entry of an INBOUND pipeline, and the REMOTE- and BOTH-owned entries of a
+ * BIDIRECTIONAL one (#1723). An OUTBOUND pipeline loads nothing.
+ */
+export declare function externalDataEntryIsLoaded(direction: ExternalDataPipelineDirection, entry: ExternalDataPipelineDeclaration['mapping'][number]): boolean;
+/**
+ * Whether a pipeline SENDS this entry: every entry of an OUTBOUND pipeline, and the LOCAL- and BOTH-owned entries of a
+ * BIDIRECTIONAL one (#1723). An INBOUND pipeline sends nothing.
+ */
+export declare function externalDataEntryIsSent(direction: ExternalDataPipelineDirection, entry: ExternalDataPipelineDeclaration['mapping'][number]): boolean;
+export {};
 //# sourceMappingURL=external-data-pipeline.shared.schemas.d.ts.map