@aventara/client 0.0.0-stage → 0.1.0-pilot.1

package/dist/emit/runtime.emitter.d.ts

@@ -0,0 +1,87 @@
+import { type ClientContract } from "@aventara/core";
+import type { ClientEntrypoint } from "../config/client-config.interface.js";
+import type { EmittedModule } from "./emitted-tree.interface.js";
+/**
+ * The runtime modules the generated client carries: `metadata.ts`, the
+ * framework `Decimal`, the outcome codes and error classes, and the transport
+ * here; the scalar codec in `scalar.codec.ts`.
+ */
+/**
+ * `runtime/decimal.ts` — the framework-owned `Decimal` of §6.2, the generated
+ * runtime value of the `decimal` scalar. Bundled with the client and imported
+ * from nothing: its public type is its own, never an ORM's (§6.2, C-801).
+ *
+ * It holds the decimal string it was made from, digit for digit, and does no
+ * arithmetic — the surface is core's `Decimal` (a string constructor and
+ * `toString`) plus `toJSON`, so a value means the same on both sides of the wire.
+ * A proven decimal library may later sit behind it (§6.2); none is needed to
+ * carry digits.
+ *
+ * `toJSON` is the architect's (2026-10-04, S6 answers): it returns the decimal
+ * string, so a Decimal in a consumer's own JSON — a log line, a cache entry — is
+ * its digits rather than `{}`. No `equals`, no arithmetic. The request body never
+ * relies on it: `serializeWireBody` refuses an unencoded Decimal regardless, so a
+ * value the codec did not encode cannot slip onto the wire through `toJSON`.
+ *
+ * The grammar is core's `Decimal` grammar, read from `AvProtocol.scalarFormats`
+ * and emitted by value (C2, R7; `protocol-parity.spec.ts`). Unlike
+ * core's, the constructor refuses a non-string outright: a pattern test coerces
+ * its argument, so `5` would otherwise pass as `"5"` and be kept as a number.
+ */
+export declare function emitDecimalModule(): EmittedModule;
+/**
+ * `metadata.ts` — what this client was generated against: the ClientContract
+ * hash and the protocol version (Phase 12-partial Q4 = A), and the resolved
+ * entrypoint as the client's default (§15.2; Phase 12-rest Q5 = A). Nothing else:
+ * no driver, no timestamp, no generator version, no host path — anything a re-run
+ * over the same inputs could change breaks byte-equality (§19.3's spirit). The
+ * entrypoint is an input like the contract: changing it regenerates different
+ * bytes and leaves the hash alone (§15.2), and it never carries credentials
+ * (refused at resolution, Q5).
+ *
+ * The hash and the version are what every operation request sends (§12.4), from
+ * `runtime/transport.ts`; all three are internal — `AvClient.ts` exports none.
+ */
+export declare function emitMetadataModule(protocol: ClientContract["protocol"], entrypoint: ClientEntrypoint): EmittedModule;
+/**
+ * The `FrameworkError` subclasses the generated runtime declares, in UTF-16
+ * code-unit order — names the root namespace reserves (`name.deriver.ts`).
+ */
+export declare const FRAMEWORK_ERROR_CLASS_NAMES: readonly string[];
+/**
+ * The names `AvClient.ts` re-exports from `generated/runtime/errors.ts`: the classes and the
+ * two code unions §15.4 requires, and `Cause` and `ValidationIssue` — the types a
+ * thrown FrameworkError carries, public by the architect's decision of
+ * 2026-10-04 — in UTF-16 code-unit order.
+ */
+export declare function errorsModuleExports(): readonly string[];
+/**
+ * `runtime/errors.ts` — §13's vocabulary as the generated client carries it.
+ *
+ * Both code unions are emitted from core's exported arrays (Q3), so the emitted
+ * tree states each code exactly once and core stays their one source; the
+ * subclass set and the code each one throws are Q2's (above), accepted as-is by
+ * the architect on 2026-10-04. Exported beyond what `AvClient.ts` re-exports: the
+ * two arrays, `OperationErrorCode` and `frameworkErrorOf`, which
+ * `runtime/transport.ts` reads.
+ */
+export declare function emitErrorsModule(): EmittedModule;
+/**
+ * `runtime/transport.ts` — the happy path of §12 and §13.5, above Phase
+ * 12-partial's boundary: one POST per operation to
+ * `<entrypoint>/_resources/<resource>/<family>/<variant>` (§12.1–§12.3), the
+ * identity headers on every request (§12.4), per-request options that are never
+ * serialized (§15.7), and the envelope read back by §13.5's rule.
+ *
+ * `execute` is Q1 = B's primitive: exported from this module for the
+ * per-variant methods to wrap, and re-exported from nowhere — it is not public
+ * surface. It reads no capability and no operation descriptor; the caller names
+ * the operation.
+ *
+ * Fetch and AbortSignal are the platform's, reached through the structural types
+ * below so the module compiles with neither DOM nor Node types (§15.7, U5).
+ *
+ * Stale-route recovery is not here: it is F-716, Phase 10's, and the emitted
+ * module documents it as a hole in its own doc comment (S9).
+ */
+export declare function emitTransportModule(): EmittedModule;