@player-tools/fluent 0.12.1--canary.241.6077

package/types/core/base-builder/errors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Error codes for fluent builder errors.
+ * Use these codes for programmatic error handling.
+ */
+export declare const ErrorCodes: {
+    /** Context is missing when required */
+    readonly MISSING_CONTEXT: "FLUENT_MISSING_CONTEXT";
+    /** Invalid branch type in ID generation */
+    readonly INVALID_BRANCH: "FLUENT_INVALID_BRANCH";
+    /** Template produced no output */
+    readonly TEMPLATE_NO_OUTPUT: "FLUENT_TEMPLATE_NO_OUTPUT";
+    /** Invalid path in value resolution */
+    readonly INVALID_PATH: "FLUENT_INVALID_PATH";
+};
+/**
+ * Type for error codes
+ */
+export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+/**
+ * Custom error class for fluent builder errors.
+ * Provides structured error information with error codes.
+ */
+export declare class FluentError extends Error {
+    readonly code: ErrorCode;
+    readonly context?: Record<string, unknown>;
+    constructor(code: ErrorCode, message: string, context?: Record<string, unknown>);
+}
+/**
+ * Creates a FluentError with the given code and message.
+ * This is a convenience function for creating errors.
+ *
+ * @param code - The error code from ErrorCodes
+ * @param message - Human-readable error message
+ * @param context - Optional context object with additional details
+ * @returns A FluentError instance
+ *
+ * @example
+ * throw createFluentError(
+ *   ErrorCodes.MISSING_CONTEXT,
+ *   "Context is required for template resolution",
+ *   { templateCount: 3 }
+ * );
+ */
+export declare function createFluentError(code: ErrorCode, message: string, context?: Record<string, unknown>): FluentError;
+//# sourceMappingURL=errors.d.ts.map

package/types/core/base-builder/fluent-builder-base.d.ts

