@wildo-ai/saas-models 1.1.5 → 1.1.6

package/dist/esm/http-api-binding/http-api-binding.shared.schemas.d.ts

@@ -33,34 +33,9 @@
  */
 import { z } from 'zod';
 import { HttpApiTransportDialect } from './http-api-transport-dialect.shared';
+import { HttpApiErasureStance } from './http-api-erasure-stance.shared';
+import { HttpApiRestWriteMethod } from './http-api-rest-write-operations.shared.schemas';
 /** @wildo_source:part:start saas.models.http-api-binding facet:layer:shared facet:audience:app-developer */
-/**
- * The declared erasure stance of an HTTP_API-backed resource. All three stances are first-class
- * from slice 1 (decision D6, 2026-08-26); a binding MUST declare one — an undeclared stance is a
- * registration refusal, because `exportSubject` is a fail-closed obligation on every resource and
- * "we cannot delete rows we do not own" is not an answer the framework may imply silently.
- */
-export declare enum HttpApiErasureStance {
-    /**
-     * (6a) The resource declares it holds NO personal/subject data. Registration verifies the
-     * declaration is coherent (e.g. `exportSubject` posture) and erasure is structurally N/A for
-     * the remote rows.
-     */
-    NO_SUBJECT_DATA = "no-subject-data",
-    /**
-     * (6b) The binding declares HOW erasure reaches the foreign system: one named API operation the
-     * engine invokes on a subject-erasure request. This is a single declared write and does NOT
-     * require general write support (slice 1 stays read-only otherwise).
-     */
-    EXTERNAL_ERASURE_OPERATION = "external-erasure-operation",
-    /**
-     * (6c) Erasure REFUSES by default; an explicit, per-request, audited controller acknowledgement
-     * lets it proceed and records the un-erased remote rows at high severity. Mirrors the existing
-     * administrative-floor acknowledgement shape (`administrative-continuity-floors.md`): the record
-     * is the control. NEVER a standing default — the acknowledgement is per erasure request.
-     */
-    CONTROLLER_ACKNOWLEDGED_NON_ERASURE = "controller-acknowledged-non-erasure"
-}
 /**
  * Per-component value normalization for key synthesis. The codec is what makes the synthesized
  * `_id` STABLE: every component must round-trip byte-identically between the remote
@@ -84,6 +59,77 @@ export declare enum HttpApiKeyComponentCodec {
      */
     DATETIME_ISO = "datetime-iso"
 }
