@azure/provisioning-core 1.0.0-beta.1

package/dist/browser/shape/shape.js

@@ -0,0 +1,424 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+// ---------------------------------------------------------------------------
+// Constructor helpers
+// ---------------------------------------------------------------------------
+/** Build a {@link FlatModelShape} from a property map. */
+export const createFlatModelShape = (byJsName) => ({
+    kind: "flatModel",
+    byJsName,
+});
+/**
+ * Build a {@link DiscriminatedModelShape}.
+ *
+ * Pass a bare string when the field goes by the same name on both
+ * sides, which is the overwhelmingly common case; pass a
+ * {@link DiscriminatorNames} pair when a `@clientName` makes them
+ * differ.
+ */
+export const createDiscriminatedModelShape = (discriminator, byValue) => ({
+    kind: "discriminatedModel",
+    discriminator: typeof discriminator === "string"
+        ? { jsName: discriminator, armName: discriminator }
+        : discriminator,
+    byValue,
+});
+/**
+ * Build a {@link DeferredShape}. The thunk is called on dereference; defer
+ * the actual shape lookup so that mutually-referential constants can
+ * be emitted in any order.
+ */
+export const createDeferredShape = (value) => ({
+    kind: "deferred",
+    value,
+});
+/** Build an {@link AnyShape}. */
+export const createAnyShape = () => ({ kind: "any" });
+/** Build a {@link StringShape}, optionally with a compatible wire encoding. */
+export const createStringShape = (encoding) => ({
+    kind: "string",
+    ...(encoding ? { encoding } : {}),
+});
+/** Build a {@link BooleanShape}, optionally with a compatible wire encoding. */
+export const createBooleanShape = (encoding) => ({
+    kind: "boolean",
+    ...(encoding ? { encoding } : {}),
+});
+/** Build a {@link NumberShape}, optionally with a compatible wire encoding. */
+export const createNumberShape = (encoding) => ({
+    kind: "number",
+    ...(encoding ? { encoding } : {}),
+});
+/** Build a {@link BytesShape}, optionally with a compatible wire encoding. */
+export const createBytesShape = (encoding) => ({
+    kind: "bytes",
+    ...(encoding ? { encoding } : {}),
+});
+/** Build a {@link DateShape}, optionally with a compatible wire encoding. */
+export const createDateShape = (encoding) => ({
+    kind: "date",
+    ...(encoding ? { encoding } : {}),
+});
+/** Build a terminal {@link StringLiteralShape}. */
+export const createStringLiteralShape = () => ({
+    kind: "stringLiteral",
+});
+/** Build a terminal {@link NumberLiteralShape}. */
+export const createNumberLiteralShape = (encoding) => ({
+    kind: "numberLiteral",
+    ...(encoding ? { encoding } : {}),
+});
+/** Build a terminal {@link BooleanLiteralShape}. */
+export const createBooleanLiteralShape = (encoding) => ({
+    kind: "booleanLiteral",
+    ...(encoding ? { encoding } : {}),
+});
+/** Build a terminal {@link EnumShape}. */
+export const createEnumShape = () => ({ kind: "enum" });
+/** Build a terminal {@link UnionShape}. */
+export const createUnionShape = () => ({ kind: "union" });
+/** Build a terminal {@link NullShape}. */
+export const createNullShape = () => ({ kind: "null" });
+/** Build an {@link ArrayShape}. */
+export const createArrayShape = (element) => ({
+    kind: "array",
+    element,
+});
+/** Build a {@link RecordShape}. */
+export const createRecordShape = (value) => ({
+    kind: "record",
+    value,
+});
+/** Build a {@link TupleShape}. */
+export const createTupleShape = (values) => ({
+    kind: "tuple",
+    values,
+});
+/** Return whether a value shape terminates property navigation. */
+export function isTerminalValueShape(shape) {
+    switch (shape.kind) {
+        case "any":
+        case "string":
+        case "boolean":
+        case "number":
+        case "bytes":
+        case "date":
+        case "stringLiteral":
+        case "numberLiteral":
+        case "booleanLiteral":
+        case "enum":
+        case "union":
+        case "null":
+            return true;
+        case "deferred":
+        case "array":
+        case "record":
+        case "tuple":
+            return false;
+        default:
+            return assertNeverShape(shape);
+    }
+}
+function assertNeverShape(shape) {
+    throw new Error(`Unhandled value shape: ${String(shape)}`);
+}
+/**
+ * Resolve a {@link ModelShape} to the single concrete variant that
+ * applies to `value`.
+ *
+ * Resolution is iterative, not a single step, because a variant may
+ * itself be a discriminated group keyed on a *different* field (see
+ * {@link DiscriminatedModelShape.byValue}). Each hop reads its own
+ * discriminator out of the same `value`, so
+ * `{ kind: "cat", breed: "siamese" }` resolves through `Pet` → `Cat`
+ * → `Siamese`. {@link DeferredShape} entries are dereferenced in
+ * place, and flat model shapes are returned as-is.
+ *
+ * When a hop's discriminator can't be read — it is absent, is not a
+ * string (the *expression-valued* case), or names an unknown variant —
+ * the variant is instead **inferred from the value's structure** by
+ * {@link selectVariant}. That inference is sound rather than a guess:
+ * ARM would reject a payload that doesn't match the variant its
+ * discriminator selects, so a concrete payload determines the variant
+ * even when the discriminator itself is only known at deploy time.
+ *
+ * Bicep takes the same position — a discriminator it can't evaluate at
+ * compile time downgrades type checking for that object (diagnostic
+ * `BCP225`) rather than failing the build.
+ *
+ * Returns `undefined` when `shape` is `undefined`, when there is no
+ * `value` to infer from, or when the `byValue` graph is cyclic
+ * (defensive; the emitter does not produce cycles here).
+ *
+ * @param shape - The shape to resolve. Flat shapes are returned
+ *   unchanged, so callers can pass either kind without checking.
+ * @param value - The object this shape describes, used both to read
+ *   discriminators and to infer a variant when they can't be read.
+ *   Omit it when no value exists (an `Expression<T>` proxy, say) and
+ *   discriminated shapes will resolve to `undefined`.
+ * @param valueKeyedBy - Which naming **`value`'s own keys** use — not
+ *   the shape's. A {@link FlatModelShape} is the mapping *between* the
+ *   two sides (one property is `secretVersion` in TypeScript and
+ *   `version` on the wire), so inference has to read both sides in the
+ *   same naming or nothing matches:
+ *
+ *   - `"js"` — client-facing names, as authored in TypeScript and held
+ *     in a resource's state. These are
+ *     {@link FlatModelShape.byJsName}'s own keys. Passed by
+ *     `lowerState`, on state about to be serialized.
+ *   - `"arm"` — wire names, as they appear in an ARM template or a
+ *     service response. These are the first segment of each
+ *     {@link PropertyShape.armPath}. Passed by `raiseState`, on JSON
+ *     just parsed off the wire.
+ *
+ *   Has no effect when the discriminator resolves normally, and no
+ *   effect at all for models whose properties map 1:1.
+ */
+export function resolveModelShape(shape, value, valueKeyedBy = "js") {
+    let current = shape;
+    const seen = new Set();
+    while (current !== undefined) {
+        if (seen.has(current))
+            return undefined;
+        seen.add(current);
+        if (current.kind === "deferred") {
+            current = current.value();
+            continue;
+        }
+        if (current.kind === "flatModel")
+            return current;
+        const group = current;
+        // Read the discriminator under the same naming as `value`'s own
+        // keys: JS-side state holds it under the client name, wire JSON
+        // under the ARM name. The two coincide for almost every ARM
+        // discriminator, but a `@clientName` on the field makes them
+        // differ, and reading the wrong one silently downgrades exact
+        // dispatch to structural inference below.
+        const names = group.discriminator;
+        const key = value?.[valueKeyedBy === "js" ? names.jsName : names.armName];
+        const next = typeof key === "string" ? group.byValue[key] : undefined;
+        if (next === undefined) {
+            return value ? selectVariant(group, value, valueKeyedBy) : undefined;
+        }
+        current = next;
+    }
+    return undefined;
+}
+/**
+ * Infer which variant of `group` a value belongs to by structure.
+ *
+ * Every variant is scored by how many of the value's keys it declares,
+ * descending into nested objects and containers so that variants which
+ * are indistinguishable at the top level can still be told apart. CDN's
+ * delivery-rule actions are exactly that case: all nine variants
+ * declare `{ name, parameters }` and differ only inside `parameters`.
+ *
+ * The highest score wins; ties keep the earliest variant in `byValue`
+ * order, which is stable emitter output. A tie means the tied variants
+ * declare the same keys for the data given, and the emitter guarantees
+ * that keys shared across variants map identically — so either choice
+ * produces the same wire mapping for everything actually present.
+ */
+function selectVariant(group, value, valueKeyedBy) {
+    let best;
+    let bestScore = -1;
+    for (const variant of flattenVariants(group, new Set())) {
+        const score = scoreShape(variant, value, valueKeyedBy, new WeakSet());
+        if (score > bestScore) {
+            bestScore = score;
+            best = variant;
+        }
+    }
+    return best;
+}
+/** How many of `value`'s keys, recursively, `shape` accounts for. */
+function scoreShape(shape, value, valueKeyedBy, visiting) {
+    if (visiting.has(value))
+        return 0;
+    visiting.add(value);
+    const byKey = getShapePropertiesMap(shape, valueKeyedBy);
+    let score = 0;
+    for (const [key, sub] of Object.entries(value)) {
+        const prop = byKey.get(key);
+        if (!prop)
+            continue;
+        score += 1;
+        score += scoreNested(sub, prop.value, valueKeyedBy, visiting);
+    }
+    visiting.delete(value);
+    return score;
+}
+/**
+ * Score one level deeper, through a property's target. Containers are
+ * sampled at their first entry — enough to discriminate, and bounded
+ * regardless of how large the value is.
+ */
+function scoreNested(value, target, valueKeyedBy, visiting) {
+    if (!target || isTerminalValueShape(target) || value === null || typeof value !== "object") {
+        return 0;
+    }
+    if (target.kind === "array") {
+        if (!Array.isArray(value) || value.length === 0)
+            return 0;
+        return scoreNested(value[0], target.element, valueKeyedBy, visiting);
+    }
+    if (target.kind === "record") {
+        if (Array.isArray(value))
+            return 0;
+        const first = Object.values(value)[0];
+        if (first === undefined)
+            return 0;
+        return scoreNested(first, target.value, valueKeyedBy, visiting);
+    }
+    if (target.kind === "tuple") {
+        if (!Array.isArray(value))
+            return 0;
+        return target.values.reduce((score, tupleValue, index) => score + scoreNested(value[index], tupleValue, valueKeyedBy, visiting), 0);
+    }
+    if (Array.isArray(value))
+        return 0;
+    const nested = resolveModelShape(target.value(), value, valueKeyedBy);
+    if (!nested)
+        return 0;
+    return scoreShape(nested, value, valueKeyedBy, visiting);
+}
+const shapePropertiesCache = new WeakMap();
+/**
+ * A shape's properties as a map, keyed by the name they go by in the
+ * requested naming. Pass the same naming the value uses and the two
+ * line up, which is what lets {@link scoreShape} compare them.
+ *
+ * Memoized per (shape, naming): scoring calls this once per candidate
+ * variant per level, so rebuilding would be wasteful.
+ *
+ * @param shape - The shape whose properties to map.
+ * @param keyedBy - Which name to key by. Note this describes the *map
+ *   being built*, not an incoming value — unlike the `valueKeyedBy`
+ *   parameter the callers thread through.
+ */
+function getShapePropertiesMap(shape, keyedBy) {
+    let byNaming = shapePropertiesCache.get(shape);
+    if (!byNaming) {
+        byNaming = new Map();
+        shapePropertiesCache.set(shape, byNaming);
+    }
+    let byKey = byNaming.get(keyedBy);
+    if (byKey)
+        return byKey;
+    byKey = new Map();
+    for (const [jsName, prop] of Object.entries(shape.byJsName)) {
+        // `armPath[0]` rather than the whole path: that is the top-level
+        // wire key, even for properties hoisted through `@flattenProperty`.
+        const key = keyedBy === "js" ? jsName : prop.armPath[0];
+        // First writer wins, so a hoisted property never shadows the
+        // wrapper it was hoisted through.
+        if (key !== undefined && !byKey.has(key))
+            byKey.set(key, prop);
+    }
+    byNaming.set(keyedBy, byKey);
+    return byKey;
+}
+/**
+ * Flatten a group to the concrete flat shapes underneath it,
+ * dereferencing thunks and descending through nested groups.
+ */
+function flattenVariants(group, seen) {
+    if (seen.has(group))
+        return [];
+    seen.add(group);
+    const out = [];
+    for (const key of Object.keys(group.byValue)) {
+        let entry = group.byValue[key];
+        if (entry?.kind === "deferred")
+            entry = entry.value();
+        if (entry === undefined)
+            continue;
+        if (entry.kind === "flatModel")
+            out.push(entry);
+        else
+            out.push(...flattenVariants(entry, seen));
+    }
+    return out;
+}
+/**
+ * Navigate `nav` one step deeper using `segment`. For string segments
+ * (`.foo`) at a model position, returns the property's shape entry as
+ * `stamp` and advances `next` into the property's target. For numeric
+ * segments (`[i]`) or string keys at a record position, peels one
+ * container layer; `stamp` is always `undefined`.
+ *
+ * Returns `{ stamp: undefined, next: undefined }` when the step can't
+ * be resolved (unknown property, out-of-shape access, etc.) — the
+ * access is treated as passthrough.
+ *
+ * @param nav - Where navigation currently sits.
+ * @param segment - The member name or array index being accessed.
+ * @param value - The value sitting at `nav`, when the caller has one.
+ *   Consulted only at a {@link DiscriminatedModelShape} position, to
+ *   select the variant via {@link resolveModelShape}. Always read with
+ *   `"js"` naming, since navigation follows client-facing property
+ *   names. Callers with no value — an `Expression<T>` proxy, for
+ *   instance — omit it and get passthrough for discriminated
+ *   positions, which is the honest answer when the variant is
+ *   unknowable.
+ */
+export function navigateShape(nav, segment, value) {
+    if (typeof segment === "number") {
+        return { stamp: undefined, next: peelContainer(nav, segment) };
+    }
+    if (isModelShape(nav)) {
+        const flat = resolveModelShape(nav, asRecord(value));
+        const stamp = flat?.byJsName[segment];
+        if (!stamp)
+            return { stamp: undefined, next: undefined };
+        return { stamp, next: derefTarget(stamp.value) };
+    }
+    // String segment against a container — treat as a record key access.
+    if (nav && nav.kind === "record") {
+        return { stamp: undefined, next: derefTarget(nav.value) };
+    }
+    return { stamp: undefined, next: undefined };
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function isModelShape(nav) {
+    return nav !== undefined && (nav.kind === "flatModel" || nav.kind === "discriminatedModel");
+}
+/**
+ * Peel one container layer off `nav`. Returns `undefined` for
+ * non-containers (caller treats the step as passthrough).
+ */
+function peelContainer(nav, index) {
+    if (!nav || isModelShape(nav))
+        return undefined;
+    if (nav.kind === "array")
+        return derefTarget(nav.element);
+    if (nav.kind === "record")
+        return derefTarget(nav.value);
+    return derefTarget(nav.values[index]);
+}
+/**
+ * Convert a {@link ValueShape} — where a property *points* — into a
+ * {@link NavShape} — where navigation now *is*.
+ *
+ * The only real work is forcing a {@link DeferredShape} thunk; the
+ * resolved model becomes the new position whether or not it is
+ * discriminated, since {@link navigateShape} can look up properties on
+ * either. Container shapes pass through unchanged, pending an index
+ * step.
+ *
+ * Deliberately *not* named `resolve*` — that prefix belongs to
+ * {@link resolveModelShape}, which picks a variant and is a much
+ * heavier operation.
+ */
+function derefTarget(shape) {
+    if (!shape || isTerminalValueShape(shape))
+        return undefined;
+    if (shape.kind === "deferred")
+        return shape.value();
+    return shape;
+}
+//# sourceMappingURL=shape.js.map

package/dist/browser/shape/shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.js","sourceRoot":"","sources":["../../../src/shape/shape.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\n/**\n * Runtime types for ARM shape information.\n *\n * A `ModelShape` is generated once per emitted Model and describes how\n * to map JS-ergonomic property names + structure to the underlying ARM\n * wire shape. The shapes are consumed by the serialization `lowerState`\n * pass (and its inverse `raiseState`) which rewrites state keys and\n * re-nests `@flattenProperty` paths just before serialization /\n * after deserialization.\n *\n * These types are an internal cross-package runtime contract; generated code\n * imports them from `@azure/provisioning-core/internal`.\n *\n * Nested-shape thunks ({@link DeferredShape}) defer dereferencing the\n * inner shape constant until use, so mutually-referential or\n * self-referential models can be emitted without initialization-order\n * problems.\n *\n * A model shape comes in two flavors:\n *   - `FlatModelShape` ({@link FlatModelShape}): the common case —\n *     one shape per concrete model.\n *   - `DiscriminatedModelShape` ({@link DiscriminatedModelShape}): a\n *     name-discriminated variant group. ARM permits multiple resources\n *     to share an ARM `type` + `apiVersion` pair and disambiguate via a\n *     fixed field — e.g. `Microsoft.ApiManagement/service/portalsettings@2024-05-01`\n *     has three variants with `name: 'signin' | 'signup' | 'delegation'`\n *     and distinct `properties` shapes. The same machinery applies to\n *     nested models that use a `@discriminator` field.\n */\nimport type {\n  BooleanValueEncodingDescriptor,\n  BytesValueEncodingDescriptor,\n  DateValueEncodingDescriptor,\n  NumberValueEncodingDescriptor,\n  NumericStringEncodingDescriptor,\n  StringValueEncodingDescriptor,\n} from \"./value-encoding.js\";\n\n/** The standard single-model shape. */\nexport interface FlatModelShape {\n  /**\n   * Tag for tag-dispatched discrimination on {@link NavShape} and\n   * {@link ModelShape}. Always `\"flatModel\"`.\n   */\n  readonly kind: \"flatModel\";\n  /**\n   * Map, keyed by JS-side (client-facing) property name, of how that\n   * property maps to the ARM wire shape. Property names not present in\n   * this map are assumed to be pass-through (identity mapping).\n   */\n  readonly byJsName: { readonly [jsName: string]: PropertyShape };\n}\n\n/**\n * The two names a discriminator field goes by.\n *\n * Usually identical — ARM discriminators are `type`, `name`, `kind` and\n * service teams rarely rename them — but a `@clientName` on the field\n * makes them differ, and the two are looked up in different keyspaces:\n * JS-side state is keyed by {@link jsName}, wire JSON by\n * {@link armName}. Carrying both is what lets a discriminated shape\n * resolve in either direction.\n */\nexport interface DiscriminatorNames {\n  /** Client-facing name, as authored in TypeScript and held in state. */\n  readonly jsName: string;\n  /** Wire-level name, as it appears in an ARM template or response. */\n  readonly armName: string;\n}\n\n/**\n * A name-discriminated group of variants that share one parent key\n * (an ARM `(type, apiVersion)` at the registry level, or a parent\n * model's `@discriminator` field elsewhere). The `discriminator` names\n * the field whose value selects a variant.\n */\nexport interface DiscriminatedModelShape {\n  readonly kind: \"discriminatedModel\";\n  /** Names of the field used to select a variant. */\n  readonly discriminator: DiscriminatorNames;\n  /**\n   * Map from discriminator value (e.g. `\"signin\"`) to the shape for\n   * that variant. A value with no entry here doesn't end resolution —\n   * {@link resolveModelShape} infers the variant from the payload's\n   * structure instead.\n   *\n   * Entries may be:\n   *  - a {@link FlatModelShape} — the terminal, common case;\n   *  - a {@link DeferredShape} — breaks emit-order / cyclic-reference\n   *    hazards, exactly as {@link PropertyShape.value} does;\n   *  - a nested {@link DiscriminatedModelShape} — a variant that is\n   *    itself a discriminated base on a *different* field. TypeSpec\n   *    permits this (`@discriminator(\"kind\") model Pet`, then\n   *    `@discriminator(\"breed\") model Cat extends Pet`), so selecting\n   *    a concrete shape may take more than one hop. See\n   *    {@link resolveModelShape}.\n   *\n   * Note that a hierarchy re-using the *same* discriminator field at\n   * every level (abstract intermediates) is flattened by the emitter\n   * into a single level here — only a change of discriminator field\n   * produces a nested entry.\n   */\n  readonly byValue: {\n    readonly [value: string]: ModelShape | DeferredShape<ModelShape>;\n  };\n}\n\n/** A single model's shape — either flat or discriminated. */\nexport type ModelShape = FlatModelShape | DiscriminatedModelShape;\n\n/**\n * What `registerShape` stores in the global registry, keyed by\n * `(armType, apiVersion)`. Same structural type as {@link ModelShape};\n * the alias documents intent at the registry boundary.\n */\nexport type ResourceShape = ModelShape;\n\n/** A single property's shape entry. */\nexport interface PropertyShape {\n  /**\n   * ARM wire path from the owning model's root to this property.\n   * Single-segment for direct properties; multi-segment for properties\n   * hoisted through one or more `@flattenProperty` wrappers.\n   */\n  readonly armPath: readonly string[];\n\n  /**\n   * Describes this property's value for navigation and wire conversion.\n   * Model and container shapes recurse into nested values; a\n   * {@link TerminalValueShape} explicitly terminates recursion. Scalar\n   * terminal shapes carry only the encodings valid for their client-side\n   * JavaScript representation.\n   */\n  readonly value: ValueShape;\n\n  /**\n   * `true` when ARM treats this property as server-set (visible in GET\n   * responses but rejected on PUT). Omitted (i.e. `undefined`/`false`)\n   * for writable properties.\n   *\n   * Currently consumed by the `Resource` constructor's deployment-context\n   * inheritance to skip readonly properties (notably `location` on many\n   * child resources where the field exists in the read model only).\n   */\n  readonly readOnly?: boolean;\n}\n\n/**\n * Deferred reference to a shape value. The thunk is called on\n * dereference so the actual shape lookup is deferred.\n *\n * **Why this exists instead of embedding the shape directly.**\n *\n * Model shapes frequently reference each other — a model's properties\n * can point to other models, and ARM types include both self-\n * referential (tree-like) and mutually-referential (cyclic) structures.\n * If we embedded a {@link ModelShape} value directly inside another\n * model shape's value field, both shapes would need to be fully\n * initialized when the parent is constructed. That's impossible\n * whenever:\n *\n *   - A model references itself, e.g. `TreeNode { children: TreeNode[] }`.\n *   - Two models reference each other, e.g. `A { b?: B }` and `B { a?: A }`.\n *   - Two modules each define shapes that reference shapes from the other.\n *\n * In all three cases the second constant is in the Temporal Dead Zone\n * when the first one's literal evaluates, and the runtime throws\n * `ReferenceError: Cannot access ... before initialization`.\n *\n * Wrapping the reference in a thunk solves it. The closure captures\n * the *binding name*, not its current value. The lookup happens later\n * when the thunk is called — by which time the module graph has\n * finished evaluating and both shapes are fully constructed.\n *\n * Only the model variant of {@link ValueShape} carries a reference —\n * container shapes (`array`, `record`) are eager because they don't\n * reference any module-level binding directly; the inner reference\n * deeper down handles cycle-breaking.\n */\nexport interface DeferredShape<T> {\n  readonly kind: \"deferred\";\n  readonly value: () => T;\n}\n\n/** An array-of-T property/container shape. */\nexport interface ArrayShape {\n  readonly kind: \"array\";\n  readonly element: ValueShape;\n}\n\n/** A `Record<string, T>` property/container shape. */\nexport interface RecordShape {\n  readonly kind: \"record\";\n  readonly value: ValueShape;\n}\n\n/** A fixed-length heterogeneous tuple property/container shape. */\nexport interface TupleShape {\n  readonly kind: \"tuple\";\n  readonly values: readonly ValueShape[];\n}\n\n/** A TypeSpec scalar rendered as TypeScript `any`. */\nexport interface AnyShape {\n  readonly kind: \"any\";\n}\n\n/** A scalar whose client-side JavaScript representation is `string`. */\nexport interface StringShape {\n  readonly kind: \"string\";\n  readonly encoding?: StringValueEncodingDescriptor;\n}\n\n/** A scalar whose client-side JavaScript representation is `boolean`. */\nexport interface BooleanShape {\n  readonly kind: \"boolean\";\n  readonly encoding?: BooleanValueEncodingDescriptor;\n}\n\n/** A scalar whose client-side JavaScript representation is `number`. */\nexport interface NumberShape {\n  readonly kind: \"number\";\n  readonly encoding?: NumberValueEncodingDescriptor;\n}\n\n/** A scalar whose client-side JavaScript representation is `Uint8Array`. */\nexport interface BytesShape {\n  readonly kind: \"bytes\";\n  readonly encoding?: BytesValueEncodingDescriptor;\n}\n\n/** A scalar whose client-side JavaScript representation is `Date`. */\nexport interface DateShape {\n  readonly kind: \"date\";\n  readonly encoding?: DateValueEncodingDescriptor;\n}\n\n/** A terminal TypeSpec string literal. Literals cannot carry `@encode`. */\nexport interface StringLiteralShape {\n  readonly kind: \"stringLiteral\";\n}\n\n/** A terminal TypeSpec numeric literal. */\nexport interface NumberLiteralShape {\n  readonly kind: \"numberLiteral\";\n  /** `@encode(string)` when the numeric literal is exposed as wire text. */\n  readonly encoding?: NumericStringEncodingDescriptor;\n}\n\n/** A terminal TypeSpec boolean literal. */\nexport interface BooleanLiteralShape {\n  readonly kind: \"booleanLiteral\";\n  /** `@encode(string)` while the client value remains a boolean literal. */\n  readonly encoding?: BooleanValueEncodingDescriptor;\n}\n\n/** A terminal TypeSpec enum. Enums cannot carry `@encode`. */\nexport interface EnumShape {\n  readonly kind: \"enum\";\n}\n\n/**\n * A terminal TypeSpec union for which no single structural shape can be\n * selected. Unions cannot carry `@encode` in the provisioning emitter.\n */\nexport interface UnionShape {\n  readonly kind: \"union\";\n}\n\n/** The TypeSpec `null` intrinsic. */\nexport interface NullShape {\n  readonly kind: \"null\";\n}\n\n/**\n * Concrete terminal values in the generated client API.\n *\n * Scalar kinds describe the JavaScript value accepted by the generated\n * TypeScript surface, not necessarily the semantic TypeSpec scalar. For\n * example, a numeric `duration` is a {@link NumberShape}, while the default\n * ISO8601 duration is a {@link StringShape}; their narrowed `encoding` fields\n * retain the TypeSpec source semantics needed for wire conversion. Numeric and\n * boolean literal shapes can carry the same narrowly applicable encodings that\n * TypeSpec permits on those values. String literals, enums, unions, and null\n * remain distinct non-encodable terminal categories.\n * Expressions are orthogonal wrappers around any value shape and are handled\n * before shape-directed conversion.\n */\nexport type TerminalValueShape =\n  | AnyShape\n  | StringShape\n  | BooleanShape\n  | NumberShape\n  | BytesShape\n  | DateShape\n  | StringLiteralShape\n  | NumberLiteralShape\n  | BooleanLiteralShape\n  | EnumShape\n  | UnionShape\n  | NullShape;\n\n/** A container through which property navigation can continue. */\nexport type ContainerShape = ArrayShape | RecordShape | TupleShape;\n\nexport type ValueShape = TerminalValueShape | DeferredShape<ModelShape> | ContainerShape;\n\n// ---------------------------------------------------------------------------\n// Constructor helpers\n// ---------------------------------------------------------------------------\n\n/** Build a {@link FlatModelShape} from a property map. */\nexport const createFlatModelShape = (byJsName: Record<string, PropertyShape>): FlatModelShape => ({\n  kind: \"flatModel\",\n  byJsName,\n});\n\n/**\n * Build a {@link DiscriminatedModelShape}.\n *\n * Pass a bare string when the field goes by the same name on both\n * sides, which is the overwhelmingly common case; pass a\n * {@link DiscriminatorNames} pair when a `@clientName` makes them\n * differ.\n */\nexport const createDiscriminatedModelShape = (\n  discriminator: string | DiscriminatorNames,\n  byValue: Record<string, ModelShape | DeferredShape<ModelShape>>,\n): DiscriminatedModelShape => ({\n  kind: \"discriminatedModel\",\n  discriminator:\n    typeof discriminator === \"string\"\n      ? { jsName: discriminator, armName: discriminator }\n      : discriminator,\n  byValue,\n});\n\n/**\n * Build a {@link DeferredShape}. The thunk is called on dereference; defer\n * the actual shape lookup so that mutually-referential constants can\n * be emitted in any order.\n */\nexport const createDeferredShape = <T>(value: () => T): DeferredShape<T> => ({\n  kind: \"deferred\",\n  value,\n});\n\n/** Build an {@link AnyShape}. */\nexport const createAnyShape = (): AnyShape => ({ kind: \"any\" });\n\n/** Build a {@link StringShape}, optionally with a compatible wire encoding. */\nexport const createStringShape = (encoding?: StringValueEncodingDescriptor): StringShape => ({\n  kind: \"string\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a {@link BooleanShape}, optionally with a compatible wire encoding. */\nexport const createBooleanShape = (encoding?: BooleanValueEncodingDescriptor): BooleanShape => ({\n  kind: \"boolean\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a {@link NumberShape}, optionally with a compatible wire encoding. */\nexport const createNumberShape = (encoding?: NumberValueEncodingDescriptor): NumberShape => ({\n  kind: \"number\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a {@link BytesShape}, optionally with a compatible wire encoding. */\nexport const createBytesShape = (encoding?: BytesValueEncodingDescriptor): BytesShape => ({\n  kind: \"bytes\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a {@link DateShape}, optionally with a compatible wire encoding. */\nexport const createDateShape = (encoding?: DateValueEncodingDescriptor): DateShape => ({\n  kind: \"date\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a terminal {@link StringLiteralShape}. */\nexport const createStringLiteralShape = (): StringLiteralShape => ({\n  kind: \"stringLiteral\",\n});\n\n/** Build a terminal {@link NumberLiteralShape}. */\nexport const createNumberLiteralShape = (\n  encoding?: NumericStringEncodingDescriptor,\n): NumberLiteralShape => ({\n  kind: \"numberLiteral\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a terminal {@link BooleanLiteralShape}. */\nexport const createBooleanLiteralShape = (\n  encoding?: BooleanValueEncodingDescriptor,\n): BooleanLiteralShape => ({\n  kind: \"booleanLiteral\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a terminal {@link EnumShape}. */\nexport const createEnumShape = (): EnumShape => ({ kind: \"enum\" });\n\n/** Build a terminal {@link UnionShape}. */\nexport const createUnionShape = (): UnionShape => ({ kind: \"union\" });\n\n/** Build a terminal {@link NullShape}. */\nexport const createNullShape = (): NullShape => ({ kind: \"null\" });\n\n/** Build an {@link ArrayShape}. */\nexport const createArrayShape = (element: ValueShape): ArrayShape => ({\n  kind: \"array\",\n  element,\n});\n\n/** Build a {@link RecordShape}. */\nexport const createRecordShape = (value: ValueShape): RecordShape => ({\n  kind: \"record\",\n  value,\n});\n\n/** Build a {@link TupleShape}. */\nexport const createTupleShape = (values: readonly ValueShape[]): TupleShape => ({\n  kind: \"tuple\",\n  values,\n});\n\n/** Return whether a value shape terminates property navigation. */\nexport function isTerminalValueShape(shape: ValueShape): shape is TerminalValueShape {\n  switch (shape.kind) {\n    case \"any\":\n    case \"string\":\n    case \"boolean\":\n    case \"number\":\n    case \"bytes\":\n    case \"date\":\n    case \"stringLiteral\":\n    case \"numberLiteral\":\n    case \"booleanLiteral\":\n    case \"enum\":\n    case \"union\":\n    case \"null\":\n      return true;\n    case \"deferred\":\n    case \"array\":\n    case \"record\":\n    case \"tuple\":\n      return false;\n    default:\n      return assertNeverShape(shape);\n  }\n}\n\nfunction assertNeverShape(shape: never): never {\n  throw new Error(`Unhandled value shape: ${String(shape)}`);\n}\n\n// ---------------------------------------------------------------------------\n// Helpers used by the runtime proxy + lowering pass\n// ---------------------------------------------------------------------------\n\n/**\n * Runtime navigation position for a typed proxy. Either:\n *   - a {@link ModelShape} — we're at a model's properties, whether or\n *     not its variant is known,\n *   - a {@link ContainerShape} — we're at a container that hasn't yet been\n *     indexed,\n *   - `undefined` — the current position is terminal, unknown, or the proxy\n *     was created without a shape.\n *\n * Proxies carry a `NavShape` through each access so they can stamp and\n * resolve the correct shape on deeper navigation.\n *\n * Navigation never sits at a {@link DeferredShape} — refs are resolved\n * eagerly as soon as the proxy encounters them.\n */\nexport type NavShape = ModelShape | ContainerShape | undefined;\n\n/**\n * Resolve a {@link ModelShape} to the single concrete variant that\n * applies to `value`.\n *\n * Resolution is iterative, not a single step, because a variant may\n * itself be a discriminated group keyed on a *different* field (see\n * {@link DiscriminatedModelShape.byValue}). Each hop reads its own\n * discriminator out of the same `value`, so\n * `{ kind: \"cat\", breed: \"siamese\" }` resolves through `Pet` → `Cat`\n * → `Siamese`. {@link DeferredShape} entries are dereferenced in\n * place, and flat model shapes are returned as-is.\n *\n * When a hop's discriminator can't be read — it is absent, is not a\n * string (the *expression-valued* case), or names an unknown variant —\n * the variant is instead **inferred from the value's structure** by\n * {@link selectVariant}. That inference is sound rather than a guess:\n * ARM would reject a payload that doesn't match the variant its\n * discriminator selects, so a concrete payload determines the variant\n * even when the discriminator itself is only known at deploy time.\n *\n * Bicep takes the same position — a discriminator it can't evaluate at\n * compile time downgrades type checking for that object (diagnostic\n * `BCP225`) rather than failing the build.\n *\n * Returns `undefined` when `shape` is `undefined`, when there is no\n * `value` to infer from, or when the `byValue` graph is cyclic\n * (defensive; the emitter does not produce cycles here).\n *\n * @param shape - The shape to resolve. Flat shapes are returned\n *   unchanged, so callers can pass either kind without checking.\n * @param value - The object this shape describes, used both to read\n *   discriminators and to infer a variant when they can't be read.\n *   Omit it when no value exists (an `Expression<T>` proxy, say) and\n *   discriminated shapes will resolve to `undefined`.\n * @param valueKeyedBy - Which naming **`value`'s own keys** use — not\n *   the shape's. A {@link FlatModelShape} is the mapping *between* the\n *   two sides (one property is `secretVersion` in TypeScript and\n *   `version` on the wire), so inference has to read both sides in the\n *   same naming or nothing matches:\n *\n *   - `\"js\"` — client-facing names, as authored in TypeScript and held\n *     in a resource's state. These are\n *     {@link FlatModelShape.byJsName}'s own keys. Passed by\n *     `lowerState`, on state about to be serialized.\n *   - `\"arm\"` — wire names, as they appear in an ARM template or a\n *     service response. These are the first segment of each\n *     {@link PropertyShape.armPath}. Passed by `raiseState`, on JSON\n *     just parsed off the wire.\n *\n *   Has no effect when the discriminator resolves normally, and no\n *   effect at all for models whose properties map 1:1.\n */\nexport function resolveModelShape(\n  shape: ModelShape | undefined,\n  value: Record<string, unknown> | undefined,\n  valueKeyedBy: \"js\" | \"arm\" = \"js\",\n): FlatModelShape | undefined {\n  let current: ModelShape | DeferredShape<ModelShape> | undefined = shape;\n  const seen = new Set<ModelShape | DeferredShape<ModelShape>>();\n\n  while (current !== undefined) {\n    if (seen.has(current)) return undefined;\n    seen.add(current);\n\n    if (current.kind === \"deferred\") {\n      current = current.value();\n      continue;\n    }\n    if (current.kind === \"flatModel\") return current;\n\n    const group: DiscriminatedModelShape = current;\n    // Read the discriminator under the same naming as `value`'s own\n    // keys: JS-side state holds it under the client name, wire JSON\n    // under the ARM name. The two coincide for almost every ARM\n    // discriminator, but a `@clientName` on the field makes them\n    // differ, and reading the wrong one silently downgrades exact\n    // dispatch to structural inference below.\n    const names = group.discriminator;\n    const key = value?.[valueKeyedBy === \"js\" ? names.jsName : names.armName];\n    const next = typeof key === \"string\" ? group.byValue[key] : undefined;\n    if (next === undefined) {\n      return value ? selectVariant(group, value, valueKeyedBy) : undefined;\n    }\n    current = next;\n  }\n\n  return undefined;\n}\n\n/**\n * Infer which variant of `group` a value belongs to by structure.\n *\n * Every variant is scored by how many of the value's keys it declares,\n * descending into nested objects and containers so that variants which\n * are indistinguishable at the top level can still be told apart. CDN's\n * delivery-rule actions are exactly that case: all nine variants\n * declare `{ name, parameters }` and differ only inside `parameters`.\n *\n * The highest score wins; ties keep the earliest variant in `byValue`\n * order, which is stable emitter output. A tie means the tied variants\n * declare the same keys for the data given, and the emitter guarantees\n * that keys shared across variants map identically — so either choice\n * produces the same wire mapping for everything actually present.\n */\nfunction selectVariant(\n  group: DiscriminatedModelShape,\n  value: Record<string, unknown>,\n  valueKeyedBy: \"js\" | \"arm\",\n): FlatModelShape | undefined {\n  let best: FlatModelShape | undefined;\n  let bestScore = -1;\n\n  for (const variant of flattenVariants(group, new Set())) {\n    const score = scoreShape(variant, value, valueKeyedBy, new WeakSet());\n    if (score > bestScore) {\n      bestScore = score;\n      best = variant;\n    }\n  }\n\n  return best;\n}\n\n/** How many of `value`'s keys, recursively, `shape` accounts for. */\nfunction scoreShape(\n  shape: FlatModelShape,\n  value: Record<string, unknown>,\n  valueKeyedBy: \"js\" | \"arm\",\n  visiting: WeakSet<object>,\n): number {\n  if (visiting.has(value)) return 0;\n  visiting.add(value);\n\n  const byKey = getShapePropertiesMap(shape, valueKeyedBy);\n  let score = 0;\n\n  for (const [key, sub] of Object.entries(value)) {\n    const prop = byKey.get(key);\n    if (!prop) continue;\n    score += 1;\n    score += scoreNested(sub, prop.value, valueKeyedBy, visiting);\n  }\n\n  visiting.delete(value);\n  return score;\n}\n\n/**\n * Score one level deeper, through a property's target. Containers are\n * sampled at their first entry — enough to discriminate, and bounded\n * regardless of how large the value is.\n */\nfunction scoreNested(\n  value: unknown,\n  target: ValueShape | undefined,\n  valueKeyedBy: \"js\" | \"arm\",\n  visiting: WeakSet<object>,\n): number {\n  if (!target || isTerminalValueShape(target) || value === null || typeof value !== \"object\") {\n    return 0;\n  }\n\n  if (target.kind === \"array\") {\n    if (!Array.isArray(value) || value.length === 0) return 0;\n    return scoreNested(value[0], target.element, valueKeyedBy, visiting);\n  }\n\n  if (target.kind === \"record\") {\n    if (Array.isArray(value)) return 0;\n    const first = Object.values(value)[0];\n    if (first === undefined) return 0;\n    return scoreNested(first, target.value, valueKeyedBy, visiting);\n  }\n\n  if (target.kind === \"tuple\") {\n    if (!Array.isArray(value)) return 0;\n    return target.values.reduce(\n      (score, tupleValue, index) =>\n        score + scoreNested(value[index], tupleValue, valueKeyedBy, visiting),\n      0,\n    );\n  }\n\n  if (Array.isArray(value)) return 0;\n  const nested = resolveModelShape(target.value(), value as Record<string, unknown>, valueKeyedBy);\n  if (!nested) return 0;\n  return scoreShape(nested, value as Record<string, unknown>, valueKeyedBy, visiting);\n}\n\nconst shapePropertiesCache = new WeakMap<\n  FlatModelShape,\n  Map<\"js\" | \"arm\", Map<string, PropertyShape>>\n>();\n\n/**\n * A shape's properties as a map, keyed by the name they go by in the\n * requested naming. Pass the same naming the value uses and the two\n * line up, which is what lets {@link scoreShape} compare them.\n *\n * Memoized per (shape, naming): scoring calls this once per candidate\n * variant per level, so rebuilding would be wasteful.\n *\n * @param shape - The shape whose properties to map.\n * @param keyedBy - Which name to key by. Note this describes the *map\n *   being built*, not an incoming value — unlike the `valueKeyedBy`\n *   parameter the callers thread through.\n */\nfunction getShapePropertiesMap(\n  shape: FlatModelShape,\n  keyedBy: \"js\" | \"arm\",\n): Map<string, PropertyShape> {\n  let byNaming = shapePropertiesCache.get(shape);\n  if (!byNaming) {\n    byNaming = new Map();\n    shapePropertiesCache.set(shape, byNaming);\n  }\n  let byKey = byNaming.get(keyedBy);\n  if (byKey) return byKey;\n\n  byKey = new Map<string, PropertyShape>();\n  for (const [jsName, prop] of Object.entries(shape.byJsName)) {\n    // `armPath[0]` rather than the whole path: that is the top-level\n    // wire key, even for properties hoisted through `@flattenProperty`.\n    const key = keyedBy === \"js\" ? jsName : prop.armPath[0];\n    // First writer wins, so a hoisted property never shadows the\n    // wrapper it was hoisted through.\n    if (key !== undefined && !byKey.has(key)) byKey.set(key, prop);\n  }\n  byNaming.set(keyedBy, byKey);\n  return byKey;\n}\n\n/**\n * Flatten a group to the concrete flat shapes underneath it,\n * dereferencing thunks and descending through nested groups.\n */\nfunction flattenVariants(\n  group: DiscriminatedModelShape,\n  seen: Set<DiscriminatedModelShape>,\n): FlatModelShape[] {\n  if (seen.has(group)) return [];\n  seen.add(group);\n\n  const out: FlatModelShape[] = [];\n  for (const key of Object.keys(group.byValue)) {\n    let entry: ModelShape | DeferredShape<ModelShape> | undefined = group.byValue[key];\n    if (entry?.kind === \"deferred\") entry = entry.value();\n    if (entry === undefined) continue;\n    if (entry.kind === \"flatModel\") out.push(entry);\n    else out.push(...flattenVariants(entry, seen));\n  }\n  return out;\n}\n\n/**\n * Navigate `nav` one step deeper using `segment`. For string segments\n * (`.foo`) at a model position, returns the property's shape entry as\n * `stamp` and advances `next` into the property's target. For numeric\n * segments (`[i]`) or string keys at a record position, peels one\n * container layer; `stamp` is always `undefined`.\n *\n * Returns `{ stamp: undefined, next: undefined }` when the step can't\n * be resolved (unknown property, out-of-shape access, etc.) — the\n * access is treated as passthrough.\n *\n * @param nav - Where navigation currently sits.\n * @param segment - The member name or array index being accessed.\n * @param value - The value sitting at `nav`, when the caller has one.\n *   Consulted only at a {@link DiscriminatedModelShape} position, to\n *   select the variant via {@link resolveModelShape}. Always read with\n *   `\"js\"` naming, since navigation follows client-facing property\n *   names. Callers with no value — an `Expression<T>` proxy, for\n *   instance — omit it and get passthrough for discriminated\n *   positions, which is the honest answer when the variant is\n *   unknowable.\n */\nexport function navigateShape(\n  nav: NavShape,\n  segment: string | number,\n  value?: unknown,\n): { readonly stamp: PropertyShape | undefined; readonly next: NavShape } {\n  if (typeof segment === \"number\") {\n    return { stamp: undefined, next: peelContainer(nav, segment) };\n  }\n  if (isModelShape(nav)) {\n    const flat = resolveModelShape(nav, asRecord(value));\n    const stamp = flat?.byJsName[segment];\n    if (!stamp) return { stamp: undefined, next: undefined };\n    return { stamp, next: derefTarget(stamp.value) };\n  }\n  // String segment against a container — treat as a record key access.\n  if (nav && nav.kind === \"record\") {\n    return { stamp: undefined, next: derefTarget(nav.value) };\n  }\n  return { stamp: undefined, next: undefined };\n}\n\nfunction asRecord(value: unknown): Record<string, unknown> | undefined {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : undefined;\n}\n\nfunction isModelShape(nav: NavShape): nav is ModelShape {\n  return nav !== undefined && (nav.kind === \"flatModel\" || nav.kind === \"discriminatedModel\");\n}\n\n/**\n * Peel one container layer off `nav`. Returns `undefined` for\n * non-containers (caller treats the step as passthrough).\n */\nfunction peelContainer(nav: NavShape, index: number): NavShape {\n  if (!nav || isModelShape(nav)) return undefined;\n  if (nav.kind === \"array\") return derefTarget(nav.element);\n  if (nav.kind === \"record\") return derefTarget(nav.value);\n  return derefTarget(nav.values[index]);\n}\n\n/**\n * Convert a {@link ValueShape} — where a property *points* — into a\n * {@link NavShape} — where navigation now *is*.\n *\n * The only real work is forcing a {@link DeferredShape} thunk; the\n * resolved model becomes the new position whether or not it is\n * discriminated, since {@link navigateShape} can look up properties on\n * either. Container shapes pass through unchanged, pending an index\n * step.\n *\n * Deliberately *not* named `resolve*` — that prefix belongs to\n * {@link resolveModelShape}, which picks a variant and is a much\n * heavier operation.\n */\nfunction derefTarget(shape: ValueShape | undefined): NavShape {\n  if (!shape || isTerminalValueShape(shape)) return undefined;\n  if (shape.kind === \"deferred\") return shape.value();\n  return shape;\n}\n"]}