@@ -0,0 +1,147 @@
+import type { template as easyDslTemplate } from "..";
+import { type BaseBuildContext, type ConditionalValue, type FluentPartial, FLUENT_BUILDER_SYMBOL } from "./types";
+import { ValueStorage } from "./storage/value-storage";
+import { AuxiliaryStorage } from "./storage/auxiliary-storage";
+import { switch_ } from "../switch";
+/**
+ * Base class for all generated builders
+ * Provides core functionality for the builder pattern with Player UI-specific features
+ *
+ * This class delegates to specialized components:
+ * - ValueStorage: Manages property values, builders, and mixed arrays
+ * - AuxiliaryStorage: Manages metadata (templates, switches)
+ * - Build Pipeline: Orchestrates the 8-step build process
+ * - Conditional Logic: Handles if/ifElse with auto-wrapping
+ */
+export declare abstract class FluentBuilderBase<T, C extends BaseBuildContext = BaseBuildContext> {
+    readonly [FLUENT_BUILDER_SYMBOL]: true;
+    protected valueStorage: ValueStorage<T>;
+    protected auxiliaryStorage: AuxiliaryStorage;
+    protected context?: C;
+    /**
+     * Creates a new builder instance
+     * @param initial - Optional initial values (accepts FluentPartial for TaggedTemplateValue support)
+     */
+    constructor(initial?: FluentPartial<T, C>);
+    /**
+     * Accessor for generated builders to access values
+     * This maintains backward compatibility with generated code
+     */
+    protected get values(): Partial<T>;
+    /**
+     * Setter for generated builders to set values in bulk
+     * Used by withAdditionalProperties() in generated builders
+     */
+    protected set values(newValues: Partial<T>);
+    /**
+     * Sets additional properties in bulk that may not be defined in the type schema
+     * Useful for extensibility and forward compatibility
+     */
+    withAdditionalProperties(values: Partial<T>): this;
+    /**
+     * Sets a property value, intelligently routing it to the appropriate storage
+     * @param key - The property key to set
+     * @param value - The value to set
+     * @returns This builder instance for chaining
+     */
+    protected set<K extends keyof T>(key: K, value: unknown): this;
+    /**
+     * Builds the final object with defaults and nested builder resolution
+     * Executes the complete 8-step build pipeline
+     *
+     * @param defaults - Optional default values
+     * @param context - Optional build context
+     */
+    protected buildWithDefaults(defaults?: Partial<T>, context?: C): T;
+    /**
+     * Gets array property metadata from the builder class
+     * Generated builders include a static __arrayProperties__ set
+     */
+    private getArrayPropertiesMetadata;
+    /**
+     * Gets asset wrapper paths metadata from the builder class.
+     * Generated builders include a static __assetWrapperPaths__ array of paths.
+     * Each path is an array of property names leading to an AssetWrapper.
+     */
+    protected getAssetWrapperPathsMetadata(): ReadonlyArray<ReadonlyArray<string>>;
+    /**
+     * Conditionally sets a property based on a predicate
+     *
+     * Accepts unwrapped Asset builders and automatically wraps them in AssetWrapper format.
+     *
+     * @param predicate - Function to determine if the property should be set
+     * @param property - The property key
+     * @param value - The value, builder, or function returning either
+     *
+     * @example
+     * action()
+     *   .if(() => showLabel, "label", text().withValue("Submit"))
+     */
+    if<K extends keyof T>(predicate: (builder: this) => boolean, property: K, value: ConditionalValue<T[K], C>): this;
+    /**
+     * Conditionally sets a property choosing between two values
+     *
+     * Accepts unwrapped Asset builders and automatically wraps them in AssetWrapper format.
+     *
+     * @param predicate - Function to determine which value to use
+     * @param property - The property key
+     * @param trueValue - Value to use if predicate is true
+     * @param falseValue - Value to use if predicate is false
+     *
+     * @example
+     * action()
+     *   .ifElse(
+     *     () => isActive,
+     *     "label",
+     *     text().withValue("Deactivate"),
+     *     text().withValue("Activate")
+     *   )
+     */
+    ifElse<K extends keyof T>(predicate: (builder: this) => boolean, property: K, trueValue: ConditionalValue<T[K], C>, falseValue: ConditionalValue<T[K], C>): this;
+    /**
+     * Checks if a property has been set
+     */
+    has<K extends keyof T>(key: K): boolean;
+    /**
+     * Peeks at a property value without resolving builders
+     */
+    peek<K extends keyof T>(key: K): T[K] | undefined;
+    /**
+     * Gets builder for a property if one is set
+     */
+    peekBuilder<K extends keyof T>(key: K): import("./types").FluentBuilder<T[K], C> | undefined;
+    /**
+     * Gets the type of value stored for a property
+     */
+    getValueType<K extends keyof T>(key: K): "static" | "builder" | "mixed-array" | "unset";
+    /**
+     * Clones the builder, creating an independent copy with the same state.
+     *
+     * Note: This method requires that the builder class has a constructor that
+     * accepts an optional `initial` parameter (like all generated builders do).
+     * If your custom builder has required constructor parameters, you must
+     * override this method.
+     */
+    clone(): this;
+    /**
+     * Unsets a property, removing it from the builder
+     */
+    unset<K extends keyof T>(key: K): this;
+    /**
+     * Clears all properties from the builder, resetting it to initial state
+     */
+    clear(): this;
+    /**
+     * Adds a template to this builder
+     */
+    template(templateFn: ReturnType<typeof easyDslTemplate>): this;
+    /**
+     * Adds a switch to this builder at a specific path
+     */
+    switch(path: ReadonlyArray<string | number>, switchFnArgs: Parameters<typeof switch_>[0]): this;
+    /**
+     * Abstract build method to be implemented by generated builders
+     */
+    abstract build(context?: C): T;
+}
+//# sourceMappingURL=fluent-builder-base.d.ts.map

package/types/core/base-builder/guards.d.ts

