@player-tools/fluent 0.13.0--canary.221.5662

package/src/core/mocks/generated/action.builder.ts

@@ -0,0 +1,109 @@
+import type { ActionAsset, ActionMetaData } from "../types/action.js";
+import type { Asset, AssetWrapper } from "@player-ui/types";
+import { type FluentBuilder, type BaseBuildContext, FluentBuilderBase, createInspectMethod } from "../../../gen/common.js";
+import type { TaggedTemplateValue } from "@player-tools/fluent";
+
+export interface ActionAssetBuilderMethods<AnyAsset extends Asset<string> = Asset<string>> {
+  /** The transition value of the action in the state machine */
+  withValue(value: string | TaggedTemplateValue<string>): ActionAssetBuilder<AnyAsset>;
+  /** A text-like asset for the action's label */
+  withLabel(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ActionAssetBuilder<AnyAsset>;
+  /** An optional expression to execute before transitioning */
+  withExp(value: string | TaggedTemplateValue<string> | Array<string | TaggedTemplateValue<string>>): ActionAssetBuilder<AnyAsset>;
+  /** An optional string that describes the action for screen-readers */
+  withAccessibility(value: string | TaggedTemplateValue<string>): ActionAssetBuilder<AnyAsset>;
+  /** An optional confirmation dialog to show before executing the action */
+  withConfirmation(value: { message: string | TaggedTemplateValue<string>; affirmativeLabel: string | TaggedTemplateValue<string>; negativeLabel?: string | TaggedTemplateValue<string> }): ActionAssetBuilder<AnyAsset>;
+  /** Additional optional data to assist with the action interactions on the page */
+  withMetaData(value: ActionMetaData | FluentBuilder<ActionMetaData, BaseBuildContext>): ActionAssetBuilder<AnyAsset>;
+  /** Triggers the listed bindings to be validated */
+  withValidate(value: string | TaggedTemplateValue<string> | Array<string | TaggedTemplateValue<string>>): ActionAssetBuilder<AnyAsset>;
+  /** Each asset requires a unique id per view */
+  withId(value: string | TaggedTemplateValue<string>): ActionAssetBuilder<AnyAsset>;
+  /** The asset type determines the semantics of how a user interacts with a page */
+  withType(value: "action"): ActionAssetBuilder<AnyAsset>;
+}
+
+/**
+* A builder for ActionAsset
+*/
+export class ActionAssetBuilder<AnyAsset extends Asset<string> = Asset<string>> extends FluentBuilderBase<ActionAsset<AnyAsset>> implements ActionAssetBuilderMethods<AnyAsset>, FluentBuilder<ActionAsset<AnyAsset>, BaseBuildContext> {
+  private static readonly defaults: Record<string, unknown> = { id: "", type: "action" };
+
+  /** The transition value of the action in the state machine */
+  withValue(value: string | TaggedTemplateValue<string>): ActionAssetBuilder<AnyAsset> {
+    return this.set("value", value);
+  }
+
+  /** A text-like asset for the action's label */
+  withLabel(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ActionAssetBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("label", extractedValue);
+  }
+
+  /** An optional expression to execute before transitioning */
+  withExp(value: string | TaggedTemplateValue<string> | Array<string | TaggedTemplateValue<string>>): ActionAssetBuilder<AnyAsset> {
+    return this.set("exp", value);
+  }
+
+  /** An optional string that describes the action for screen-readers */
+  withAccessibility(value: string | TaggedTemplateValue<string>): ActionAssetBuilder<AnyAsset> {
+    return this.set("accessibility", value);
+  }
+
+  /** An optional confirmation dialog to show before executing the action */
+  withConfirmation(value: { message: string | TaggedTemplateValue<string>; affirmativeLabel: string | TaggedTemplateValue<string>; negativeLabel?: string | TaggedTemplateValue<string> }): ActionAssetBuilder<AnyAsset> {
+    return this.set("confirmation", value);
+  }
+
+  /** Additional optional data to assist with the action interactions on the page */
+  withMetaData(value: ActionMetaData | FluentBuilder<ActionMetaData, BaseBuildContext>): ActionAssetBuilder<AnyAsset> {
+    return this.set("metaData", value);
+  }
+
+  /** Triggers the listed bindings to be validated */
+  withValidate(value: string | TaggedTemplateValue<string> | Array<string | TaggedTemplateValue<string>>): ActionAssetBuilder<AnyAsset> {
+    return this.set("validate", value);
+  }
+
+  /** Each asset requires a unique id per view */
+  withId(value: string | TaggedTemplateValue<string>): ActionAssetBuilder<AnyAsset> {
+    return this.set("id", value);
+  }
+
+  /** The asset type determines the semantics of how a user interacts with a page */
+  withType(value: "action"): ActionAssetBuilder<AnyAsset> {
+    return this.set("type", value);
+  }
+
+  /**
+   * Set additional properties with dynamic keys
+   * @param props - Object with dynamic properties
+   */
+  withAdditionalProperties(props: Record<string, unknown>): ActionAssetBuilder<AnyAsset> {
+    Object.assign(this.values, props);
+    return this as ActionAssetBuilder<AnyAsset>;
+  }
+
+  /**
+   * Builds the final ActionAsset object
+   * @param context - Optional build context for nested builders
+   */
+  build(context?: BaseBuildContext): ActionAsset<AnyAsset> {
+    return this.buildWithDefaults(ActionAssetBuilder.defaults, context);
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return createInspectMethod("ActionAssetBuilder", this.values);
+  }
+}
+
+/**
+ * Creates a new ActionAsset builder
+ * @param initial Optional initial values
+ * @returns A fluent builder for ActionAsset
+ */
+export function action<AnyAsset extends Asset<string> = Asset<string>>(initial?: Partial<ActionAsset<AnyAsset>>): ActionAssetBuilder<AnyAsset> {
+  return new ActionAssetBuilder<AnyAsset>(initial);
+}

package/src/core/mocks/generated/choice.builder.ts

@@ -0,0 +1,161 @@
+import type { ChoiceAsset, ChoiceItem, ChoiceInputModifier, ChoiceItemMetadata, ChoiceModifier, ChoiceMetaData } from "../types/choice.js";
+import type { Asset, AssetWrapper } from "@player-ui/types";
+import { type FluentBuilder, type BaseBuildContext, FluentBuilderBase, createInspectMethod } from "../../../gen/common.js";
+import type { TaggedTemplateValue } from "@player-tools/fluent";
+
+export interface ChoiceAssetBuilderMethods<AnyAsset extends Asset<string> = Asset<string>> {
+  /** The binding used to keep track of the selected Choice */
+  withBinding(value: string | TaggedTemplateValue<string>): ChoiceAssetBuilder<AnyAsset>;
+  /** The choiceItems used as options */
+  withChoices(value: Array<ChoiceItem<AnyAsset> | FluentBuilder<ChoiceItem<AnyAsset>, BaseBuildContext>>): ChoiceAssetBuilder<AnyAsset>;
+  /** The label describing the choice field. */
+  withLabel(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset>;
+  /** choice help providing additional info that could be helpful */
+  withHelp(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset>;
+  /** choice note */
+  withNote(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset>;
+  /** placeholder string to show by default for the choice */
+  withPlaceholder(value: string | TaggedTemplateValue<string>): ChoiceAssetBuilder<AnyAsset>;
+  /** any accessibility text to be added as an aria label. */
+  withAccessibility(value: string | TaggedTemplateValue<string>): ChoiceAssetBuilder<AnyAsset>;
+  /** The info that appears underneath the choice */
+  withAdditionalInfo(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset>;
+  /** The resulting Text that appears underneath the choice */
+  withResultText(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset>;
+  withModifiers(value: Array<ChoiceInputModifier | ChoiceModifier>): ChoiceAssetBuilder<AnyAsset>;
+  /** Additional metaData for the Choice */
+  withMetaData(value: ChoiceMetaData | FluentBuilder<ChoiceMetaData, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset>;
+  /** The main action associated with choices */
+  withAction(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset>;
+  /** The main image associated with choices */
+  withImage(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset>;
+  /** Each asset requires a unique id per view */
+  withId(value: string | TaggedTemplateValue<string>): ChoiceAssetBuilder<AnyAsset>;
+  /** The asset type determines the semantics of how a user interacts with a page */
+  withType(value: "choice"): ChoiceAssetBuilder<AnyAsset>;
+}
+
+/**
+* A builder for ChoiceAsset
+*/
+export class ChoiceAssetBuilder<AnyAsset extends Asset<string> = Asset<string>> extends FluentBuilderBase<ChoiceAsset<AnyAsset>> implements ChoiceAssetBuilderMethods<AnyAsset>, FluentBuilder<ChoiceAsset<AnyAsset>, BaseBuildContext> {
+  private static readonly defaults: Record<string, unknown> = { binding: "", id: "", type: "choice" };
+
+  /** The binding used to keep track of the selected Choice */
+  withBinding(value: string | TaggedTemplateValue<string>): ChoiceAssetBuilder<AnyAsset> {
+    return this.set("binding", value);
+  }
+
+  /** The choiceItems used as options */
+  withChoices(value: Array<ChoiceItem<AnyAsset> | FluentBuilder<ChoiceItem<AnyAsset>, BaseBuildContext>>): ChoiceAssetBuilder<AnyAsset> {
+    return this.set("choices", value);
+  }
+
+  /** The label describing the choice field. */
+  withLabel(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("label", extractedValue);
+  }
+
+  /** choice help providing additional info that could be helpful */
+  withHelp(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("help", extractedValue);
+  }
+
+  /** choice note */
+  withNote(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("note", extractedValue);
+  }
+
+  /** placeholder string to show by default for the choice */
+  withPlaceholder(value: string | TaggedTemplateValue<string>): ChoiceAssetBuilder<AnyAsset> {
+    return this.set("placeholder", value);
+  }
+
+  /** any accessibility text to be added as an aria label. */
+  withAccessibility(value: string | TaggedTemplateValue<string>): ChoiceAssetBuilder<AnyAsset> {
+    return this.set("accessibility", value);
+  }
+
+  /** The info that appears underneath the choice */
+  withAdditionalInfo(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("additionalInfo", extractedValue);
+  }
+
+  /** The resulting Text that appears underneath the choice */
+  withResultText(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("resultText", extractedValue);
+  }
+
+  withModifiers(value: Array<ChoiceInputModifier | ChoiceModifier>): ChoiceAssetBuilder<AnyAsset> {
+    return this.set("modifiers", value);
+  }
+
+  /** Additional metaData for the Choice */
+  withMetaData(value: ChoiceMetaData | FluentBuilder<ChoiceMetaData, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset> {
+    return this.set("metaData", value);
+  }
+
+  /** The main action associated with choices */
+  withAction(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("action", extractedValue);
+  }
+
+  /** The main image associated with choices */
+  withImage(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceAssetBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("image", extractedValue);
+  }
+
+  /** Each asset requires a unique id per view */
+  withId(value: string | TaggedTemplateValue<string>): ChoiceAssetBuilder<AnyAsset> {
+    return this.set("id", value);
+  }
+
+  /** The asset type determines the semantics of how a user interacts with a page */
+  withType(value: "choice"): ChoiceAssetBuilder<AnyAsset> {
+    return this.set("type", value);
+  }
+
+  /**
+   * Set additional properties with dynamic keys
+   * @param props - Object with dynamic properties
+   */
+  withAdditionalProperties(props: Record<string, unknown>): ChoiceAssetBuilder<AnyAsset> {
+    Object.assign(this.values, props);
+    return this as ChoiceAssetBuilder<AnyAsset>;
+  }
+
+  /**
+   * Builds the final ChoiceAsset object
+   * @param context - Optional build context for nested builders
+   */
+  build(context?: BaseBuildContext): ChoiceAsset<AnyAsset> {
+    return this.buildWithDefaults(ChoiceAssetBuilder.defaults, context);
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return createInspectMethod("ChoiceAssetBuilder", this.values);
+  }
+}
+
+/**
+ * Creates a new ChoiceAsset builder
+ * @param initial Optional initial values
+ * @returns A fluent builder for ChoiceAsset
+ */
+export function choice<AnyAsset extends Asset<string> = Asset<string>>(initial?: Partial<ChoiceAsset<AnyAsset>>): ChoiceAssetBuilder<AnyAsset> {
+  return new ChoiceAssetBuilder<AnyAsset>(initial);
+}

package/src/core/mocks/generated/choiceItem.builder.ts

@@ -0,0 +1,133 @@
+import type { ChoiceItem, ChoiceInputModifier, ChoiceItemMetadata } from "../types/choice.js";
+import type { Asset, AssetWrapper } from "@player-ui/types";
+import { type FluentBuilder, type BaseBuildContext, FluentBuilderBase, createInspectMethod } from "../../../gen/common.js";
+import type { TaggedTemplateValue } from "@player-tools/fluent";
+
+export interface ChoiceItemBuilderMethods<AnyAsset extends Asset<string> = Asset<string>> {
+  /** The id associated with the choice item */
+  withId(value: string | TaggedTemplateValue<string>): ChoiceItemBuilder<AnyAsset>;
+  /** The id used for replay tests. */
+  withAutomationId(value: string | TaggedTemplateValue<string>): ChoiceItemBuilder<AnyAsset>;
+  /** The label describing the choice. */
+  withLabel(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset>;
+  /** The icon describing the choice. */
+  withIcon(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset>;
+  /** The help for the choice. */
+  withHelp(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset>;
+  /** Support the legacy choiceHelp prop. No storybook docs for this; deprecated in favour of the "help" field. */
+  withChoiceHelp(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset>;
+  /** The description of the choice. */
+  withDescription(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset>;
+  /** The footer of the choice. */
+  withFooter(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset>;
+  /** The value to set when this choice is selected */
+  withValue(value: string | number | false | true): ChoiceItemBuilder<AnyAsset>;
+  /** The details shown when a user selects the choice item */
+  withChoiceDetail(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset>;
+  /** Any modifiers for the current item. No storybook docs for this as "readonly" (the only modifier) shouldn't be used anymore. */
+  withModifiers(value: Array<ChoiceInputModifier | FluentBuilder<ChoiceInputModifier, BaseBuildContext>>): ChoiceItemBuilder<AnyAsset>;
+  /** MetaData for the choiceItem */
+  withMetaData(value: ChoiceItemMetadata | FluentBuilder<ChoiceItemMetadata, BaseBuildContext>): ChoiceItemBuilder<AnyAsset>;
+}
+
+/**
+* A builder for ChoiceItem
+*/
+export class ChoiceItemBuilder<AnyAsset extends Asset<string> = Asset<string>> extends FluentBuilderBase<ChoiceItem<AnyAsset>> implements ChoiceItemBuilderMethods<AnyAsset>, FluentBuilder<ChoiceItem<AnyAsset>, BaseBuildContext> {
+  private static readonly defaults: Record<string, unknown> = { id: "" };
+
+  /** The id associated with the choice item */
+  withId(value: string | TaggedTemplateValue<string>): ChoiceItemBuilder<AnyAsset> {
+    return this.set("id", value);
+  }
+
+  /** The id used for replay tests. */
+  withAutomationId(value: string | TaggedTemplateValue<string>): ChoiceItemBuilder<AnyAsset> {
+    return this.set("automationId", value);
+  }
+
+  /** The label describing the choice. */
+  withLabel(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("label", extractedValue);
+  }
+
+  /** The icon describing the choice. */
+  withIcon(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("icon", extractedValue);
+  }
+
+  /** The help for the choice. */
+  withHelp(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("help", extractedValue);
+  }
+
+  /** Support the legacy choiceHelp prop. No storybook docs for this; deprecated in favour of the "help" field. */
+  withChoiceHelp(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("choiceHelp", extractedValue);
+  }
+
+  /** The description of the choice. */
+  withDescription(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("description", extractedValue);
+  }
+
+  /** The footer of the choice. */
+  withFooter(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("footer", extractedValue);
+  }
+
+  /** The value to set when this choice is selected */
+  withValue(value: string | number | false | true): ChoiceItemBuilder<AnyAsset> {
+    return this.set("value", value);
+  }
+
+  /** The details shown when a user selects the choice item */
+  withChoiceDetail(value: Asset | FluentBuilder<Asset, BaseBuildContext>): ChoiceItemBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("choiceDetail", extractedValue);
+  }
+
+  /** Any modifiers for the current item. No storybook docs for this as "readonly" (the only modifier) shouldn't be used anymore. */
+  withModifiers(value: Array<ChoiceInputModifier | FluentBuilder<ChoiceInputModifier, BaseBuildContext>>): ChoiceItemBuilder<AnyAsset> {
+    return this.set("modifiers", value);
+  }
+
+  /** MetaData for the choiceItem */
+  withMetaData(value: ChoiceItemMetadata | FluentBuilder<ChoiceItemMetadata, BaseBuildContext>): ChoiceItemBuilder<AnyAsset> {
+    return this.set("metaData", value);
+  }
+
+  /**
+   * Builds the final ChoiceItem object
+   * @param context - Optional build context for nested builders
+   */
+  build(context?: BaseBuildContext): ChoiceItem<AnyAsset> {
+    return this.buildWithDefaults(ChoiceItemBuilder.defaults, context);
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return createInspectMethod("ChoiceItemBuilder", this.values);
+  }
+}
+
+/**
+ * Creates a new ChoiceItem builder
+ * @param initial Optional initial values
+ * @returns A fluent builder for ChoiceItem
+ */
+export function choiceItem<AnyAsset extends Asset<string> = Asset<string>>(initial?: Partial<ChoiceItem<AnyAsset>>): ChoiceItemBuilder<AnyAsset> {
+  return new ChoiceItemBuilder<AnyAsset>(initial);
+}

package/src/core/mocks/generated/collection.builder.ts

@@ -0,0 +1,117 @@
+import type { Collection, CollectionMetaData, CalloutModifier, TagModifier } from "../types/collection.js";
+import type { ActionAsset, ActionMetaData } from "../types/action.js";
+import type { Asset, AssetWrapper } from "@player-ui/types";
+import { type FluentBuilder, type BaseBuildContext, FluentBuilderBase, createInspectMethod } from "../../../gen/common.js";
+import type { TaggedTemplateValue } from "@player-tools/fluent";
+
+export interface CollectionBuilderMethods<AnyAsset extends Asset<string> = Asset<string>> {
+  /** The collection items to show */
+  withValues(value: Array<Asset | FluentBuilder<Asset, BaseBuildContext>>): CollectionBuilder<AnyAsset>;
+  /** The additional information to  show */
+  withAdditionalInfo(value: Asset | FluentBuilder<Asset, BaseBuildContext>): CollectionBuilder<AnyAsset>;
+  /** The result text to show */
+  withResultText(value: AssetWrapper | Array<AssetWrapper>): CollectionBuilder<AnyAsset>;
+  /** The label defining the collection */
+  withLabel(value: Asset | FluentBuilder<Asset, BaseBuildContext>): CollectionBuilder<AnyAsset>;
+  /** Actions attached to the collection */
+  withActions(value: Array<Asset | FluentBuilder<Asset, BaseBuildContext>>): CollectionBuilder<AnyAsset>;
+  /** Extra data associated with the collection */
+  withMetaData(value: CollectionMetaData | FluentBuilder<CollectionMetaData, BaseBuildContext>): CollectionBuilder<AnyAsset>;
+  /** Ways to modify how the component looks */
+  withModifiers(value: Array<CalloutModifier | TagModifier>): CollectionBuilder<AnyAsset>;
+  /** Each asset requires a unique id per view */
+  withId(value: string | TaggedTemplateValue<string>): CollectionBuilder<AnyAsset>;
+  /** The asset type determines the semantics of how a user interacts with a page */
+  withType(value: "collection"): CollectionBuilder<AnyAsset>;
+}
+
+/**
+* A builder for Collection
+*/
+export class CollectionBuilder<AnyAsset extends Asset<string> = Asset<string>> extends FluentBuilderBase<Collection<AnyAsset>> implements CollectionBuilderMethods<AnyAsset>, FluentBuilder<Collection<AnyAsset>, BaseBuildContext> {
+  private static readonly defaults: Record<string, unknown> = { id: "", type: "collection" };
+  private static readonly __arrayProperties__: ReadonlySet<string> = new Set(["actions", "values"]);
+
+  /** The collection items to show */
+  withValues(value: Array<Asset | FluentBuilder<Asset, BaseBuildContext>>): CollectionBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("values", extractedValue);
+  }
+
+  /** The additional information to  show */
+  withAdditionalInfo(value: Asset | FluentBuilder<Asset, BaseBuildContext>): CollectionBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("additionalInfo", extractedValue);
+  }
+
+  /** The result text to show */
+  withResultText(value: AssetWrapper | Array<AssetWrapper>): CollectionBuilder<AnyAsset> {
+    return this.set("resultText", value);
+  }
+
+  /** The label defining the collection */
+  withLabel(value: Asset | FluentBuilder<Asset, BaseBuildContext>): CollectionBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("label", extractedValue);
+  }
+
+  /** Actions attached to the collection */
+  withActions(value: Array<Asset | FluentBuilder<Asset, BaseBuildContext>>): CollectionBuilder<AnyAsset> {
+    const extractedValue = { asset: value };
+    
+    return this.set("actions", extractedValue);
+  }
+
+  /** Extra data associated with the collection */
+  withMetaData(value: CollectionMetaData | FluentBuilder<CollectionMetaData, BaseBuildContext>): CollectionBuilder<AnyAsset> {
+    return this.set("metaData", value);
+  }
+
+  /** Ways to modify how the component looks */
+  withModifiers(value: Array<CalloutModifier | TagModifier>): CollectionBuilder<AnyAsset> {
+    return this.set("modifiers", value);
+  }
+
+  /** Each asset requires a unique id per view */
+  withId(value: string | TaggedTemplateValue<string>): CollectionBuilder<AnyAsset> {
+    return this.set("id", value);
+  }
+
+  /** The asset type determines the semantics of how a user interacts with a page */
+  withType(value: "collection"): CollectionBuilder<AnyAsset> {
+    return this.set("type", value);
+  }
+
+  /**
+   * Set additional properties with dynamic keys
+   * @param props - Object with dynamic properties
+   */
+  withAdditionalProperties(props: Record<string, unknown>): CollectionBuilder<AnyAsset> {
+    Object.assign(this.values, props);
+    return this as CollectionBuilder<AnyAsset>;
+  }
+
+  /**
+   * Builds the final Collection object
+   * @param context - Optional build context for nested builders
+   */
+  build(context?: BaseBuildContext): Collection<AnyAsset> {
+    return this.buildWithDefaults(CollectionBuilder.defaults, context);
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return createInspectMethod("CollectionBuilder", this.values);
+  }
+}
+
+/**
+ * Creates a new Collection builder
+ * @param initial Optional initial values
+ * @returns A fluent builder for Collection
+ */
+export function collection<AnyAsset extends Asset<string> = Asset<string>>(initial?: Partial<Collection<AnyAsset>>): CollectionBuilder<AnyAsset> {
+  return new CollectionBuilder<AnyAsset>(initial);
+}

package/src/core/mocks/generated/index.ts

@@ -0,0 +1,7 @@
+export * from './action.builder.js';
+export * from './collection.builder.js';
+export * from './text.builder.js';
+export * from './info.builder.js';
+export * from './input.builder.js';
+export * from './choice.builder.js';
+export * from './choiceItem.builder.js';

package/src/core/mocks/generated/info.builder.ts

@@ -0,0 +1,80 @@
+import type { InfoAsset } from "../types/info.js";
+import type { Asset, AssetWrapper } from "@player-ui/types";
+import { type FluentBuilder, type BaseBuildContext, FluentBuilderBase, createInspectMethod } from "../../../gen/common.js";
+import type { TaggedTemplateValue } from "@player-tools/fluent";
+
+export interface InfoAssetBuilderMethods {
+  withPrimaryInfo(value: Array<Asset | FluentBuilder<Asset, BaseBuildContext>>): InfoAssetBuilder;
+  withTitle(value: Asset | FluentBuilder<Asset, BaseBuildContext>): InfoAssetBuilder;
+  withSubtitle(value: Asset | FluentBuilder<Asset, BaseBuildContext>): InfoAssetBuilder;
+  /** Each asset requires a unique id per view */
+  withId(value: string | TaggedTemplateValue<string>): InfoAssetBuilder;
+  /** The asset type determines the semantics of how a user interacts with a page */
+  withType(value: "info"): InfoAssetBuilder;
+}
+
+/**
+* A builder for InfoAsset
+*/
+export class InfoAssetBuilder extends FluentBuilderBase<InfoAsset> implements InfoAssetBuilderMethods, FluentBuilder<InfoAsset, BaseBuildContext> {
+  private static readonly defaults: Record<string, unknown> = { primaryInfo: [], id: "", type: "info" };
+  private static readonly __arrayProperties__: ReadonlySet<string> = new Set(["primaryInfo"]);
+
+  withPrimaryInfo(value: Array<Asset | FluentBuilder<Asset, BaseBuildContext>>): InfoAssetBuilder {
+    const extractedValue = { asset: value };
+    
+    return this.set("primaryInfo", extractedValue);
+  }
+
+  withTitle(value: Asset | FluentBuilder<Asset, BaseBuildContext>): InfoAssetBuilder {
+    const extractedValue = { asset: value };
+    
+    return this.set("title", extractedValue);
+  }
+
+  withSubtitle(value: Asset | FluentBuilder<Asset, BaseBuildContext>): InfoAssetBuilder {
+    const extractedValue = { asset: value };
+    
+    return this.set("subtitle", extractedValue);
+  }
+
+  /** Each asset requires a unique id per view */
+  withId(value: string | TaggedTemplateValue<string>): InfoAssetBuilder {
+    return this.set("id", value);
+  }
+
+  /** The asset type determines the semantics of how a user interacts with a page */
+  withType(value: "info"): InfoAssetBuilder {
+    return this.set("type", value);
+  }
+
+  /**
+   * Set additional properties with dynamic keys
+   * @param props - Object with dynamic properties
+   */
+  withAdditionalProperties(props: Record<string, unknown>): InfoAssetBuilder {
+    Object.assign(this.values, props);
+    return this as InfoAssetBuilder;
+  }
+
+  /**
+   * Builds the final InfoAsset object
+   * @param context - Optional build context for nested builders
+   */
+  build(context?: BaseBuildContext): InfoAsset {
+    return this.buildWithDefaults(InfoAssetBuilder.defaults, context);
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return createInspectMethod("InfoAssetBuilder", this.values);
+  }
+}
+
+/**
+ * Creates a new InfoAsset builder
+ * @param initial Optional initial values
+ * @returns A fluent builder for InfoAsset
+ */
+export function info(initial?: Partial<InfoAsset>): InfoAssetBuilder {
+  return new InfoAssetBuilder(initial);
+}