package/dist/browser/shape/value-encoding.d.ts

@@ -0,0 +1,121 @@
+export declare const INTEGER_SCALAR_NAMES: readonly ["integer", "safeint", "int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"];
+export type IntegerScalarName = (typeof INTEGER_SCALAR_NAMES)[number];
+export declare const NUMERIC_SCALAR_NAMES: readonly ["integer", "safeint", "int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64", "numeric", "decimal", "decimal128", "float", "float32", "float64"];
+export type NumericScalarName = (typeof NUMERIC_SCALAR_NAMES)[number];
+export declare function isIntegerScalarName(name: string): name is IntegerScalarName;
+export declare function isNumericScalarName(name: string): name is NumericScalarName;
+export interface DateTimeTextEncodingDescriptor {
+    readonly kind: "date-time-text";
+    readonly source: "utcDateTime" | "offsetDateTime";
+    readonly format: "rfc3339" | "rfc7231";
+    readonly clientMode: "client" | "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export interface UnixTimestampEncodingDescriptor {
+    readonly kind: "unix-timestamp";
+    readonly source: "utcDateTime";
+    readonly unit: "seconds";
+    readonly clientMode: "client" | "wire";
+    readonly wire: {
+        readonly kind: "integer";
+        readonly scalar: IntegerScalarName;
+    };
+}
+export interface DurationIso8601EncodingDescriptor {
+    readonly kind: "duration-iso8601";
+    readonly source: "duration";
+    readonly clientMode: "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export interface DurationNumericEncodingDescriptor {
+    readonly kind: "duration-numeric";
+    readonly source: "duration";
+    readonly unit: "seconds" | "milliseconds";
+    readonly clientMode: "wire";
+    readonly wire: {
+        readonly kind: "integer";
+        readonly scalar: IntegerScalarName;
+    };
+}
+export interface BytesEncodingDescriptor {
+    readonly kind: "bytes";
+    readonly source: "bytes";
+    readonly format: "base64" | "base64url";
+    readonly clientMode: "client" | "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export interface PlainDateEncodingDescriptor {
+    readonly kind: "plain-date";
+    readonly source: "plainDate";
+    readonly clientMode: "client" | "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export interface NumericStringEncodingDescriptor {
+    readonly kind: "numeric-string";
+    readonly source: "integer" | "number";
+    readonly sourceScalar: NumericScalarName;
+    readonly clientMode: "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export interface BooleanStringEncodingDescriptor {
+    readonly kind: "boolean-string";
+    readonly source: "boolean";
+    readonly clientMode: "client" | "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export type ValueEncodingDescriptor = DateTimeTextEncodingDescriptor | UnixTimestampEncodingDescriptor | DurationIso8601EncodingDescriptor | DurationNumericEncodingDescriptor | BytesEncodingDescriptor | PlainDateEncodingDescriptor | NumericStringEncodingDescriptor | BooleanStringEncodingDescriptor;
+/**
+ * Encodings whose client-side value is a JavaScript `string`.
+ *
+ * The source TypeSpec scalar can be a date/time, duration, byte sequence,
+ * numeric value, or boolean. `clientMode: "wire"` is the important invariant:
+ * it means the generated TypeScript API exposes the encoded string itself.
+ */
+export type StringValueEncodingDescriptor = (DateTimeTextEncodingDescriptor & {
+    readonly clientMode: "wire";
+}) | DurationIso8601EncodingDescriptor | (BytesEncodingDescriptor & {
+    readonly clientMode: "wire";
+}) | (PlainDateEncodingDescriptor & {
+    readonly clientMode: "wire";
+}) | NumericStringEncodingDescriptor | (BooleanStringEncodingDescriptor & {
+    readonly clientMode: "wire";
+});
+/** Encoding supported by a client-side JavaScript `boolean`. */
+export type BooleanValueEncodingDescriptor = BooleanStringEncodingDescriptor & {
+    readonly clientMode: "client";
+};
+/** Encodings whose client-side value is a JavaScript `number`. */
+export type NumberValueEncodingDescriptor = (UnixTimestampEncodingDescriptor & {
+    readonly clientMode: "wire";
+}) | DurationNumericEncodingDescriptor;
+/** Encoding supported by a client-side JavaScript `Uint8Array`. */
+export type BytesValueEncodingDescriptor = BytesEncodingDescriptor & {
+    readonly clientMode: "client";
+};
+/**
+ * Encodings whose client-side value is a JavaScript `Date`.
+ *
+ * `offsetDateTime` is intentionally absent: the emitter exposes it as a
+ * string so the original offset is not erased.
+ */
+export type DateValueEncodingDescriptor = (DateTimeTextEncodingDescriptor & {
+    readonly source: "utcDateTime";
+    readonly clientMode: "client";
+}) | (UnixTimestampEncodingDescriptor & {
+    readonly clientMode: "client";
+}) | (PlainDateEncodingDescriptor & {
+    readonly clientMode: "client";
+});
+//# sourceMappingURL=value-encoding.d.ts.map

package/dist/browser/shape/value-encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-encoding.d.ts","sourceRoot":"","sources":["../../../src/shape/value-encoding.ts"],"names":[],"mappings":"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"}