@@ -0,0 +1,58 @@
+import type { Asset, AssetWrapper } from "@player-ui/types";
+import type { BaseBuildContext, FluentBuilder } from "./types";
+/**
+ * Type guard to check if a value is a FluentBuilder instance
+ * Checks for the builder symbol and build method
+ */
+export declare function isFluentBuilder<T = unknown, C extends BaseBuildContext = BaseBuildContext>(value: unknown): value is FluentBuilder<T, C>;
+/**
+ * Type guard to check if a value is an array of FluentBuilders
+ */
+export declare function isBuilderArray<T = unknown, C extends BaseBuildContext = BaseBuildContext>(value: unknown): value is Array<FluentBuilder<T, C>>;
+/**
+ * Type guard to check if a value is a plain object (not a class instance)
+ * Returns true for objects created with {} or Object.create(null)
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type guard to check if a value is an Asset (has required 'type' property)
+ * Assets are the core building blocks in Player UI
+ */
+export declare function isAsset(value: unknown): value is Asset;
+/**
+ * Type guard to check if a value is an AssetWrapper
+ * AssetWrapper has a single 'asset' property containing the wrapped value
+ */
+export declare function isAssetWrapper<T extends Asset = Asset>(value: unknown): value is AssetWrapper<T>;
+/**
+ * Type guard to check if a value is an AssetWrapper containing an Asset
+ * More strict than isAssetWrapper - verifies the wrapped value is actually an Asset
+ */
+export declare function isAssetWrapperWithAsset<T extends Asset = Asset>(value: unknown): value is AssetWrapper<T>;
+/**
+ * Type guard to check if a value is an AssetWrapper value object
+ * This is the internal representation: { asset: unknown }
+ * Used to detect values that need special handling during build
+ */
+export declare function isAssetWrapperValue(value: unknown): value is {
+    asset: unknown;
+};
+/**
+ * Determines if a property value needs to be wrapped in AssetWrapper format
+ * Used during value storage to decide wrapping strategy
+ */
+export declare function needsAssetWrapper(value: unknown): boolean;
+/**
+ * Type guard to check if a value is a switch result object
+ * Switch results contain staticSwitch or dynamicSwitch arrays
+ */
+export declare function isSwitchResult(value: unknown): value is Record<string, unknown> & {
+    staticSwitch?: unknown[];
+    dynamicSwitch?: unknown[];
+};
+/**
+ * Type guard to check if a value is a string or undefined
+ * Useful for validating optional string properties
+ */
+export declare function isStringOrUndefined(value: unknown): value is string | undefined;
+//# sourceMappingURL=guards.d.ts.map

package/types/core/base-builder/id/generator.d.ts

@@ -0,0 +1,69 @@
+import { type AssetMetadata, type BaseBuildContext } from "../types";
+export { globalIdRegistry, createIdRegistry, IDRegistry } from "./registry";
+/**
+ * Resets the global ID registry, clearing all registered IDs.
+ * This is useful for testing scenarios where you need a clean slate.
+ */
+export declare const resetGlobalIdSet: () => void;
+/**
+ * Generates an ID without registering it in the global registry.
+ * This is useful for intermediate ID lookups where you don't want to consume the ID.
+ *
+ * @param context - The context containing parent ID and optional branch information
+ * @returns The generated ID (without collision detection or registration)
+ *
+ * @example
+ * // Use this when you need to generate a parent ID for nested context creation
+ * const parentId = peekId({ parentId: 'collection' }); // Doesn't register 'collection'
+ * const nestedCtx = { parentId, branch: { type: 'slot', name: 'label' } };
+ */
+export declare const peekId: (context: BaseBuildContext) => string;
+/**
+ * Generates a unique identifier based on the parent ID and branch information.
+ *
+ * This function creates hierarchical IDs for various element types in a DSL structure,
+ * maintaining relationships between parent and child elements through consistent naming patterns.
+ * IDs are automatically checked for uniqueness and modified if collisions are detected.
+ *
+ * @param {BaseBuildContext} context - The context containing parent ID and optional branch information
+ * @param {string} context.parentId - The ID of the parent element
+ * @param {IdBranch} [context.branch] - Optional branch information to specify the type of child element
+ *
+ * @returns {string} A generated ID string representing the element's unique identifier
+ *
+ * @throws {Error} If context is invalid or incomplete
+ *
+ * @example
+ * // Slot branch
+ * genId({ parentId: 'parent', branch: { type: 'slot', name: 'header' } })
+ * // Returns: 'parent-header'
+ *
+ * @example
+ * // Array item branch
+ * genId({ parentId: 'list', branch: { type: 'array-item', index: 2 } })
+ * // Returns: 'list-2'
+ *
+ * @example
+ * // Template branch
+ * genId({ parentId: 'template', branch: { type: 'template', depth: 1 } })
+ * // Returns: 'template-_index1_'
+ *
+ * @example
+ * // Switch branch
+ * genId({ parentId: 'condition', branch: { type: 'switch', index: 0, kind: 'static' } })
+ * // Returns: 'condition-staticSwitch-0'
+ *
+ * @example
+ * // Custom ID case (no branch)
+ * genId({ parentId: 'custom-id' })
+ * // Returns: 'custom-id'
+ */
+export declare const genId: (context: BaseBuildContext) => string;
+export declare function determineSlotName(parameterName: string, assetMetadata?: AssetMetadata): string;
+export declare function generateAssetId<C extends BaseBuildContext>(params: {
+    readonly context?: C;
+    readonly parameterName?: string;
+    readonly assetMetadata?: AssetMetadata;
+    readonly explicitId?: string;
+}): string;
+//# sourceMappingURL=generator.d.ts.map

