@wildo-ai/saas-models 1.1.5 → 1.1.7

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

@@ -0,0 +1,384 @@
+/**
+ * Declared ACTIONS of a system of record (#1678) — the named vendor operations an application may run against the
+ * ERP it reads, beside the row reads and row writes its read-through bindings already open.
+ *
+ * Posting an invoice (Odoo `account.move` `action_post`), confirming a sales order, an OData bound or unbound action:
+ * none of them is a row write, and before this nothing declared one and nothing executed one. The only thing that
+ * could run one was the systems-of-record registry's raw access hand-out, which returns an instance's credentials and
+ * records nothing (#1738 withdrew it from every application-facing door).
+ *
+ * ## The decision these declarations implement (Paul, 2026-09-25, on #1677/#1678)
+ *
+ * One vendor may serve two roles through two SEPARATE lanes. The system-of-record lane declares named actions and runs
+ * them under the INSTANCE's service identity, confined to the owner organization and to the member's partition, with
+ * its own audit event. The same vendor may also be a classical provider with its own user or organization connections.
+ * The two share a vendor identity for display and compliance, and never a credential or a runtime object (#1049 D10).
+ * There is no Odoo provider package, and a provider operation can never name a system-of-record instance.
+ *
+ * ## WHERE an action is declared, and the placement that was rejected
+ *
+ * On a read-through BINDING (`httpApiBinding.actions`), both kinds:
+ *
+ * - a RECORD-targeted action on the binding of the entity it acts on, which supplies the key codec that decodes the
+ *   target id and the resource whose read gates decide whether the caller may reach that record;
+ * - a RECORD-FREE action on the binding of the entity whose model (Odoo) or service (OData) the call is made against.
+ *
+ * Rejected: record-free actions on the INSTANCE (`systemsOfRecord.<name>.actions` in `wildo.saas.config.ts`). Three
+ * reasons, any one sufficient. An action declares a Zod INPUT schema, and the saas configuration is parsed by the CLI
+ * and the companion as data, where a schema object is not representable. An action declares the ROLES admitted to it,
+ * which are the same role keys the resource's operations declare in `shared-lib`, and a second home for them would
+ * drift. And the HTTP exposure of an action is a custom operation on a read-through resource, which lives in the
+ * resource configuration anyway; the instance declaration is not in scope there (it lives in the application root, not
+ * in `shared-lib`). What the instance keeps is what only the instance knows: whether its data is partitioned, which is
+ * why a record-free action's partition stance is checked at boot, where both are visible.
+ *
+ * ## What is checked where
+ *
+ * - HERE, at authoring (the resource factory, through `assertHttpApiBindingDialectCoherence`): the call shape against
+ *   the binding's dialect, the target against the call shape, the refused vendor methods, the stance's placement.
+ * - At BOOT (the resources registry, where the instance and the vendor facet are visible): the facet declares the call
+ *   shape, a record-free action on a PARTITIONED instance states its partition stance, and action names are unique per
+ *   instance.
+ * - Per REQUEST (the system-of-record action executor): who may run it, on which record, and what it sends.
+ */
+import { z } from 'zod';
+import { HttpApiTransportDialect } from '../http-api-binding/http-api-transport-dialect.shared';
+/** @wildo_source:part:start saas.models.system-of-record-actions facet:layer:shared facet:audience:app-developer */
+/**
+ * The wire SHAPE of a vendor action — how the engine calls it. Declared by the VENDOR FACET (which shapes its product
+ * supports, `actionCallShapes`) and chosen per action by its declaration.
+ *
+ * REST_JSON has no member: an arbitrary REST surface has no action convention to compile against, and a declared method
+ * plus path template is a design of its own. A REST_JSON binding declaring an action is refused by name. (REST_JSON
+ * ROW writes are declared per verb since #1728 — `operations.create` / `update` / `delete` — because a row write has a
+ * fixed meaning a method and a path can carry; an action's meaning is the vendor's, and has no such shape.)
+ */
+export declare enum SystemOfRecordActionCallShape {
+    /**
+     * Odoo's `object.execute_kw(db, uid, key, model, method, positional, keyword)` — any public model method, the
+     * credential inside the RPC arguments. A record-targeted call passes the record ids as its first positional
+     * argument, which is how Odoo addresses a recordset method such as `action_post`.
+     *
+     * spec-cite: Odoo 18.0 developer documentation, External API — "Calling methods" (the execute_kw argument layout).
+     */
+    ODOO_EXECUTE_KW = "odoo-execute-kw",
+    /**
+     * An OData v4 BOUND action: `POST <EntitySet>(<key>)/<Namespace>.<Action>`, parameters in the JSON body.
+     *
+     * spec-cite: OData Version 4.01 Part 1: Protocol §11.5.5 (Actions) and §11.5.5.1 (Invoking an Action).
+     */
+    ODATA_BOUND_ACTION = "odata-bound-action",
+    /**
+     * An OData v4 UNBOUND action reached through its action import: `POST /<ActionImport>`, parameters in the JSON body.
+     *
+     * spec-cite: OData Version 4.01 Part 1: Protocol §11.5.5.1 (Invoking an Action).
+     */
+    ODATA_UNBOUND_ACTION = "odata-unbound-action"
+}
+/**
+ * The dialect each call shape is spoken over. Total over {@link SystemOfRecordActionCallShape}, so a new shape is a
+ * compile error here until somebody says which dialect it belongs to.
+ */
+export declare const SYSTEM_OF_RECORD_ACTION_CALL_SHAPE_DIALECT: Readonly<Record<SystemOfRecordActionCallShape, HttpApiTransportDialect>>;
+/** What an action acts ON. */
+export declare enum SystemOfRecordActionTarget {
+    /**
+     * ONE record of the binding's entity, addressed by its synthesized id. The record is READ FIRST through the binding's
+     * read gates (owner organization, partition), so a caller can act only on a record it could see — and a record
+     * outside its partition answers as absent, exactly as a read answers.
+     */
+    RECORD = "record",
+    /** No record: a model-level Odoo method (`create`) or an OData unbound action. */
+    NONE = "none"
+}
+/** Where an Odoo action's validated input goes in the `execute_kw` call. */
+export declare enum SystemOfRecordOdooActionInputPlacement {
+    /** The input object is the keyword-argument dict. The default: most recordset methods take options by keyword. */
+    KEYWORD_ARGUMENTS = "keyword-arguments",
+    /**
+     * The input object is the (next) POSITIONAL argument — after the id list on a record-targeted action, first on a
+     * record-free one. `create(vals)` is the canonical case.
+     */
+    POSITIONAL = "positional",
+    /** The method takes nothing beyond its records (`action_post`). The declared input must then be empty. */
+    NONE = "none"
+}
+/**
+ * How a RECORD-FREE action relates to the instance's partitions (#1058), required at boot when the instance is
+ * partitioned. A record-targeted action needs none: the record it reads first carries its partition.
+ */
+export declare enum SystemOfRecordActionPartitionStanceKind {
+    /**
+     * The action touches no partitioned data — a lookup of a vendor setting, an action whose effect no partition owns.
+     * The declaration must say WHY in `reason`, because a claim nothing checks has to be one a reviewer can read.
+     */
+    PARTITION_NEUTRAL = "partition-neutral",
+    /**
+     * The action CARRIES the partition as one of its inputs, and the engine derives it from the caller's organization
+     * unit exactly as a read-through create is placed (#1679): a member of one unit lands in its partition, a member of
+     * several names the unit, and a caller may never supply the partition value itself.
+     */
+    MEMBER_UNIT_PARTITION = "member-unit-partition"
+}
+export declare const SystemOfRecordActionPartitionStanceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<SystemOfRecordActionPartitionStanceKind.PARTITION_NEUTRAL>;
+    /** Why no partition is reached. Read by a reviewer; nothing can verify it, which is why it is required. */
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<SystemOfRecordActionPartitionStanceKind.MEMBER_UNIT_PARTITION>;
+    /**
+     * The REMOTE parameter the placed partition value is written into (`company_id`): a key of the Odoo keyword
+     * arguments or of the positional input object, or a member of the OData body. The caller's input may not carry it.
+     */
+    parameter: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type SystemOfRecordActionPartitionStance = z.infer<typeof SystemOfRecordActionPartitionStanceSchema>;
+export declare const SystemOfRecordActionCallSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    shape: z.ZodLiteral<SystemOfRecordActionCallShape.ODOO_EXECUTE_KW>;
+    /** The model method, in Odoo's own spelling (`action_post`, `create`). */
+    method: z.ZodString;
+    /**
+     * The model the call is made on, for a RECORD-FREE action only. A record-targeted action acts on the binding's own
+     * model — the one its key codec and read gates describe — so naming another would decode the id against the wrong
+     * entity. Absent means the binding's `entityRef`.
+     */
+    model: z.ZodOptional<z.ZodString>;
+    inputPlacement: z.ZodDefault<z.ZodEnum<typeof SystemOfRecordOdooActionInputPlacement>>;
+}, z.core.$strict>, z.ZodObject<{
+    shape: z.ZodLiteral<SystemOfRecordActionCallShape.ODATA_BOUND_ACTION>;
+    /** The namespace-qualified action name (`Microsoft.Dynamics.CRM.WinOpportunity`). */
+    qualifiedName: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    shape: z.ZodLiteral<SystemOfRecordActionCallShape.ODATA_UNBOUND_ACTION>;
+    /** The action import's name, as the service root exposes it. */
+    actionImport: z.ZodString;
+}, z.core.$strict>], "shape">;
+export type SystemOfRecordActionCall = z.infer<typeof SystemOfRecordActionCallSchema>;
+/**
+ * The application's NAME for an action — lowerCamelCase, and distinct from the vendor's method name on purpose: the
+ * name is what code, roles and audit rows speak (`postInvoice`), the call is what the vendor understands
+ * (`account.move` `action_post`). Unique per INSTANCE across every binding, checked at boot, because callers address an
+ * action by `(system, action)`.
+ */
+export declare const SYSTEM_OF_RECORD_ACTION_NAME_PATTERN: RegExp;
+export declare const SystemOfRecordActionNameSchema: z.ZodString;
+/** ONE declared action. */
+export declare const SystemOfRecordActionDeclarationSchema: z.ZodObject<{
+    target: z.ZodEnum<typeof SystemOfRecordActionTarget>;
+    call: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        shape: z.ZodLiteral<SystemOfRecordActionCallShape.ODOO_EXECUTE_KW>;
+        /** The model method, in Odoo's own spelling (`action_post`, `create`). */
+        method: z.ZodString;
+        /**
+         * The model the call is made on, for a RECORD-FREE action only. A record-targeted action acts on the binding's own
+         * model — the one its key codec and read gates describe — so naming another would decode the id against the wrong
+         * entity. Absent means the binding's `entityRef`.
+         */
+        model: z.ZodOptional<z.ZodString>;
+        inputPlacement: z.ZodDefault<z.ZodEnum<typeof SystemOfRecordOdooActionInputPlacement>>;
+    }, z.core.$strict>, z.ZodObject<{
+        shape: z.ZodLiteral<SystemOfRecordActionCallShape.ODATA_BOUND_ACTION>;
+        /** The namespace-qualified action name (`Microsoft.Dynamics.CRM.WinOpportunity`). */
+        qualifiedName: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        shape: z.ZodLiteral<SystemOfRecordActionCallShape.ODATA_UNBOUND_ACTION>;
+        /** The action import's name, as the service root exposes it. */
+        actionImport: z.ZodString;
+    }, z.core.$strict>], "shape">;
+    /**
+     * The input contract, validated BEFORE anything is sent. Strict parsing is the caller's contract: a key the schema
+     * does not declare is refused rather than forwarded, so nothing reaches the vendor that the author did not name.
+     */
+    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>>;
+    /**
+     * The result contract. When declared, the vendor's answer is parsed through it and only the parsed value is returned;
+     * an answer it rejects after the vendor APPLIED the action is reported as an unknown outcome, never as "not done".
+     * Absent means the result is returned as the vendor sent it.
+     */
+    output: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    /**
+     * Whether the action CHANGES remote state. A writing action must carry an Idempotency-Key from EVERY caller, because a
+     * remote change cannot be rolled back, and its interrupted attempts are reported as an unknown outcome rather than as
+     * a failure. A non-writing action (a vendor computation that changes nothing) needs neither.
+     */
+    writes: z.ZodBoolean;
+    /**
+     * Whether the VENDOR makes a repeated call harmless, so the transport may re-send it after a timeout or a 5xx. False
+     * unless the vendor offers an idempotency mechanism for this call; Odoo offers none, so no Odoo action is retry-safe.
+     * A writing action is never re-sent without an Idempotency-Key, whatever this says.
+     */
+    retrySafe: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * The role keys admitted to run it, held in the OWNER organization (an organization role) or at application scope. A
+     * role held only inside an organization UNIT admits the action on that unit's partition alone.
+     */
+    roles: z.ZodArray<z.ZodString>;
+    /**
+     * Whether a context with NO user and no machine principal — the engine's own batch, cron and queue work, a webhook, an
+     * autonomous agent with nobody behind it — may run it. Such a context then acts ORGANIZATION-WIDE on the owner
+     * organization's behalf, which is exactly why it is off unless declared.
+     */
+    admitsSystemInitiation: z.ZodDefault<z.ZodBoolean>;
+    /** A record-free action's relation to the instance's partitions; see {@link SystemOfRecordActionPartitionStanceKind}. */
+    partitionStance: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<SystemOfRecordActionPartitionStanceKind.PARTITION_NEUTRAL>;
+        /** Why no partition is reached. Read by a reviewer; nothing can verify it, which is why it is required. */
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<SystemOfRecordActionPartitionStanceKind.MEMBER_UNIT_PARTITION>;
+        /**
+         * The REMOTE parameter the placed partition value is written into (`company_id`): a key of the Odoo keyword
+         * arguments or of the positional input object, or a member of the OData body. The caller's input may not carry it.
+         */
+        parameter: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    /**
+     * The resource operation that is this action's HTTP door, when it has one: a custom operation of the SAME resource
+     * whose implementation hands the request to the system-of-record action executor. Absent means the action is reached
+     * from code only.
+     *
+     * Naming the door HERE is what lets the resource factory tell an action from a row write. Without it, the only thing the
+     * factory can see is the verb the operation borrows, and both available borrows were wrong (#1678 review, F1):
+     *
+     * - borrowing READ made a state-changing route a GET, and its required Idempotency-Key was refused at boot, because a
+     *   read-shaped operation claims its repeat changes nothing — Wonder Todos' backend could not start;
+     * - borrowing UPDATE read as a ROW write, so the factory demanded `writableVerbs: [update]` — a door onto the bound
+     *   entity's rows that nobody asked for.
+     *
+     * A named door is exempt from the row-write rules and held to the action's own instead: a WRITING action's door borrows
+     * a single-row mutation verb (so its route is not a GET and a retry is keyed), requires the key on every variant, and
+     * runs INLINE. See `assertHttpApiWriteDeclarationCoherence`.
+     */
+    operation: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SystemOfRecordActionDeclaration = z.infer<typeof SystemOfRecordActionDeclarationSchema>;
+/** What an author writes — defaulted fields optional. */
+export type SystemOfRecordActionDeclarationAuthored = z.input<typeof SystemOfRecordActionDeclarationSchema>;
+/** Every action a binding declares, keyed by the application's action name. */
+export declare const SystemOfRecordActionDeclarationsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    target: z.ZodEnum<typeof SystemOfRecordActionTarget>;
+    call: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        shape: z.ZodLiteral<SystemOfRecordActionCallShape.ODOO_EXECUTE_KW>;
+        /** The model method, in Odoo's own spelling (`action_post`, `create`). */
+        method: z.ZodString;
+        /**
+         * The model the call is made on, for a RECORD-FREE action only. A record-targeted action acts on the binding's own
+         * model — the one its key codec and read gates describe — so naming another would decode the id against the wrong
+         * entity. Absent means the binding's `entityRef`.
+         */
+        model: z.ZodOptional<z.ZodString>;
+        inputPlacement: z.ZodDefault<z.ZodEnum<typeof SystemOfRecordOdooActionInputPlacement>>;
+    }, z.core.$strict>, z.ZodObject<{
+        shape: z.ZodLiteral<SystemOfRecordActionCallShape.ODATA_BOUND_ACTION>;
+        /** The namespace-qualified action name (`Microsoft.Dynamics.CRM.WinOpportunity`). */
+        qualifiedName: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        shape: z.ZodLiteral<SystemOfRecordActionCallShape.ODATA_UNBOUND_ACTION>;
+        /** The action import's name, as the service root exposes it. */
+        actionImport: z.ZodString;
+    }, z.core.$strict>], "shape">;
+    /**
+     * The input contract, validated BEFORE anything is sent. Strict parsing is the caller's contract: a key the schema
+     * does not declare is refused rather than forwarded, so nothing reaches the vendor that the author did not name.
+     */
+    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>>;
+    /**
+     * The result contract. When declared, the vendor's answer is parsed through it and only the parsed value is returned;
+     * an answer it rejects after the vendor APPLIED the action is reported as an unknown outcome, never as "not done".
+     * Absent means the result is returned as the vendor sent it.
+     */
+    output: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    /**
+     * Whether the action CHANGES remote state. A writing action must carry an Idempotency-Key from EVERY caller, because a
+     * remote change cannot be rolled back, and its interrupted attempts are reported as an unknown outcome rather than as
+     * a failure. A non-writing action (a vendor computation that changes nothing) needs neither.
+     */
+    writes: z.ZodBoolean;
+    /**
+     * Whether the VENDOR makes a repeated call harmless, so the transport may re-send it after a timeout or a 5xx. False
+     * unless the vendor offers an idempotency mechanism for this call; Odoo offers none, so no Odoo action is retry-safe.
+     * A writing action is never re-sent without an Idempotency-Key, whatever this says.
+     */
+    retrySafe: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * The role keys admitted to run it, held in the OWNER organization (an organization role) or at application scope. A
+     * role held only inside an organization UNIT admits the action on that unit's partition alone.
+     */
+    roles: z.ZodArray<z.ZodString>;
+    /**
+     * Whether a context with NO user and no machine principal — the engine's own batch, cron and queue work, a webhook, an
+     * autonomous agent with nobody behind it — may run it. Such a context then acts ORGANIZATION-WIDE on the owner
+     * organization's behalf, which is exactly why it is off unless declared.
+     */
+    admitsSystemInitiation: z.ZodDefault<z.ZodBoolean>;
+    /** A record-free action's relation to the instance's partitions; see {@link SystemOfRecordActionPartitionStanceKind}. */
+    partitionStance: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<SystemOfRecordActionPartitionStanceKind.PARTITION_NEUTRAL>;
+        /** Why no partition is reached. Read by a reviewer; nothing can verify it, which is why it is required. */
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<SystemOfRecordActionPartitionStanceKind.MEMBER_UNIT_PARTITION>;
+        /**
+         * The REMOTE parameter the placed partition value is written into (`company_id`): a key of the Odoo keyword
+         * arguments or of the positional input object, or a member of the OData body. The caller's input may not carry it.
+         */
+        parameter: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    /**
+     * The resource operation that is this action's HTTP door, when it has one: a custom operation of the SAME resource
+     * whose implementation hands the request to the system-of-record action executor. Absent means the action is reached
+     * from code only.
+     *
+     * Naming the door HERE is what lets the resource factory tell an action from a row write. Without it, the only thing the
+     * factory can see is the verb the operation borrows, and both available borrows were wrong (#1678 review, F1):
+     *
+     * - borrowing READ made a state-changing route a GET, and its required Idempotency-Key was refused at boot, because a
+     *   read-shaped operation claims its repeat changes nothing — Wonder Todos' backend could not start;
+     * - borrowing UPDATE read as a ROW write, so the factory demanded `writableVerbs: [update]` — a door onto the bound
+     *   entity's rows that nobody asked for.
+     *
+     * A named door is exempt from the row-write rules and held to the action's own instead: a WRITING action's door borrows
+     * a single-row mutation verb (so its route is not a GET and a retry is keyed), requires the key on every variant, and
+     * runs INLINE. See `assertHttpApiWriteDeclarationCoherence`.
+     */
+    operation: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+export type SystemOfRecordActionDeclarations = z.infer<typeof SystemOfRecordActionDeclarationsSchema>;
+/** @wildo_source:part:end saas.models.system-of-record-actions */
+/**
+ * Odoo methods that READ, refused as actions.
+ *
+ * An action's answer is returned to its caller, and it is not confined the way the read lane confines rows: a
+ * `search_read` declared as an action would hand a unit-confined member every company's rows. Reads go through the
+ * read-through resource, whose pushdown and key-addressed admission are the confinement. A deny-list cannot be
+ * complete — Odoo lets any public method be called — so an author reviews what a declared method returns; these are the
+ * methods whose whole purpose is to return rows.
+ */
+export declare const ODOO_READ_METHODS_REFUSED_AS_ACTIONS: ReadonlySet<string>;
+/**
+ * Odoo methods that are ROW WRITES of the binding's own entity, refused as record-targeted actions: `write` and
+ * `unlink` on the bound model are exactly what `writableVerbs` opens (#1679), with its payload rules and its field-level
+ * trail. Declaring them as actions would open a second door onto the same change, one that skips both.
+ */
+export declare const ODOO_ROW_WRITE_METHODS_REFUSED_AS_RECORD_ACTIONS: ReadonlySet<string>;
+/**
+ * Refuse every action declaration the engine could not honour, at AUTHORING (#1678). Throws a plain `Error` naming the
+ * action and the fix; the resource factory wraps it with the resource identifier.
+ *
+ * What is NOT decidable here, and why: whether the vendor's facet supports the call shape and whether the instance is
+ * partitioned both need the saas configuration and the facet map, which `shared-lib` does not see. Those are the boot
+ * checks (`collectSystemOfRecordActionDeclarationViolations` in the backend).
+ */
+export declare function assertSystemOfRecordActionDeclarationsCoherence(params: {
+    readonly dialect: HttpApiTransportDialect;
+    readonly actions: SystemOfRecordActionDeclarations | undefined;
+}): void;
+//# sourceMappingURL=system-of-record-actions.shared.schemas.d.ts.map

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

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