+/**
+ * A row-level write a read-through resource may send to its system of record.
+ *
+ * Three members and no bulk ones, deliberately. A bulk write against a system the platform does not
+ * own has no atomicity to offer — ten rows are ten remote calls, any of which can fail after the ones
+ * before it landed — so the engine opens single-row create, update and delete by key, and nothing
+ * else. `createMany`, `updateMany`, `deleteMany`, the guarded atomic primitives and the raw-filter
+ * doors stay refused by name on the repository.
+ *
+ * ## Why the binding declares them at all, when the resource already lists its operations
+ *
+ * Because opening a write door into somebody else's ERP is a decision of its own, taken where the
+ * remote contract is written. The resource's operation list says which HTTP routes exist; this says
+ * the binding may WRITE through them. The resource factory refuses the two disagreeing in EITHER
+ * direction — a write operation whose verb the binding does not open, and an opened verb no operation
+ * uses — so the second declaration can never drift from the first into an inert door or an open one.
+ *
+ * Absent is empty: every binding written before #1679 stays read-only without a change.
+ */
+export declare enum HttpApiWriteVerb {
+    /** A new remote row. The engine derives its partition from the caller's organization unit. */
+    CREATE = "create",
+    /** A change to one remote row, addressed by its synthesized id. Read first, then written. */
+    UPDATE = "update",
+    /** The removal of one remote row, addressed by its synthesized id. Read first, then deleted. */
+    DELETE = "delete"
+}
+/**
+ * What protects an UPDATE against overwriting a change made since its author read the row (#1724, #1726, #1728) —
+ * declared by every binding that opens UPDATE, whatever its dialect (ODOO_JSONRPC, ODATA, REST_JSON).
+ *
+ * ## Why a binding must say this at all
+ *
+ * An update that carries no version is last-writer-wins, whatever the vendor could have offered: Odoo's external API
+ * applies `write(ids, vals)` unconditionally, a REST_JSON write is sent with no precondition, and an OData service
+ * applies a `PATCH` whose `If-Match` matches — which a caller who never read the row cannot make match anything but
+ * `*`. A default nobody chose is a lost update nobody expects, so a binding that opens UPDATE states which of the two it
+ * accepts, and the factory refuses the omission.
+ *
+ * ## What VERSION_CHECKED is, honestly — it depends on the dialect
+ *
+ * The caller sends the row version it read (the local field named by `versionField`, mapped onto the vendor's
+ * `rowVersionField` — Odoo `write_date`, an OData service's `@odata.etag`). The engine reads the row just before
+ * writing it — the read it already makes to check the partition — and refuses the update when the versions differ,
+ * before anything is sent. Then:
+ *
+ * - **Odoo: best-effort.** Odoo takes no precondition, so the comparison and the write are two calls. That NARROWS the
+ *   race to the gap between them; it does NOT close it. A change landing inside that gap is overwritten, and a vendor
+ *   that serves its version coarsely (Odoo: to the second) cannot tell two changes in the same second apart.
+ * - **REST_JSON: best-effort, as on Odoo** — the write is sent as declared, with no precondition. It is available only
+ *   where the vendor facet declares a `rowVersionField`; neither the Salesforce nor the NetSuite facet does, so a
+ *   binding against them states LAST_WRITER_WINS (startup refuses VERSION_CHECKED there).
+ * - **OData: atomic.** The version is also sent as `If-Match`, so the SERVICE compares it with the row it is about to
+ *   change and answers `412 Precondition Failed` without applying anything when it moved — the gap is closed by the
+ *   vendor, not narrowed by the engine.
+ *   spec-cite: OData Version 4.01 Part 1: Protocol §8.2.4 (Header If-Match).
+ */
+export declare enum HttpApiWriteConcurrencyMode {
+    /**
+     * Every UPDATE carries the version its author read, and a stale one is refused before sending. Best-effort on Odoo
+     * and REST_JSON; atomic on OData, where the version also travels as `If-Match`.
+     */
+    VERSION_CHECKED = "version-checked",
+    /**
+     * No check against the version the CALLER read: the last update sent wins. Stated, so it is a decision rather than an
+     * accident. On OData the engine still sends the entity tag of the row it read first (or `*` when the row carries
+     * none), so a row that moved between that read and the write is refused, and a row deleted in between is never
+     * re-created by an upsert.
+     */
+    LAST_WRITER_WINS = "last-writer-wins"
+}
 /** @wildo_source:part:end saas.models.http-api-binding */
 /**
  * One ordered component of the remote entity's key. `keyFields` order is the ENCODING order —
@@ -97,14 +143,52 @@ export declare const HttpApiKeyFieldSchema: z.ZodObject<{
     codec: z.ZodEnum<typeof HttpApiKeyComponentCodec>;
 }, z.core.$strip>;
 export type HttpApiKeyField = z.infer<typeof HttpApiKeyFieldSchema>;
+/** @wildo_source:part:start saas.models.http-api-binding facet:layer:shared facet:audience:app-developer */
+/**
+ * What kind of TEMPORAL value a remote field holds, when a query statement compares it (#1972).
+ *
+ * A statement language spells a date and a date-time differently, and neither accepts a quoted string:
+ *
+ * | language | `DATE` | `DATE_TIME` |
+ * |---|---|---|
+ * | SOQL | `2026-01-05` (unquoted) | `2026-01-05T10:00:00Z` (unquoted, whole seconds) |
+ * | SuiteQL | `TO_DATE('2026-01-05', 'YYYY-MM-DD')` ¹ | `TO_DATE('2026-01-05 10:00:00', 'YYYY-MM-DD HH24:MI:SS')` |
+ *
+ * ¹ spec-cite: N/A — the date-only mask is Oracle SQL's `TO_DATE` convention (SuiteQL is SQL-92 / Oracle SQL);
+ * NetSuite's page shows only the date-time mask cited below.
+ *
+ * Which one a field needs is a fact about the REMOTE column that nothing in a local `Date` carries, so a
+ * statement read that filters a date field DECLARES it; a date compared with an undeclared field is refused
+ * rather than guessed, because the wrong form is refused by the vendor or silently compares as text.
+ * spec-cite: Salesforce, "SOQL and SOSL Reference" v68.0, WHERE › "Date Formats and Date Literals in WHERE" —
+ * `WHERE CreatedDate > 2005-10-08T01:02:03Z`; `date YYYY-MM-DD`; `dateTime YYYY-MM-DDThh:mm:ss+hh:mm,
+ * YYYY-MM-DDThh:mm:ss-hh:mm, or YYYY-MM-DDThh:mm:ssZ`.
+ * spec-cite: Oracle NetSuite, "SuiteQL Performance and Best Practices" (article_0824094533) — "You can't use date
+ * literals. You must encapsulate dates using the `to_date()` function."; "Do not use plain string values for date
+ * comparisons."; `where lastmodifieddate >= TO_DATE('2024-01-01 00:00:00', 'yyyy-mm-dd hh24:mi:ss')`.
+ *
+ * Read by the REST_JSON STATEMENT compilers only; declared on another dialect, or on a REST_JSON binding none of
+ * whose read members is a statement, it would change nothing, so the binding coherence refuses it there.
+ */
+export declare enum HttpApiRemoteTemporalKind {
+    /** A calendar date with no time — SOQL `date`, a NetSuite date column. */
+    DATE = "date",
+    /** An instant — SOQL `dateTime`, a NetSuite datetime column. */
+    DATE_TIME = "date-time"
+}
 /**
  * Local-to-remote field name mapping for fields whose names differ. Fields not listed map by
  * identity (same name both sides). Key components are declared in `keyFields`, not here.
+ *
+ * A REST_JSON statement read that FILTERS a temporal field lists it here — with the same name on both sides
+ * when they agree — to declare its `temporalKind`.
  */
 export declare const HttpApiFieldMappingSchema: z.ZodObject<{
     localField: z.ZodString;
     remoteField: z.ZodString;
+    temporalKind: z.ZodOptional<z.ZodEnum<typeof HttpApiRemoteTemporalKind>>;
 }, z.core.$strip>;