package/types/core/base-builder/id/registry.d.ts

@@ -0,0 +1,93 @@
+/**
+ * ID Registry for tracking and ensuring unique IDs across asset generation.
+ * This registry maintains a set of used IDs and provides collision resolution
+ * by appending numeric suffixes when duplicates are detected.
+ *
+ * Special handling for template placeholders:
+ * - IDs ending with template placeholders like `_index_`, `_row_` are allowed to be duplicated
+ * - IDs with placeholders followed by additional segments enforce uniqueness normally
+ */
+export declare class IDRegistry {
+    private usedIds;
+    private isEnabled;
+    constructor(enabled?: boolean);
+    /**
+     * Ensures the given ID is unique, modifying it if necessary.
+     * If the ID already exists, appends a numeric suffix (-1, -2, etc.)
+     * until a unique ID is found.
+     *
+     * Special handling for template placeholders:
+     * - IDs ending with `_index_`, `_row_`, etc. are allowed as duplicates
+     * - IDs with placeholders followed by segments (e.g., `_index_.field`) enforce uniqueness
+     *
+     * @param baseId - The desired ID
+     * @returns A unique ID (either the original or modified with suffix)
+     *
+     * @example
+     * ```typescript
+     * const registry = new IDRegistry();
+     * registry.ensureUnique("my-id");         // "my-id"
+     * registry.ensureUnique("my-id");         // "my-id-1"
+     * registry.ensureUnique("list-_index_");  // "list-_index_" (allowed duplicate)
+     * registry.ensureUnique("list-_index_");  // "list-_index_" (allowed duplicate)
+     * ```
+     */
+    ensureUnique(baseId: string): string;
+    /**
+     * Checks if an ID has already been used.
+     *
+     * @param id - The ID to check
+     * @returns true if the ID has been used, false otherwise
+     */
+    has(id: string): boolean;
+    /**
+     * Clears all registered IDs from the registry.
+     * Useful for resetting state between test runs or separate flows.
+     */
+    reset(): void;
+    /**
+     * Enables or disables the uniqueness checking.
+     * When disabled, all IDs pass through unchanged.
+     *
+     * @param enabled - Whether to enable uniqueness checking
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Returns the number of unique IDs currently registered.
+     *
+     * @returns The count of registered IDs
+     */
+    size(): number;
+    /**
+     * Returns a snapshot of all registered IDs.
+     * Useful for debugging and testing.
+     *
+     * @returns An array of all registered IDs
+     */
+    getRegisteredIds(): string[];
+    /**
+     * Checks if an ID contains template placeholders that should be exempt from uniqueness checks.
+     * Template placeholders are patterns like `_index_`, `_index1_`, `_row_` that are replaced at runtime.
+     *
+     * IDs ending with just a placeholder (e.g., "parent-_index_") are allowed as duplicates.
+     * IDs with placeholders followed by additional segments (e.g., "parent-_index_-field") are not.
+     *
+     * @param id - The ID to check
+     * @returns true if the ID should be exempt from uniqueness checks
+     */
+    private isTemplatePlaceholderID;
+}
+/**
+ * Global singleton instance of the ID registry.
+ * This ensures consistent ID tracking across the entire application.
+ */
+export declare const globalIdRegistry: IDRegistry;
+/**
+ * Creates a new isolated ID registry instance.
+ * Useful for testing or when you need separate ID tracking contexts.
+ *
+ * @param enabled - Whether the registry should be enabled by default
+ * @returns A new IDRegistry instance
+ */
+export declare function createIdRegistry(enabled?: boolean): IDRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/types/core/base-builder/index.d.ts

