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

package/types/core/base-builder/storage/auxiliary-storage.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Manages auxiliary data storage for builders
+ *
+ * Auxiliary data is metadata that doesn't appear in the final built object
+ * but is used during the build process. This includes:
+ * - Templates (stored under "__templates__")
+ * - Switches (stored under "__switches__")
+ * - Custom metadata
+ *
+ * This separation keeps builder state clean and makes the build process more explicit
+ */
+export declare class AuxiliaryStorage {
+    private data;
+    /**
+     * Sets auxiliary data with a given key
+     */
+    set<T>(key: string, value: T): void;
+    /**
+     * Gets auxiliary data with type assertion
+     * The caller is responsible for knowing the correct type
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * Pushes an item to an auxiliary data array
+     * Creates the array if it doesn't exist
+     */
+    push<T>(key: string, item: T): void;
+    /**
+     * Gets an auxiliary data array
+     * Returns empty array if doesn't exist or isn't an array
+     */
+    getArray<T>(key: string): T[];
+    /**
+     * Checks if auxiliary data exists for a key
+     */
+    has(key: string): boolean;
+    /**
+     * Deletes auxiliary data for a key
+     */
+    delete(key: string): boolean;
+    /**
+     * Clears all auxiliary data
+     */
+    clear(): void;
+    /**
+     * Clones the auxiliary storage, creating an independent copy
+     */
+    clone(): AuxiliaryStorage;
+}
+//# sourceMappingURL=auxiliary-storage.d.ts.map

package/types/core/base-builder/storage/value-storage.d.ts

@@ -0,0 +1,82 @@
+import type { BaseBuildContext, FluentBuilder, MixedArrayMetadata } from "../types";
+/**
+ * Manages storage for builder property values
+ *
+ * Values are stored in three different maps based on their type:
+ * - values: Static values (strings, numbers, plain objects without builders)
+ * - builders: FluentBuilder instances and objects containing builders
+ * - mixedArrays: Arrays containing both static values and builders
+ *
+ * This separation allows efficient resolution during the build process
+ */
+export declare class ValueStorage<T> {
+    private values;
+    private builders;
+    private mixedArrays;
+    constructor(initial?: Partial<T>);
+    /**
+     * Sets a property value, intelligently routing it to the appropriate storage
+     *
+     * This method performs runtime type checking to determine how to store the value:
+     * - FluentBuilder instances → builders Map
+     * - Arrays with builders → mixedArrays Map
+     * - Objects with builders → builders Map
+     * - Everything else → values (static storage)
+     */
+    set<K extends keyof T>(key: K, value: unknown): void;
+    /**
+     * Handles array value storage, detecting mixed arrays with builders
+     */
+    private handleArrayValue;
+    /**
+     * Sets a static value with proper type handling
+     */
+    private setStaticValue;
+    /**
+     * Checks if an object contains any builders recursively
+     * Handles circular references gracefully
+     */
+    private containsBuilder;
+    /**
+     * Checks if a property has been set
+     */
+    has<K extends keyof T>(key: K): boolean;
+    /**
+     * Peeks at a property value without resolving builders
+     * Returns the raw value if it's static, the array if it's mixed, or undefined if it's a builder
+     */
+    peek<K extends keyof T>(key: K): T[K] | undefined;
+    /**
+     * Gets builder for a property if one is set
+     */
+    peekBuilder<K extends keyof T, C extends BaseBuildContext>(key: K): 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";
+    /**
+     * Gets all static values for the build pipeline
+     */
+    getValues(): Readonly<Partial<T>>;
+    /**
+     * Gets all builder entries for the build pipeline
+     */
+    getBuilders(): ReadonlyMap<string, FluentBuilder<unknown, BaseBuildContext> | Record<string, unknown>>;
+    /**
+     * Gets all mixed array entries for the build pipeline
+     */
+    getMixedArrays(): ReadonlyMap<string, MixedArrayMetadata>;
+    /**
+     * Unsets a property, removing it from storage
+     */
+    unset<K extends keyof T>(key: K): void;
+    /**
+     * Clears all properties from storage
+     */
+    clear(): void;
+    /**
+     * Clones the storage, creating an independent copy
+     */
+    clone(): ValueStorage<T>;
+}
+//# sourceMappingURL=value-storage.d.ts.map

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