+/** @wildo_source:part:end saas.models.http-api-binding */
 export type HttpApiFieldMapping = z.infer<typeof HttpApiFieldMappingSchema>;
 /**
  * Declared remote-call semantics. An enterprise API is 100ms–2s, rate-limited, and sometimes
@@ -125,14 +209,27 @@ export type HttpApiRemoteCallSemantics = z.infer<typeof HttpApiRemoteCallSemanti
 /**
  * HTTP methods a declared read-family operation may use. Deliberately NOT the full HTTP verb set
  * (`API_HttpMethod` in `@wildo-ai/external-connectors-models` describes provider-protocol
- * operations): slice 1 is read-only, so the closed vocabulary is the read-safe verb plus POST —
+ * operations): these are READ members, so the closed vocabulary is the read-safe verb plus POST —
  * because JSON-RPC (Odoo) and many enterprise search endpoints are POST-shaped even for reads.
- * Write verbs (PUT/PATCH/DELETE) enter only with the D4 write story, as their own decision.
+ * Row writes are opened by `writableVerbs` (#1679) and framed by each dialect's write compiler; a
+ * REST_JSON write surface is its own declaration (#1728), never a widening of this enum.
  */
 export declare enum HttpApiRestOperationMethod {
     GET = "GET",
     POST = "POST"
 }