@@ -0,0 +1,9 @@
+export { FLUENT_BUILDER_SYMBOL, BranchTypes, StorageKeys, PropertyKeys, type NestedContextParams, type NestedContextGenerator, type AssetMetadata, type BaseBuildContext, type FluentBuilder, type AnyAssetBuilder, type MixedArrayMetadata, type TemplateMetadata, type IdBranch, type SlotBranch, type ArrayItemBranch, type TemplateBranch, type SwitchBranch, type CustomBranch, type ValuePath, type SwitchMetadata, type ConditionalValue, type FluentPartial, type FluentPartialValue, } from "./types";
+export { isFluentBuilder, isBuilderArray, isPlainObject, isAsset, isAssetWrapper, isAssetWrapperWithAsset, needsAssetWrapper, isAssetWrapperValue, isSwitchResult, isStringOrUndefined, } from "./guards";
+export { determineSlotName, generateAssetId, genId, peekId, resetGlobalIdSet, globalIdRegistry, createIdRegistry, IDRegistry, } from "./id/generator";
+export { createNestedContext, createTemplateContext, createSwitchContext, } from "./context";
+export { extractValue, resolveValue, resolveAndWrapAsset, } from "./resolution/value-resolver";
+export { FluentBuilderBase } from "./fluent-builder-base";
+export { createInspectMethod } from "./utils";
+export { ErrorCodes, FluentError, createFluentError, type ErrorCode, } from "./errors";
+//# sourceMappingURL=index.d.ts.map

package/types/core/base-builder/resolution/path-resolver.d.ts

@@ -0,0 +1,15 @@
+import type { ValuePath } from "../types";
+/**
+ * Sets a value at a nested path in an object
+ * Handles nested objects, arrays, and AssetWrapper structures
+ *
+ * @param obj - The target object to modify
+ * @param path - Array of keys/indices representing the path
+ * @param value - The value to set at the path
+ *
+ * @example
+ * setValueAtPath(obj, ["actions", 0, "label"], "Click me")
+ * // Sets obj.actions[0].label = "Click me"
+ */
+export declare function setValueAtPath(obj: Record<string, unknown>, path: ValuePath, value: unknown): void;
+//# sourceMappingURL=path-resolver.d.ts.map

package/types/core/base-builder/resolution/pipeline.d.ts

@@ -0,0 +1,27 @@
+import type { BaseBuildContext } from "../types";
+import type { ValueStorage } from "../storage/value-storage";
+import type { AuxiliaryStorage } from "../storage/auxiliary-storage";
+/**
+ * Executes the complete build pipeline
+ *
+ * The pipeline consists of 9 steps that transform builder state into a final object:
+ * 1. Resolve static values (extract TaggedTemplateValue, resolve simple builders)
+ * 2. Generate asset ID if needed
+ * 3. Create nested context for child assets
+ * 4. Resolve AssetWrapper values
+ * 5. Resolve mixed arrays
+ * 6. Resolve builders
+ * 7. Resolve nested AssetWrapper paths
+ * 8. Resolve switches
+ * 9. Resolve templates
+ *
+ * @param valueStorage - Storage containing property values
+ * @param auxiliaryStorage - Storage containing metadata (templates, switches)
+ * @param defaults - Optional default values to merge into result
+ * @param context - Optional build context
+ * @param arrayProperties - Set of property names that are array types
+ * @param assetWrapperPaths - Paths to nested AssetWrapper properties
+ * @returns The fully built object
+ */
+export declare function executeBuildPipeline<T, C extends BaseBuildContext>(valueStorage: ValueStorage<T>, auxiliaryStorage: AuxiliaryStorage, defaults: Partial<T> | undefined, context: C | undefined, arrayProperties: ReadonlySet<string>, assetWrapperPaths?: ReadonlyArray<ReadonlyArray<string>>): T;
+//# sourceMappingURL=pipeline.d.ts.map

package/types/core/base-builder/resolution/steps/asset-id.d.ts

@@ -0,0 +1,14 @@
+import type { BaseBuildContext } from "../../types";
+import type { ValueStorage } from "../../storage/value-storage";
+/**
+ * Step 2: Generates ID for this asset if needed
+ *
+ * Note: This runs AFTER resolveStaticValues, so we use values from result
+ * rather than from storage.
+ *
+ * @param storage - The value storage (used to check if ID was explicitly set)
+ * @param result - The result object being built (contains resolved values)
+ * @param context - Optional build context
+ */
+export declare function generateAssetIdForBuilder<T, C extends BaseBuildContext>(storage: ValueStorage<T>, result: Record<string, unknown>, context: C | undefined): void;
+//# sourceMappingURL=asset-id.d.ts.map