@@ -0,0 +1,183 @@
+import { Asset, AssetWrapper } from "@player-ui/types";
+import type { TaggedTemplateValue } from "../tagged-template/types";
+/**
+ * Unique symbol to identify FluentBuilder instances
+ * Used for runtime type checking of builder objects
+ */
+export declare const FLUENT_BUILDER_SYMBOL: unique symbol;
+/**
+ * Constants for branch type discriminators
+ * Use these instead of string literals to prevent typos
+ */
+export declare const BranchTypes: {
+    readonly SLOT: "slot";
+    readonly ARRAY_ITEM: "array-item";
+    readonly TEMPLATE: "template";
+    readonly SWITCH: "switch";
+    readonly CUSTOM: "custom";
+};
+/**
+ * Constants for internal storage keys
+ * Used by AuxiliaryStorage to store templates and switches
+ */
+export declare const StorageKeys: {
+    readonly TEMPLATES: "__templates__";
+    readonly SWITCHES: "__switches__";
+};
+/**
+ * Constants for common property keys used in asset building
+ */
+export declare const PropertyKeys: {
+    readonly ID: "id";
+    readonly TYPE: "type";
+    readonly VALUE: "value";
+    readonly BINDING: "binding";
+};
+/**
+ * Core interface for all fluent builders
+ * Provides build(), peek(), and has() methods for all builder types
+ */
+export interface FluentBuilder<T, C extends BaseBuildContext = BaseBuildContext> {
+    readonly [FLUENT_BUILDER_SYMBOL]: true;
+    build(context?: C): T;
+    peek<K extends keyof T>(key: K): T[K] | undefined;
+    has<K extends keyof T>(key: K): boolean;
+}
+/**
+ * Type-erased asset builder interface for generic asset handling
+ */
+export type AnyAssetBuilder<C extends BaseBuildContext = BaseBuildContext> = {
+    readonly [FLUENT_BUILDER_SYMBOL]: true;
+    build(context?: C): Asset;
+    peek(key: string): unknown;
+    has(key: string): boolean;
+};
+/**
+ * Parameters for creating nested build contexts
+ * Used by nested context generators to create child contexts
+ */
+export interface NestedContextParams<C extends BaseBuildContext> {
+    readonly parentContext: C;
+    readonly parameterName: string;
+    readonly index?: number;
+}
+/**
+ * Function type for custom nested context generation
+ * Allows users to customize how child contexts are created
+ */
+export type NestedContextGenerator<C extends BaseBuildContext> = (params: NestedContextParams<C>) => C;
+/**
+ * Metadata about an asset used for ID generation and context tracking
+ */
+export interface AssetMetadata {
+    readonly type?: string;
+    readonly binding?: string;
+    readonly value?: string;
+}
+/**
+ * Base build context interface containing common fields for all builders
+ * Extended by specific builder implementations for custom context needs
+ */
+export interface BaseBuildContext {
+    readonly parentId?: string;
+    readonly parameterName?: string;
+    readonly index?: number;
+    readonly branch?: IdBranch;
+    readonly nestedContextGenerator?: NestedContextGenerator<BaseBuildContext>;
+    readonly assetMetadata?: AssetMetadata;
+    readonly [key: string]: unknown;
+}
+/**
+ * Slot branch for named properties (e.g., "label", "action")
+ * Creates IDs like: parent-label, parent-action
+ */
+export interface SlotBranch {
+    type: "slot";
+    name: string;
+}
+/**
+ * Array item branch for indexed elements
+ * Creates IDs like: parent-0, parent-1
+ */
+export interface ArrayItemBranch {
+    type: "array-item";
+    index: number;
+}
+/**
+ * Template branch for template placeholders
+ * Creates IDs like: parent-_index_, parent-_index1_
+ */
+export interface TemplateBranch {
+    type: "template";
+    depth?: number;
+}
+/**
+ * Switch branch for conditional cases
+ * Creates IDs like: parent-staticSwitch-0, parent-dynamicSwitch-1
+ */
+export interface SwitchBranch {
+    type: "switch";
+    index: number;
+    kind: "static" | "dynamic";
+}
+/**
+ * Custom branch for user-defined ID patterns
+ */
+export interface CustomBranch {
+    type: "custom";
+}
+/**
+ * Union of all branch types for type-safe ID generation
+ */
+export type IdBranch = SlotBranch | ArrayItemBranch | TemplateBranch | SwitchBranch | CustomBranch;
+/**
+ * Metadata for arrays containing mixed static values and builders
+ * Tracks which indices contain builders for selective resolution
+ */
+export interface MixedArrayMetadata {
+    readonly array: readonly unknown[];
+    readonly builderIndices: ReadonlySet<number>;
+    readonly objectIndices: ReadonlySet<number>;
+}
+/**
+ * Metadata for template storage in FluentBuilderBase
+ */
+export interface TemplateMetadata {
+    readonly data: string;
+    readonly output: string;
+    readonly dynamic?: boolean;
+}
+/**
+ * Path type for targeting where to inject values in nested structures
+ * Example: ["actions", 0, "label"] targets actions[0].label
+ */
+export type ValuePath = ReadonlyArray<string | number>;
+/**
+ * Metadata for switch storage in FluentBuilderBase
+ */
+export interface SwitchMetadata<C extends BaseBuildContext = BaseBuildContext> {
+    readonly path: ValuePath;
+    readonly switchFn: (context: C, globalCaseIndex?: number) => unknown;
+}
+/**
+ * Helper type for conditional property values in if/ifElse methods
+ * Allows passing unwrapped Asset builders to AssetWrapper properties
+ * Enables: .if(() => true, "label", text().withValue("..."))
+ * Instead of: .if(() => true, "label", { asset: text().withValue("...") })
+ */
+export type ConditionalValue<T, C extends BaseBuildContext> = T extends AssetWrapper<infer A> | undefined ? T | FluentBuilder<T, C> | FluentBuilder<A, C> | A | Array<FluentBuilder<A, C> | A> | (() => T | FluentBuilder<T, C> | FluentBuilder<A, C> | A | Array<FluentBuilder<A, C> | A>) : T extends Array<AssetWrapper<infer A>> ? T | Array<AssetWrapper<A> | FluentBuilder<AssetWrapper<A>, C> | FluentBuilder<A, C> | A> | (() => T | Array<AssetWrapper<A> | FluentBuilder<AssetWrapper<A>, C> | FluentBuilder<A, C> | A>) : // Case 3: Other properties
+T | FluentBuilder<T, C> | (() => T | FluentBuilder<T, C>);
+/**
+ * Transforms property types to allow TaggedTemplateValue for scalars
+ * and FluentBuilder for AssetWrapper properties.
+ */
+export type FluentPartialValue<T, C extends BaseBuildContext = BaseBuildContext> = T extends string ? T | TaggedTemplateValue<string> : T extends number ? T | TaggedTemplateValue<number> : T extends boolean ? T | TaggedTemplateValue<boolean> : T extends bigint ? T | TaggedTemplateValue<bigint> : T extends AssetWrapper<infer A> ? T | FluentBuilder<A, C> | A : T extends Array<AssetWrapper<infer A>> ? Array<AssetWrapper<A> | FluentBuilder<A, C> | A> : T extends Array<infer E> ? Array<FluentPartialValue<E, C>> : T extends object ? {
+    [K in keyof T]: FluentPartialValue<T[K], C>;
+} : T;
+/**
+ * Partial type for builder constructors that allows TaggedTemplateValue for scalars.
+ */
+export type FluentPartial<T, C extends BaseBuildContext = BaseBuildContext> = {
+    [K in keyof T]?: FluentPartialValue<T[K], C>;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,2 @@
+export declare function createInspectMethod(builderName: string, properties: Record<string, unknown>): string;
+//# sourceMappingURL=utils.d.ts.map

package/types/core/flow/index.d.ts

@@ -0,0 +1,23 @@
+import { Asset, Flow, DataModel, Navigation, Schema } from "@player-ui/types";
+import { BaseBuildContext } from "../base-builder";
+/**
+ * Core options for creating a Player-UI Flow
+ */
+interface CoreFlowOptions<T extends Asset = Asset, C extends BaseBuildContext = BaseBuildContext> {
+    id?: string;
+    views: Array<T | {
+        build(context?: C): T;
+    } | ((ctx: C) => T)>;
+    data?: DataModel;
+    schema?: Schema.Schema;
+    navigation: Navigation;
+    context?: C;
+}
+/**
+ * Options for creating a Player-UI Flow
+ * Allows additional properties to be passed through to the final Flow
+ */
+export type FlowOptions<T extends Asset = Asset, C extends BaseBuildContext = BaseBuildContext> = CoreFlowOptions<T, C> & Omit<Flow<T>, keyof CoreFlowOptions<T, C> | "views">;
+export declare function flow<T extends Asset = Asset>(options: FlowOptions<T>): Flow<T>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/types/core/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./base-builder";
+export * from "./tagged-template";
+export * from "./template";
+export * from "./switch";
+export * from "./flow";
+export * from "./schema";
+export * from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/types/core/mocks/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./generated";
+//# sourceMappingURL=index.d.ts.map

package/types/core/mocks/types/action.d.ts

@@ -0,0 +1,58 @@
+import type { Asset, AssetWrapper, Binding, Expression } from "@player-ui/types";
+export interface SimpleModifier<Type extends string> {
+    /** THe mofifier type */
+    type: Type;
+}
+export declare const ActionRoles: readonly ["primary", "secondary", "tertiary", "upsell", "back", "link", "inline-link", "tertiary-button"];
+export type ActionRole = (typeof ActionRoles)[number];
+/**
+ * User actions can be represented in several places.
+ * Each view typically has one or more actions that allow the user to navigate away from that view.
+ * In addition, several asset types can have actions that apply to that asset only.
+ */
+export interface ActionAsset<AnyAsset extends Asset = Asset> extends Asset<"action"> {
+    /** The transition value of the action in the state machine */
+    value?: string;
+    /** A text-like asset for the action's label */
+    label?: AssetWrapper<AnyAsset>;
+    /** An optional expression to execute before transitioning */
+    exp?: Expression;
+    /** An optional string that describes the action for screen-readers */
+    accessibility?: string;
+    /** An optional confirmation dialog to show before executing the action */
+    confirmation?: {
+        /** message asking for confirmation */
+        message: string;
+        /** label for the confirm button */
+        affirmativeLabel: string;
+        /** label for the deny button */
+        negativeLabel?: string;
+    };
+    /** Additional optional data to assist with the action interactions on the page */
+    metaData?: ActionMetaData;
+    /** Triggers the listed bindings to be validated */
+    validate?: Array<Binding> | Binding;
+}
+export interface ActionMetaData {
+    /** beacon to send when the action runs */
+    beacon?: string | Record<string, unknown>;
+    /**
+     * A semantic hint to render the action in different user contexts
+     */
+    role?: ActionRole;
+    /** Force transition to the next view without checking for validation TODO need to update this to support an expression */
+    skipValidation?: boolean;
+    /** Size of the button */
+    size?: "small" | "medium" | "large";
+    /** true to indicate the button should be disabled */
+    disabled?: boolean;
+    /** true to indicate that the button label should be hidden */
+    hideLabel?: boolean;
+    /** true to indicate that the button icon should be hidden */
+    hideIcon?: boolean;
+    /** true to indicate that the action should display as a button instead of a link */
+    showAsButton?: boolean;
+    /** true to indicate to take container width, responsive: Full Width on mobile */
+    fullWidth?: boolean | "responsive";
+}
+//# sourceMappingURL=action.d.ts.map

package/types/core/mocks/types/choice.d.ts

@@ -0,0 +1,95 @@
+import type { Asset, AssetWrapper, Binding } from "@player-ui/types";
+export declare const ALL_CATEGORIES: readonly ["recommended"];
+export type ChoiceItemCategory = (typeof ALL_CATEGORIES)[number];
+/** Any modifier that can appear on a choice */
+export type ChoiceModifier = {
+    /** The default type */
+    type: "tag";
+    /** A compact modifier renders a radio button as a dropdown  */
+    value: "compact";
+};
+/** Optional tag to set choice as readonly */
+export type ChoiceInputModifier = {
+    /** The default type */
+    type: "input";
+    /** modifier to set the choices to readonly */
+    value: "readonly";
+};
+export type ChoiceItemMetadata = {
+    /** optional category for the choice item to determine its purpose:
+     * recommended: this choice item is recommended for the user over or in addition to other items
+     */
+    category?: ChoiceItemCategory;
+};
+export interface ChoiceItem<AnyAsset extends Asset = Asset> {
+    /** The id associated with the choice item */
+    id: string;
+    /** The id used for replay tests. */
+    automationId?: string;
+    /** The label describing the choice. */
+    label?: AssetWrapper<AnyAsset>;
+    /** The icon describing the choice. */
+    icon?: AssetWrapper<AnyAsset>;
+    /** The help for the choice. */
+    help?: AssetWrapper<AnyAsset>;
+    /** Support the legacy choiceHelp prop. No storybook docs for this; deprecated in favour of the "help" field. */
+    choiceHelp?: AssetWrapper<AnyAsset>;
+    /** The description of the choice. */
+    description?: AssetWrapper<AnyAsset>;
+    /** The footer of the choice. */
+    footer?: AssetWrapper<AnyAsset>;
+    /**
+     * The value to set when this choice is selected
+     */
+    value?: string | number | boolean | null;
+    /** The details shown when a user selects the choice item */
+    choiceDetail?: AssetWrapper<AnyAsset>;
+    /**
+     * Any modifiers for the current item. No storybook docs for this as "readonly" (the only modifier) shouldn't be used anymore.
+     */
+    modifiers?: Array<ChoiceInputModifier>;
+    /** MetaData for the choiceItem */
+    metaData?: ChoiceItemMetadata;
+}
+export interface ChoiceMetaData {
+    /** Display the asset a little differently based on the role, monthselector only applies to multiselect asset */
+    role?: "tiles" | "monthselector";
+    /** used to set tiles to jumbo manually */
+    tileSize?: "jumbo" | undefined;
+    /** should The placeholder be disabled or not */
+    placeholderSelectable?: boolean;
+}
+/**
+ * Choice assets are more specific type of data collection element
+ *  where user is presented with a number of predefined choices and
+ * asked to select a single answer.
+ */
+export interface ChoiceAsset<AnyAsset extends Asset = Asset> extends Asset<"choice"> {
+    /** The binding used to keep track of the selected Choice */
+    binding: Binding;
+    /** The choiceItems used as options */
+    choices?: Array<ChoiceItem<AnyAsset>>;
+    /** The label describing the choice field. */
+    label?: AssetWrapper<AnyAsset>;
+    /** choice help providing additional info that could be helpful  */
+    help?: AssetWrapper<AnyAsset>;
+    /** choice note */
+    note?: AssetWrapper;
+    /** placeholder string to show by default for the choice */
+    placeholder?: string;
+    /** any accessibility text to be added as an aria label.*/
+    accessibility?: string;
+    /** The info that appears underneath the choice  */
+    additionalInfo?: AssetWrapper<AnyAsset>;
+    /** The resulting Text that appears underneath the choice */
+    resultText?: AssetWrapper<AnyAsset>;
+    /** */
+    modifiers?: Array<ChoiceModifier | ChoiceInputModifier>;
+    /** Additional metaData for the Choice */
+    metaData?: ChoiceMetaData;
+    /** The main action associated with choices */
+    action?: AssetWrapper<AnyAsset>;
+    /** The main image associated with choices */
+    image?: AssetWrapper<AnyAsset>;
+}
+//# sourceMappingURL=choice.d.ts.map

package/types/core/mocks/types/collection.d.ts

@@ -0,0 +1,102 @@
+import type { Asset, AssetWrapper } from "@player-ui/types";
+import { ActionAsset } from "./action";
+/** A Modifier to apply 'highlight' styling to the collection */
+export interface CalloutModifier {
+    /** the type of modifier */
+    type: "callout";
+    /** specification on why the callout needs to be highlighted--this determines the coloring  */
+    value: "support" | "legal";
+}
+export interface TagModifier {
+    /** the type of modifier */
+    type: "tag";
+    /** the value for the tag */
+    value: "block";
+}
+export interface CollectionMetaData {
+    /** the role of the collection */
+    role?: "section" | "ocr-surface" | "ocr-instructions-lighting" | "ocr-instructions-positioning" | "swd-head-start-text" | "premium" | "address";
+}
+/**
+ * A collection is a group of assets
+ *
+ * @asset
+ */
+export interface Collection<AnyAsset extends Asset = Asset> extends Asset<"collection"> {
+    /** The collection items to show */
+    values?: Array<AssetWrapper<AnyAsset>>;
+    /** The additional information to  show */
+    additionalInfo?: AssetWrapper<AnyAsset>;
+    /** The result text to show */
+    resultText?: AssetWrapper<AnyAsset> | Array<AssetWrapper<AnyAsset>>;
+    /** The label defining the collection  */
+    label?: AssetWrapper<AnyAsset>;
+    /** Actions attached to the collection */
+    actions?: Array<AssetWrapper<ActionAsset>>;
+    /** Extra data associated with the collection */
+    metaData?: CollectionMetaData;
+    /** Ways to modify how the component looks */
+    modifiers?: Array<CalloutModifier | TagModifier>;
+}
+export interface FieldCollectionMetaData {
+    /** the role of the field collection */
+    role?: "section" | "address" | "name" | "phone";
+}
+/**
+ * A field collection is a group of field assets
+ *
+ * @asset
+ */
+export interface FieldCollection<AnyAsset extends Asset = Asset> extends Asset<"fieldCollection"> {
+    /** The collection items to show */
+    values?: Array<AssetWrapper<AnyAsset>>;
+    /** The additional information to  show */
+    additionalInfo?: AssetWrapper<AnyAsset>;
+    /** The result text to show */
+    resultText?: AssetWrapper<AnyAsset>;
+    /** The label defining the collection  */
+    label?: AssetWrapper<AnyAsset>;
+    /** Extra data associated with the collection */
+    metaData?: FieldCollectionMetaData;
+    /** Actions attached to the collection */
+    actions?: Array<AssetWrapper<ActionAsset>>;
+}
+/**
+ * The OverviewCollection asset
+ *
+ * @asset
+ */
+export interface OverviewCollection<AnyAsset extends Asset = Asset> extends Asset<"overviewCollection"> {
+    /** The collection items to show */
+    values?: Array<AssetWrapper<AnyAsset>>;
+    /** The label defining the collection  */
+    label?: AssetWrapper<AnyAsset>;
+    /** Actions attached to the collection */
+    actions?: Array<AssetWrapper<ActionAsset>>;
+}
+/**
+ * SplashCollection asset is very similar to the basic Collection, which is a group of assets.
+ * It can also contain an image. It is intended to display read-only data.
+ */
+export interface SplashCollection<AnyAsset extends Asset = Asset> extends Asset<"splashCollection"> {
+    /** Extra data associated with the Asset */
+    metaData?: {
+        /** Changes the style slightly */
+        role?: "promotional";
+    };
+    /** Asset container for an image */
+    splash?: AssetWrapper<AnyAsset>;
+    /** Label, typically a single text asset */
+    label?: AssetWrapper<AnyAsset>;
+    /** Array of assets, typically text assets */
+    values?: Array<AssetWrapper<AnyAsset>>;
+    /** @deprecated additionalInfo in splash collection is no longer supported */
+    additionalInfo?: AssetWrapper<AnyAsset>;
+    /** @deprecated resultText in splash collection is no longer supported */
+    resultText?: AssetWrapper<AnyAsset>;
+    /** @deprecated actions in splash collection is no longer supported */
+    actions?: Array<AssetWrapper<ActionAsset>>;
+}
+export type CollectionType = Collection | FieldCollection | OverviewCollection | SplashCollection;
+export type CollectionValue = AssetWrapper<Asset<string>>;
+//# sourceMappingURL=collection.d.ts.map

package/types/core/mocks/types/info.d.ts

@@ -0,0 +1,7 @@
+import type { Asset, AssetWrapper } from "@player-ui/types";
+export interface InfoAsset extends Asset<"info"> {
+    primaryInfo: Array<AssetWrapper<Asset>>;
+    title?: AssetWrapper<Asset>;
+    subtitle?: AssetWrapper<Asset>;
+}
+//# sourceMappingURL=info.d.ts.map

package/types/core/mocks/types/input.d.ts

@@ -0,0 +1,7 @@
+import type { Asset, AssetWrapper } from "@player-ui/types";
+export interface InputAsset extends Asset<"input"> {
+    binding: string;
+    label: AssetWrapper<Asset>;
+    placeholder?: string;
+}
+//# sourceMappingURL=input.d.ts.map

package/types/core/mocks/types/text.d.ts

@@ -0,0 +1,5 @@
+import type { Asset } from "@player-ui/types";
+export interface TextAsset extends Asset<"text"> {
+    value: string;
+}
+//# sourceMappingURL=text.d.ts.map

package/types/core/schema/index.d.ts

@@ -0,0 +1,34 @@
+import type { Schema } from "@player-ui/types";
+import { SyncWaterfallHook } from "tapable-ts";
+import { SchemaGeneratorInput } from "./types";
+/** Symbol to indicate that a schema node should be generated with a different name */
+export declare const SchemaTypeName: unique symbol;
+export type LoggingInterface = Pick<Console, "warn" | "error" | "log">;
+/**
+ * Generator for `Schema.Schema` Objects
+ */
+export declare class SchemaGenerator {
+    private children;
+    private generatedDataTypes;
+    private typeNameCache;
+    private logger;
+    hooks: {
+        createSchemaNode: SyncWaterfallHook<[node: Schema.DataType<unknown>, originalProperty: Record<string | symbol, unknown>], Record<string, any>>;
+    };
+    constructor(logger?: LoggingInterface);
+    /**
+     * Converts an object to a `Schema.Schema` representation
+     * Optimized to minimize object operations and memory allocations
+     */
+    toSchema: (schema: SchemaGeneratorInput) => Schema.Schema;
+    private processChild;
+    /**
+     * Cached type name generation
+     */
+    private makePlaceholderType;
+    /**
+     * Cached array type name generation
+     */
+    private makePlaceholderArrayType;
+}
+//# sourceMappingURL=index.d.ts.map