+/** @wildo_source:part:start saas.models.http-api-binding facet:layer:shared facet:audience:app-developer */
+/**
+ * Where a declared REST parameter is placed on the request, when the method's own answer is wrong for it (#1686).
+ */
+export declare enum HttpApiRestParameterPlacement {
+    /**
+     * The URL query string, whatever the method — NetSuite's SuiteQL `limit` and `offset` on a POST.
+     * spec-cite: Oracle NetSuite, "Executing SuiteQL Queries Through REST Web Services" (section_157909186990) — the
+     * statement is POSTed as `{"q": …}` and paged by `?limit=10&offset=10` on the request URL.
+     */
+    QUERY_STRING = "query-string"
+}
 /**
  * REST_JSON per-operation declaration: how one read-family member maps onto a concrete HTTP
  * operation. Deliberately minimal in slice 1 — pagination/filter parameter NAMES are declared,
@@ -195,6 +292,94 @@ export declare enum HttpApiQueryStatementLanguage {
      */
     SUITEQL = "suiteql"
 }
+/**
+ * Where a KEYSET page's size bound goes, per statement language (#1686).
+ *
+ * A keyset page is "the next N rows after the last key", so the statement's predicate and order are
+ * the same in every language — `<key> > <last key> … ORDER BY <key> ASC` — and only the size bound
+ * differs. Decided by the LANGUAGE, never declared by an author: it is a fact about the grammar.
+ */
+export declare enum HttpApiKeysetPageBound {
+    /**
+     * The statement carries `LIMIT <n>` itself — SOQL, which has no size parameter on `/query`.
+     *
+     * The vendor may still split the limited result into several BATCHES and answer the first one with
+     * a continuation (`nextRecordsUrl`), so a keyset page on this bound follows the operation's declared
+     * `cursorPath` inside the page until the result is exhausted — which is why the bound requires one.
+     * Without it, a batch shorter than the limit would read as the end of the pass and every row after
+     * it would go unread, and a DELETE orphan policy would then delete them.
+     * spec-cite: Salesforce REST API Developer Guide v68.0, "Query" — "up to 2,000 records can be returned
+     * at a time … the returned batch can include fewer records than the limit or what's set in the
+     * request … If the total number of results exceeds the limit or the requested number of results, the
+     * response contains the first batch of records, a false value for done, and a query locator."
+     */
+    STATEMENT_LIMIT_CLAUSE = "statement-limit-clause",
+    /**
+     * The operation's declared `pagingParams.limitParam` carries the size, and its `offsetParam` is sent
+     * as 0 on every page — SuiteQL, which pages by `limit`/`offset` query parameters.
+     *
+     * Offset 0 always: each page is a NEW query that starts after the last key, so no offset is ever
+     * needed, and none of the offset rules (an offset divisible by the limit, the result ceiling) is
+     * ever reached.
+     * spec-cite: Oracle NetSuite, "Collection Paging" (section_156414087576) — "You can only set offset
+     * and limit values in a way that the offset is divisible by the limit"; "Executing SuiteQL Queries
+     * Through REST Web Services" (section_157909186990) — "Using SuiteQL queries, you can return a
+     * maximum of 100,000 results."
+     */
+    LIMIT_PARAMETER = "limit-parameter"
+}
+/** The page bound of each statement language. A `Record` over the enum, so a new language is a compile error until it has one. */
+export declare const HTTP_API_KEYSET_PAGE_BOUND: Readonly<Record<HttpApiQueryStatementLanguage, HttpApiKeysetPageBound>>;
+/**
+ * The key codecs a keyset may walk (#1686): an INTEGER compares as a number and a STRING by code
+ * unit, and the engine CHECKS every served page against that order before trusting its last key.
+ *
+ * GUID and DATETIME_ISO are refused. A GUID has no order the vendors agree on — SQL Server sorts a
+ * `uniqueidentifier` by its last bytes first — so a page could never be checked; a datetime is not
+ * unique, and a keyset on a non-unique column skips the rows that share the boundary value.
+ */
+export declare const HTTP_API_KEYSET_ELIGIBLE_CODECS: readonly HttpApiKeyComponentCodec[];
+/**
+ * A declared KEYSET on a statement read (#1686) — what lets a REST system of record feed a pipeline.
+ *
+ * ## What it makes the engine build
+ *
+ * For the pipeline's extraction, the `list` member's statement becomes
+ *
+ * ```
+ * SELECT <mapped fields> FROM <entity> WHERE <sourceFilter> AND <key> > <last key> ORDER BY <key> ASC
+ * ```
+ *
+ * with the page size bounded per {@link HttpApiKeysetPageBound} (SOQL `LIMIT <n>`; SuiteQL
+ * `limit=<n>&offset=0`). The last key of each page is the pipeline's persisted cursor, and a page
+ * shorter than asked ends the pass — the Odoo id-keyset discipline, drift-safe for the same reason: a
+ * row inserted or deleted mid-pass never shifts the rows after the cursor, so none is skipped or read
+ * twice. Offset paging has neither property, which is why a REST source without a keyset stays
+ * refused.
+ *
+ * ## Why there is no cursor PLACEHOLDER to write
+ *
+ * The statement is BUILT by the engine (#1293), never templated by an author, so there is nowhere for a
+ * `:cursor` placeholder to go and no ORDER BY an author could forget: declaring the keyset is what puts
+ * both into the statement, and the engine writes them itself. What an author declares is only which
+ * column the walk runs on.
+ *
+ * ## Which column
+ *
+ * The binding's ONE key field — unique and immutable, which is what a keyset needs. Named by its
+ * remote field; its codec is the key field's own, so the two cannot disagree. A composite key is
+ * refused: one component of it is not unique.
+ *
+ * ## A vendor continuation is followed INSIDE a page, never persisted
+ *
+ * Salesforce's `nextRecordsUrl` names a server-side query locator. How long a locator lives is not
+ * stated in the REST API guide (UNVERIFIED), so it is never the cross-run cursor: the key is.
+ */
+export declare const HttpApiQueryStatementKeysetSchema: z.ZodObject<{
+    /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+    keyRemoteField: z.ZodString;
+}, z.core.$strict>;
+export type HttpApiQueryStatementKeyset = z.infer<typeof HttpApiQueryStatementKeysetSchema>;
 /**
  * How a read member builds and sends a query STATEMENT (#1293).
  *
@@ -206,6 +391,10 @@ export declare const HttpApiQueryStatementSpecSchema: z.ZodObject<{
     language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
     parameterName: z.ZodString;
     fromEntity: z.ZodOptional<z.ZodString>;
+    keyset: z.ZodOptional<z.ZodObject<{
+        /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+        keyRemoteField: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 export type HttpApiQueryStatementSpec = z.infer<typeof HttpApiQueryStatementSpecSchema>;
 export declare const HttpApiRestOperationSpecSchema: z.ZodObject<{
@@ -214,6 +403,7 @@ export declare const HttpApiRestOperationSpecSchema: z.ZodObject<{
     pagingParams: z.ZodOptional<z.ZodObject<{
         limitParam: z.ZodString;
         offsetParam: z.ZodString;
+        placement: z.ZodOptional<z.ZodEnum<typeof HttpApiRestParameterPlacement>>;
     }, z.core.$strip>>;
     filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     searchParam: z.ZodOptional<z.ZodString>;
@@ -225,11 +415,16 @@ export declare const HttpApiRestOperationSpecSchema: z.ZodObject<{
         language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
         parameterName: z.ZodString;
         fromEntity: z.ZodOptional<z.ZodString>;
+        keyset: z.ZodOptional<z.ZodObject<{
+            /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+            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>;
 export type HttpApiRestOperationSpec = z.infer<typeof HttpApiRestOperationSpecSchema>;
+/** @wildo_source:part:end saas.models.http-api-binding */
 /**
  * One read-surface member. An INLINE spec, and now only that.
  *
@@ -243,6 +438,7 @@ export declare const HttpApiRestOperationDeclarationSchema: z.ZodObject<{
     pagingParams: z.ZodOptional<z.ZodObject<{
         limitParam: z.ZodString;
         offsetParam: z.ZodString;
+        placement: z.ZodOptional<z.ZodEnum<typeof HttpApiRestParameterPlacement>>;
     }, z.core.$strip>>;
     filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     searchParam: z.ZodOptional<z.ZodString>;
@@ -254,12 +450,16 @@ export declare const HttpApiRestOperationDeclarationSchema: z.ZodObject<{
         language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
         parameterName: z.ZodString;
         fromEntity: z.ZodOptional<z.ZodString>;
+        keyset: z.ZodOptional<z.ZodObject<{
+            /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+            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>;
 export type HttpApiRestOperationDeclaration = z.infer<typeof HttpApiRestOperationDeclarationSchema>;
-/** The REST_JSON read-surface mapping: which lifecycle members exist remotely, and how. */
+/** The REST_JSON operation mapping: which read members and opened row writes exist remotely, and how each is sent. */
 export declare const HttpApiRestOperationsSchema: z.ZodObject<{
     read: z.ZodObject<{
         method: z.ZodEnum<typeof HttpApiRestOperationMethod>;
@@ -267,6 +467,7 @@ export declare const HttpApiRestOperationsSchema: z.ZodObject<{
         pagingParams: z.ZodOptional<z.ZodObject<{
             limitParam: z.ZodString;
             offsetParam: z.ZodString;
+            placement: z.ZodOptional<z.ZodEnum<typeof HttpApiRestParameterPlacement>>;
         }, z.core.$strip>>;
         filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         searchParam: z.ZodOptional<z.ZodString>;
@@ -278,6 +479,10 @@ export declare const HttpApiRestOperationsSchema: z.ZodObject<{
             language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
             parameterName: z.ZodString;
             fromEntity: z.ZodOptional<z.ZodString>;
+            keyset: z.ZodOptional<z.ZodObject<{
+                /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+                keyRemoteField: z.ZodString;
+            }, z.core.$strict>>;
         }, z.core.$strip>>;
         cursorPath: z.ZodOptional<z.ZodString>;
         staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -288,6 +493,7 @@ export declare const HttpApiRestOperationsSchema: z.ZodObject<{
         pagingParams: z.ZodOptional<z.ZodObject<{
             limitParam: z.ZodString;
             offsetParam: z.ZodString;
+            placement: z.ZodOptional<z.ZodEnum<typeof HttpApiRestParameterPlacement>>;
         }, z.core.$strip>>;
         filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         searchParam: z.ZodOptional<z.ZodString>;
@@ -299,6 +505,10 @@ export declare const HttpApiRestOperationsSchema: z.ZodObject<{
             language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
             parameterName: z.ZodString;
             fromEntity: z.ZodOptional<z.ZodString>;
+            keyset: z.ZodOptional<z.ZodObject<{
+                /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+                keyRemoteField: z.ZodString;
+            }, z.core.$strict>>;
         }, z.core.$strip>>;
         cursorPath: z.ZodOptional<z.ZodString>;
         staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -309,6 +519,7 @@ export declare const HttpApiRestOperationsSchema: z.ZodObject<{
         pagingParams: z.ZodOptional<z.ZodObject<{
             limitParam: z.ZodString;
             offsetParam: z.ZodString;
+            placement: z.ZodOptional<z.ZodEnum<typeof HttpApiRestParameterPlacement>>;
         }, z.core.$strip>>;
         filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         searchParam: z.ZodOptional<z.ZodString>;
@@ -320,6 +531,10 @@ export declare const HttpApiRestOperationsSchema: z.ZodObject<{
             language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
             parameterName: z.ZodString;
             fromEntity: z.ZodOptional<z.ZodString>;
+            keyset: z.ZodOptional<z.ZodObject<{
+                /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+                keyRemoteField: z.ZodString;
+            }, z.core.$strict>>;
         }, z.core.$strip>>;
         cursorPath: z.ZodOptional<z.ZodString>;
         staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -330,6 +545,7 @@ export declare const HttpApiRestOperationsSchema: z.ZodObject<{
         pagingParams: z.ZodOptional<z.ZodObject<{
             limitParam: z.ZodString;
             offsetParam: z.ZodString;
+            placement: z.ZodOptional<z.ZodEnum<typeof HttpApiRestParameterPlacement>>;
         }, z.core.$strip>>;
         filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         searchParam: z.ZodOptional<z.ZodString>;
@@ -341,10 +557,47 @@ export declare const HttpApiRestOperationsSchema: z.ZodObject<{
             language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
             parameterName: z.ZodString;
             fromEntity: z.ZodOptional<z.ZodString>;
+            keyset: z.ZodOptional<z.ZodObject<{
+                /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+                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 HttpApiRestWriteMethod>;
+        pathTemplate: z.ZodString;
+        createdKey: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").HttpApiRestCreatedKeySource.RESPONSE_BODY>;
+            path: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").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 HttpApiRestWriteMethod>;
+        pathTemplate: z.ZodString;
+        createdKey: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").HttpApiRestCreatedKeySource.RESPONSE_BODY>;
+            path: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").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 HttpApiRestWriteMethod>;
+        pathTemplate: z.ZodString;
+        createdKey: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").HttpApiRestCreatedKeySource.RESPONSE_BODY>;
+            path: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").HttpApiRestCreatedKeySource.LOCATION_HEADER>;
+        }, z.core.$strip>], "source">>;
+        staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type HttpApiRestOperations = z.infer<typeof HttpApiRestOperationsSchema>;
 /**
@@ -392,6 +645,7 @@ export declare const HttpApiErasureDeclarationSchema: z.ZodDiscriminatedUnion<[z
     subjectLinkLocalField: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "stance">;
 export type HttpApiErasureDeclaration = z.infer<typeof HttpApiErasureDeclarationSchema>;
+/** @wildo_source:part:end saas.models.http-api-binding */
 /**
  * The HTTP_API resource binding — discriminated on the transport dialect so each dialect carries
  * exactly its own obligations: ODATA and ODOO_JSONRPC are generic (the model name IS `entityRef`, and
@@ -413,6 +667,7 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
     fieldMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
         localField: z.ZodString;
         remoteField: z.ZodString;
+        temporalKind: z.ZodOptional<z.ZodEnum<typeof HttpApiRemoteTemporalKind>>;
     }, z.core.$strip>>>;
     erasure: z.ZodDiscriminatedUnion<[z.ZodObject<{
         stance: z.ZodLiteral<HttpApiErasureStance.NO_SUBJECT_DATA>;
@@ -432,6 +687,48 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
         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>;
+        /** The LOCAL field carrying the row version the caller read — never written to the remote. */
+        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<{
@@ -443,6 +740,90 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
         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 HttpApiKeyComponentCodec>;
+    }, z.core.$strip>>;
+    fieldMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        localField: z.ZodString;
+        remoteField: z.ZodString;
+        temporalKind: z.ZodOptional<z.ZodEnum<typeof 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 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>;
+        /** The LOCAL field carrying the row version the caller read — never written to the remote. */
+        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<{
@@ -451,6 +832,7 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
             pagingParams: z.ZodOptional<z.ZodObject<{
                 limitParam: z.ZodString;
                 offsetParam: z.ZodString;
+                placement: z.ZodOptional<z.ZodEnum<typeof HttpApiRestParameterPlacement>>;
             }, z.core.$strip>>;
             filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             searchParam: z.ZodOptional<z.ZodString>;
@@ -462,6 +844,10 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
                 language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
                 parameterName: z.ZodString;
                 fromEntity: z.ZodOptional<z.ZodString>;
+                keyset: z.ZodOptional<z.ZodObject<{
+                    /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+                    keyRemoteField: z.ZodString;
+                }, z.core.$strict>>;
             }, z.core.$strip>>;
             cursorPath: z.ZodOptional<z.ZodString>;
             staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -472,6 +858,7 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
             pagingParams: z.ZodOptional<z.ZodObject<{
                 limitParam: z.ZodString;
                 offsetParam: z.ZodString;
+                placement: z.ZodOptional<z.ZodEnum<typeof HttpApiRestParameterPlacement>>;
             }, z.core.$strip>>;
             filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             searchParam: z.ZodOptional<z.ZodString>;
@@ -483,6 +870,10 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
                 language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
                 parameterName: z.ZodString;
                 fromEntity: z.ZodOptional<z.ZodString>;
+                keyset: z.ZodOptional<z.ZodObject<{
+                    /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+                    keyRemoteField: z.ZodString;
+                }, z.core.$strict>>;
             }, z.core.$strip>>;
             cursorPath: z.ZodOptional<z.ZodString>;
             staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -493,6 +884,7 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
             pagingParams: z.ZodOptional<z.ZodObject<{
                 limitParam: z.ZodString;
                 offsetParam: z.ZodString;
+                placement: z.ZodOptional<z.ZodEnum<typeof HttpApiRestParameterPlacement>>;
             }, z.core.$strip>>;
             filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             searchParam: z.ZodOptional<z.ZodString>;
@@ -504,6 +896,10 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
                 language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
                 parameterName: z.ZodString;
                 fromEntity: z.ZodOptional<z.ZodString>;
+                keyset: z.ZodOptional<z.ZodObject<{
+                    /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+                    keyRemoteField: z.ZodString;
+                }, z.core.$strict>>;
             }, z.core.$strip>>;
             cursorPath: z.ZodOptional<z.ZodString>;
             staticHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -514,6 +910,7 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
             pagingParams: z.ZodOptional<z.ZodObject<{
                 limitParam: z.ZodString;
                 offsetParam: z.ZodString;
+                placement: z.ZodOptional<z.ZodEnum<typeof HttpApiRestParameterPlacement>>;
             }, z.core.$strip>>;
             filterParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             searchParam: z.ZodOptional<z.ZodString>;
@@ -525,10 +922,47 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
                 language: z.ZodEnum<typeof HttpApiQueryStatementLanguage>;
                 parameterName: z.ZodString;
                 fromEntity: z.ZodOptional<z.ZodString>;
+                keyset: z.ZodOptional<z.ZodObject<{
+                    /** The remote field of the binding's single key field — Salesforce `Id`, NetSuite `id`. */
+                    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 HttpApiRestWriteMethod>;
+            pathTemplate: z.ZodString;
+            createdKey: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").HttpApiRestCreatedKeySource.RESPONSE_BODY>;
+                path: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").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 HttpApiRestWriteMethod>;
+            pathTemplate: z.ZodString;
+            createdKey: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").HttpApiRestCreatedKeySource.RESPONSE_BODY>;
+                path: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").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 HttpApiRestWriteMethod>;
+            pathTemplate: z.ZodString;
+            createdKey: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").HttpApiRestCreatedKeySource.RESPONSE_BODY>;
+                path: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                source: z.ZodLiteral<import("./http-api-rest-write-operations.shared.schemas").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;
@@ -540,6 +974,7 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
     fieldMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
         localField: z.ZodString;
         remoteField: z.ZodString;
+        temporalKind: z.ZodOptional<z.ZodEnum<typeof HttpApiRemoteTemporalKind>>;
     }, z.core.$strip>>>;
     erasure: z.ZodDiscriminatedUnion<[z.ZodObject<{
         stance: z.ZodLiteral<HttpApiErasureStance.NO_SUBJECT_DATA>;
@@ -559,6 +994,48 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
         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>;
+        /** The LOCAL field carrying the row version the caller read — never written to the remote. */
+        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<{
@@ -581,6 +1058,7 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
     fieldMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
         localField: z.ZodString;
         remoteField: z.ZodString;
+        temporalKind: z.ZodOptional<z.ZodEnum<typeof HttpApiRemoteTemporalKind>>;
     }, z.core.$strip>>>;
     erasure: z.ZodDiscriminatedUnion<[z.ZodObject<{
         stance: z.ZodLiteral<HttpApiErasureStance.NO_SUBJECT_DATA>;
@@ -600,6 +1078,48 @@ export declare const HttpApiResourceBindingSchema: z.ZodDiscriminatedUnion<[z.Zo
         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>;
+        /** The LOCAL field carrying the row version the caller read — never written to the remote. */
+        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<{