package/types/core/base-builder/resolution/steps/asset-wrappers.d.ts

@@ -0,0 +1,14 @@
+import type { BaseBuildContext } from "../../types";
+import type { ValueStorage } from "../../storage/value-storage";
+/**
+ * Step 4: Resolves AssetWrapper values in static storage
+ *
+ * Processes values that were marked as AssetWrapper during value setting.
+ * These values contain assets or builders that need special context handling.
+ *
+ * @param storage - The value storage
+ * @param result - The result object being built
+ * @param nestedParentContext - Context for nested assets
+ */
+export declare function resolveAssetWrappers<T, C extends BaseBuildContext>(storage: ValueStorage<T>, result: Record<string, unknown>, nestedParentContext: C | undefined): void;
+//# sourceMappingURL=asset-wrappers.d.ts.map

package/types/core/base-builder/resolution/steps/builders.d.ts

@@ -0,0 +1,14 @@
+import type { BaseBuildContext } from "../../types";
+import type { ValueStorage } from "../../storage/value-storage";
+/**
+ * Step 6: Resolves regular builders (non-array)
+ *
+ * Processes FluentBuilder instances and objects containing builders.
+ * Creates nested contexts for proper ID generation.
+ *
+ * @param storage - The value storage
+ * @param result - The result object being built
+ * @param nestedParentContext - Context for nested builders
+ */
+export declare function resolveBuilders<T, C extends BaseBuildContext>(storage: ValueStorage<T>, result: Record<string, unknown>, nestedParentContext: C | undefined): void;
+//# sourceMappingURL=builders.d.ts.map

package/types/core/base-builder/resolution/steps/mixed-arrays.d.ts

@@ -0,0 +1,14 @@
+import type { BaseBuildContext } from "../../types";
+import type { ValueStorage } from "../../storage/value-storage";
+/**
+ * Step 5: Resolves mixed arrays
+ *
+ * Processes arrays containing both builders and static values.
+ * Builders are resolved with proper context, static values pass through.
+ *
+ * @param storage - The value storage
+ * @param result - The result object being built
+ * @param nestedParentContext - Context for nested builders
+ */
+export declare function resolveMixedArrays<T, C extends BaseBuildContext>(storage: ValueStorage<T>, result: Record<string, unknown>, nestedParentContext: C | undefined): void;
+//# sourceMappingURL=mixed-arrays.d.ts.map

package/types/core/base-builder/resolution/steps/nested-asset-wrappers.d.ts

@@ -0,0 +1,14 @@
+import type { BaseBuildContext } from "../../types";
+/**
+ * Step 7: Resolves nested AssetWrapper paths
+ *
+ * This step handles cases where AssetWrapper properties are nested within
+ * interface types. It traverses paths like ["header", "left"] to find and
+ * wrap assets that should be in AssetWrapper format.
+ *
+ * @param result - The result object being built
+ * @param context - Context for nested assets
+ * @param assetWrapperPaths - Array of paths to AssetWrapper properties
+ */
+export declare function resolveNestedAssetWrappers<C extends BaseBuildContext>(result: Record<string, unknown>, context: C | undefined, assetWrapperPaths: ReadonlyArray<ReadonlyArray<string>>): void;
+//# sourceMappingURL=nested-asset-wrappers.d.ts.map

package/types/core/base-builder/resolution/steps/static-values.d.ts

@@ -0,0 +1,14 @@
+import type { BaseBuildContext } from "../../types";
+import type { ValueStorage } from "../../storage/value-storage";
+/**
+ * Step 1: Resolves static values
+ *
+ * Converts TaggedTemplateValue to strings and resolves nested FluentBuilders
+ * in static storage. AssetWrapper values are preserved for later processing.
+ *
+ * @param storage - The value storage containing static values
+ * @param result - The result object being built
+ * @param context - Optional build context
+ */
+export declare function resolveStaticValues<T, C extends BaseBuildContext>(storage: ValueStorage<T>, result: Record<string, unknown>, context: C | undefined): void;
+//# sourceMappingURL=static-values.d.ts.map

package/types/core/base-builder/resolution/steps/switches.d.ts

@@ -0,0 +1,15 @@
+import { type BaseBuildContext } from "../../types";
+import type { AuxiliaryStorage } from "../../storage/auxiliary-storage";
+/**
+ * Step 7: Resolves switches
+ *
+ * Processes switch expressions and injects them at the specified paths.
+ * Handles both static and dynamic switches with proper ID generation.
+ *
+ * @param auxiliaryStorage - Storage containing switch metadata
+ * @param result - The result object being built
+ * @param nestedParentContext - Context for switch resolution
+ * @param arrayProperties - Set of property names that are array types
+ */
+export declare function resolveSwitches<C extends BaseBuildContext>(auxiliaryStorage: AuxiliaryStorage, result: Record<string, unknown>, nestedParentContext: C | undefined, arrayProperties: ReadonlySet<string>): void;
+//# sourceMappingURL=switches.d.ts.map

package/types/core/base-builder/resolution/steps/templates.d.ts

@@ -0,0 +1,14 @@
+import { type BaseBuildContext } from "../../types";
+import type { AuxiliaryStorage } from "../../storage/auxiliary-storage";
+/**
+ * Step 8: Resolves templates
+ *
+ * Processes template functions and adds them to the result.
+ * Templates are special constructs that generate dynamic content.
+ *
+ * @param auxiliaryStorage - Storage containing template functions
+ * @param result - The result object being built
+ * @param context - Build context for template resolution
+ */
+export declare function resolveTemplates<C extends BaseBuildContext>(auxiliaryStorage: AuxiliaryStorage, result: Record<string, unknown>, context: C | undefined): void;
+//# sourceMappingURL=templates.d.ts.map

package/types/core/base-builder/resolution/value-resolver.d.ts

@@ -0,0 +1,62 @@
+import type { Asset, AssetWrapper } from "@player-ui/types";
+import { type BaseBuildContext } from "../types";
+/**
+ * Type-safe value extraction utilities for handling TaggedTemplateValue
+ * These functions properly unwrap TaggedTemplateValue while preserving structure
+ */
+interface ExtractValueOptions {
+    readonly propertyKey?: string;
+    readonly visited?: WeakSet<object>;
+}
+/**
+ * Recursively extracts values from a structure, converting TaggedTemplateValue instances
+ * to their string representations while preserving arrays and objects.
+ *
+ * **Return Type Note**: This function returns `unknown` because the input type is unknown
+ * and the transformation can change types (TaggedTemplateValue -> string). Callers should
+ * validate the returned value using type guards before using it.
+ *
+ * **Transformation Behavior**:
+ * - `TaggedTemplateValue` → `string` (via toString() or toValue())
+ * - Arrays → Arrays (elements recursively transformed)
+ * - Plain objects → Objects (properties recursively transformed)
+ * - FluentBuilder/AssetWrapper → passed through unchanged (resolved later)
+ * - Primitives → passed through unchanged
+ *
+ * @param value - The value to extract (may contain TaggedTemplateValue instances)
+ * @param options - Extraction options (propertyKey for special handling, visited for cycle detection)
+ * @returns The extracted value with TaggedTemplateValue instances converted to strings
+ *
+ * @example
+ * ```typescript
+ * const result = extractValue({ name: taggedTemplate`Hello` });
+ * // result is { name: "Hello" } but typed as unknown
+ *
+ * // Caller must validate:
+ * if (isPlainObject(result)) {
+ *   const name = result.name; // Use safely
+ * }
+ * ```
+ */
+export declare function extractValue(value: unknown, options?: ExtractValueOptions): unknown;
+interface ResolveValueOptions<C extends BaseBuildContext = BaseBuildContext> {
+    readonly context?: C;
+    readonly propertyName?: string;
+    readonly visited?: WeakSet<object>;
+}
+/**
+ * Resolves a value, handling FluentBuilders, AssetWrappers, and nested structures
+ */
+export declare function resolveValue<T, C extends BaseBuildContext>(value: unknown, options?: ResolveValueOptions<C>): unknown;
+interface ResolveAndWrapAssetOptions<C extends BaseBuildContext = BaseBuildContext> {
+    readonly context?: C;
+    readonly slotName: string;
+    readonly visited?: WeakSet<object>;
+}
+/**
+ * Resolves and wraps a nested asset value
+ * This is used when we know a property should contain an AssetWrapper
+ */
+export declare function resolveAndWrapAsset<C extends BaseBuildContext>(value: unknown, options: ResolveAndWrapAssetOptions<C>): AssetWrapper<Asset> | unknown;
+export {};
+//# sourceMappingURL=value-resolver.d.ts.map