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

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

@@ -0,0 +1,5 @@
+import type { Schema } from "@player-ui/types";
+type SchemaDataType = Schema.DataType | Schema.RecordType | Schema.ArrayType;
+export type SchemaGeneratorInput = Record<string, SchemaDataType | Record<string, unknown> | unknown[]>;
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { Asset, AssetWrapper } from "@player-ui/types";
+import { type BaseBuildContext } from "../base-builder";
+import { type TaggedTemplateValue } from "../tagged-template";
+type CaseExpression = boolean | string | TaggedTemplateValue;
+interface SwitchCase<T extends Asset, C extends BaseBuildContext = BaseBuildContext> {
+    readonly case: CaseExpression;
+    readonly asset: T | {
+        build(context?: C): T;
+    };
+}
+interface SwitchArgs<T extends Asset, C extends BaseBuildContext = BaseBuildContext> {
+    readonly cases: ReadonlyArray<SwitchCase<T, C>>;
+    readonly isDynamic?: boolean;
+}
+/**
+ * Creates a switch configuration for conditionally selecting an asset
+ * @see https://player-ui.github.io/next/content/assets-views/#switches
+ */
+export declare const switch_: <T extends Asset, C extends BaseBuildContext = BaseBuildContext>({ cases, isDynamic, }: SwitchArgs<T, C>) => (ctx: C, caseOffset?: number) => AssetWrapper;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/types/core/tagged-template/binding.d.ts

@@ -0,0 +1,19 @@
+import { type TaggedTemplateValue } from "./types";
+/**
+ * Tagged template for creating binding expressions with optional type information
+ * Used to generate template strings with proper binding syntax
+ * @param strings - Template string parts
+ * @param expressions - Values to interpolate
+ * @returns TaggedTemplateValue with optional phantom type T
+ *
+ * @example
+ * ```typescript
+ * // Basic usage (backward compatible)
+ * const basicBinding = binding`data.count`;
+ *
+ * // With phantom type for TypeScript type checking
+ * const typedBinding = binding<number>`data.count`;
+ * ```
+ */
+export declare function binding<T = unknown>(strings: TemplateStringsArray, ...expressions: Array<unknown>): TaggedTemplateValue<T>;
+//# sourceMappingURL=binding.d.ts.map

package/types/core/tagged-template/expression.d.ts

@@ -0,0 +1,11 @@
+import { type TaggedTemplateValue } from "./types";
+/**
+ * Tagged template for creating expression literals
+ * Used for generating expressions with proper validation and formatting
+ * @param strings - Template string parts
+ * @param expressions - Values to interpolate
+ * @returns TaggedTemplateValue with expression context
+ * @throws Error if expression syntax is invalid
+ */
+export declare function expression<T = unknown>(strings: TemplateStringsArray, ...expressions: Array<unknown>): TaggedTemplateValue<T>;
+//# sourceMappingURL=expression.d.ts.map

package/types/core/tagged-template/extract-bindings-from-schema.d.ts

@@ -0,0 +1,7 @@
+import type { Schema } from "@player-ui/types";
+import type { ExtractedBindings } from "./types";
+/**
+ * Runtime implementation that builds the actual object structure
+ */
+export declare function extractBindingsFromSchema<const S extends Schema.Schema>(schema: S): ExtractedBindings<S>;
+//# sourceMappingURL=extract-bindings-from-schema.d.ts.map

package/types/core/tagged-template/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./binding";
+export * from "./expression";
+export * from "./extract-bindings-from-schema";
+export * from "./std";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/types/core/tagged-template/std.d.ts

@@ -0,0 +1,174 @@
+import { type TaggedTemplateValue } from "./types";
+/**
+ * Type-safe standard library of expressions for the Player-UI DSL
+ * Provides common logical, comparison, and arithmetic operations with full TypeScript type safety
+ * using phantom types from TaggedTemplateValue.
+ */
+/**
+ * Logical AND operation - returns true if all arguments are truthy
+ * @param args - Values or bindings to evaluate with AND logic
+ * @returns TaggedTemplateValue<boolean> representing the AND expression
+ */
+export declare function and(...args: Array<TaggedTemplateValue<unknown> | boolean | string | number>): TaggedTemplateValue<boolean>;
+/**
+ * Logical OR operation - returns true if any argument is truthy
+ * @param args - Values or bindings to evaluate with OR logic
+ * @returns TaggedTemplateValue<boolean> representing the OR expression
+ */
+export declare function or(...args: Array<TaggedTemplateValue<unknown> | boolean | string | number>): TaggedTemplateValue<boolean>;
+/**
+ * Logical NOT operation - returns true if argument is falsy
+ * @param value - Value or binding to negate
+ * @returns TaggedTemplateValue<boolean> representing the NOT expression
+ */
+export declare function not(value: TaggedTemplateValue<unknown> | boolean | string | number): TaggedTemplateValue<boolean>;
+/**
+ * Logical NOR operation - returns true if all arguments are falsy
+ * @param args - Values or bindings to evaluate with NOR logic
+ * @returns TaggedTemplateValue<boolean> representing the NOR expression
+ */
+export declare function nor(...args: Array<TaggedTemplateValue<unknown> | boolean | string | number>): TaggedTemplateValue<boolean>;
+/**
+ * Logical NAND operation - returns false if all arguments are truthy
+ * @param args - Values or bindings to evaluate with NAND logic
+ * @returns TaggedTemplateValue<boolean> representing the NAND expression
+ */
+export declare function nand(...args: Array<TaggedTemplateValue<unknown> | boolean | string | number>): TaggedTemplateValue<boolean>;
+/**
+ * Logical XOR operation - returns true if exactly one argument is truthy
+ * @param left - First value to compare
+ * @param right - Second value to compare
+ * @returns TaggedTemplateValue<boolean> representing the XOR expression
+ */
+export declare function xor(left: TaggedTemplateValue<unknown> | boolean | string | number, right: TaggedTemplateValue<unknown> | boolean | string | number): TaggedTemplateValue<boolean>;
+/**
+ * Equality comparison (loose equality ==)
+ * @param left - First value to compare
+ * @param right - Second value to compare
+ * @returns TaggedTemplateValue<boolean> representing the equality expression
+ */
+export declare function equal<T>(left: TaggedTemplateValue<T> | T, right: TaggedTemplateValue<T> | T): TaggedTemplateValue<boolean>;
+/**
+ * Strict equality comparison (===)
+ * @param left - First value to compare
+ * @param right - Second value to compare
+ * @returns TaggedTemplateValue<boolean> representing the strict equality expression
+ */
+export declare function strictEqual<T>(left: TaggedTemplateValue<T> | T, right: TaggedTemplateValue<T> | T): TaggedTemplateValue<boolean>;
+/**
+ * Inequality comparison (!=)
+ * @param left - First value to compare
+ * @param right - Second value to compare
+ * @returns TaggedTemplateValue<boolean> representing the inequality expression
+ */
+export declare function notEqual<T>(left: TaggedTemplateValue<T> | T, right: TaggedTemplateValue<T> | T): TaggedTemplateValue<boolean>;
+/**
+ * Strict inequality comparison (!==)
+ * @param left - First value to compare
+ * @param right - Second value to compare
+ * @returns TaggedTemplateValue<boolean> representing the strict inequality expression
+ */
+export declare function strictNotEqual<T>(left: TaggedTemplateValue<T> | T, right: TaggedTemplateValue<T> | T): TaggedTemplateValue<boolean>;
+/**
+ * Greater than comparison (>)
+ * @param left - First value to compare
+ * @param right - Second value to compare
+ * @returns TaggedTemplateValue<boolean> representing the greater than expression
+ */
+export declare function greaterThan<T extends number | string>(left: TaggedTemplateValue<T> | T, right: TaggedTemplateValue<T> | T): TaggedTemplateValue<boolean>;
+/**
+ * Greater than or equal comparison (>=)
+ * @param left - First value to compare
+ * @param right - Second value to compare
+ * @returns TaggedTemplateValue<boolean> representing the greater than or equal expression
+ */
+export declare function greaterThanOrEqual<T extends number | string>(left: TaggedTemplateValue<T> | T, right: TaggedTemplateValue<T> | T): TaggedTemplateValue<boolean>;
+/**
+ * Less than comparison (<)
+ * @param left - First value to compare
+ * @param right - Second value to compare
+ * @returns TaggedTemplateValue<boolean> representing the less than expression
+ */
+export declare function lessThan<T extends number | string>(left: TaggedTemplateValue<T> | T, right: TaggedTemplateValue<T> | T): TaggedTemplateValue<boolean>;
+/**
+ * Less than or equal comparison (<=)
+ * @param left - First value to compare
+ * @param right - Second value to compare
+ * @returns TaggedTemplateValue<boolean> representing the less than or equal expression
+ */
+export declare function lessThanOrEqual<T extends number | string>(left: TaggedTemplateValue<T> | T, right: TaggedTemplateValue<T> | T): TaggedTemplateValue<boolean>;
+/**
+ * Addition operation (+)
+ * @param args - Values or bindings to add together
+ * @returns TaggedTemplateValue<number> representing the addition expression
+ */
+export declare function add(...args: Array<TaggedTemplateValue<number> | number>): TaggedTemplateValue<number>;
+/**
+ * Subtraction operation (-)
+ * @param left - Value to subtract from
+ * @param right - Value to subtract
+ * @returns TaggedTemplateValue<number> representing the subtraction expression
+ */
+export declare function subtract(left: TaggedTemplateValue<number> | number, right: TaggedTemplateValue<number> | number): TaggedTemplateValue<number>;
+/**
+ * Multiplication operation (*)
+ * @param args - Values or bindings to multiply together
+ * @returns TaggedTemplateValue<number> representing the multiplication expression
+ */
+export declare function multiply(...args: Array<TaggedTemplateValue<number> | number>): TaggedTemplateValue<number>;
+/**
+ * Division operation (/)
+ * @param left - Dividend
+ * @param right - Divisor
+ * @returns TaggedTemplateValue<number> representing the division expression
+ */
+export declare function divide(left: TaggedTemplateValue<number> | number, right: TaggedTemplateValue<number> | number): TaggedTemplateValue<number>;
+/**
+ * Modulo operation (%)
+ * @param left - Dividend
+ * @param right - Divisor
+ * @returns TaggedTemplateValue<number> representing the modulo expression
+ */
+export declare function modulo(left: TaggedTemplateValue<number> | number, right: TaggedTemplateValue<number> | number): TaggedTemplateValue<number>;
+/**
+ * Conditional (ternary) operation - if-then-else logic
+ * @param condition - Condition to evaluate
+ * @param ifTrue - Value to return if condition is truthy
+ * @param ifFalse - Value to return if condition is falsy
+ * @returns TaggedTemplateValue<T> representing the conditional expression
+ */
+export declare function conditional<T>(condition: TaggedTemplateValue<boolean> | boolean, ifTrue: TaggedTemplateValue<T> | T, ifFalse: TaggedTemplateValue<T> | T): TaggedTemplateValue<T>;
+/**
+ * Function call expression
+ * @param functionName - Name of the function to call
+ * @param args - Arguments to pass to the function
+ * @returns TaggedTemplateValue<T> representing the function call expression
+ */
+export declare function call<T = unknown>(functionName: string, ...args: Array<TaggedTemplateValue<unknown> | unknown>): TaggedTemplateValue<T>;
+/**
+ * Creates a literal value expression
+ * @param value - Literal value to create expression for
+ * @returns TaggedTemplateValue<T> representing the literal
+ */
+export declare function literal<T>(value: T): TaggedTemplateValue<T>;
+export { and as AND };
+export { or as OR };
+export { not as NOT };
+export { nor as NOR };
+export { nand as NAND };
+export { xor as XOR };
+export { equal as eq };
+export { strictEqual as strictEq };
+export { notEqual as neq };
+export { strictNotEqual as strictNeq };
+export { greaterThan as gt };
+export { greaterThanOrEqual as gte };
+export { lessThan as lt };
+export { lessThanOrEqual as lte };
+export { add as plus };
+export { subtract as minus };
+export { multiply as times };
+export { divide as div };
+export { modulo as mod };
+export { conditional as ternary, conditional as ifElse };
+//# sourceMappingURL=std.d.ts.map

package/types/core/tagged-template/types.d.ts

@@ -0,0 +1,69 @@
+import type { Schema } from "@player-ui/types";
+export declare const TaggedTemplateValueSymbol: unique symbol;
+export interface TemplateRefOptions {
+    nestedContext?: "binding" | "expression";
+}
+export interface TaggedTemplateValue<T = unknown> {
+    [TaggedTemplateValueSymbol]: true;
+    /** Phantom type marker - not available at runtime */
+    readonly _phantomType?: T;
+    toValue(): string;
+    toRefString(options?: TemplateRefOptions): string;
+    toString(): string;
+}
+export declare function isTaggedTemplateValue(value: unknown): value is TaggedTemplateValue;
+/**
+ * Type that converts an object type to a bindable proxy type
+ * Each property access returns a TaggedTemplateValue with the correct type
+ */
+export type BindableProxy<T> = {
+    readonly [K in keyof T]: T[K] extends unknown[] ? TaggedTemplateValue<T[K]> : T[K] extends object ? BindableProxy<T[K]> : TaggedTemplateValue<T[K]>;
+};
+/**
+ * Maps primitive Schema types to their corresponding TypeScript types
+ */
+type PrimitiveTypeMap = {
+    StringType: string;
+    NumberType: number;
+    BooleanType: boolean;
+};
+/**
+ * Utility to force TypeScript to fully evaluate a type
+ */
+type Evaluate<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;
+/**
+ * Check if a type name is primitive
+ */
+type IsPrimitiveType<T extends string> = T extends keyof PrimitiveTypeMap ? true : false;
+/**
+ * Convert a primitive type name to its TaggedTemplateValue
+ */
+type PrimitiveToBinding<T extends string> = T extends keyof PrimitiveTypeMap ? TaggedTemplateValue<PrimitiveTypeMap[T]> : TaggedTemplateValue<string>;
+/**
+ * Process a single field from a node into its binding representation
+ */
+type ProcessField<Field extends Schema.DataTypes, S extends Schema.Schema, CurrentPath extends string> = Field extends {
+    type: infer TypeName extends string;
+} ? Field extends {
+    isArray: true;
+} ? IsPrimitiveType<TypeName> extends true ? TypeName extends "StringType" ? {
+    name: PrimitiveToBinding<TypeName>;
+} : {
+    value: PrimitiveToBinding<TypeName>;
+} : TypeName extends keyof S ? S[TypeName] extends Schema.Node ? ProcessNodeFields<S[TypeName], S, `${CurrentPath}._current_`> : TaggedTemplateValue<string> : TaggedTemplateValue<string> : IsPrimitiveType<TypeName> extends true ? PrimitiveToBinding<TypeName> : TypeName extends keyof S ? S[TypeName] extends Schema.Node ? ProcessNodeFields<S[TypeName], S, CurrentPath> : TaggedTemplateValue<string> : TaggedTemplateValue<string> : TaggedTemplateValue<string>;
+/**
+ * Process all fields in a node
+ */
+type ProcessNodeFields<Node extends Schema.Node, S extends Schema.Schema, BasePath extends string> = Evaluate<{
+    [K in keyof Node]: ProcessField<Node[K], S, BasePath extends "" ? K & string : `${BasePath}.${K & string}`>;
+}>;
+/**
+ * Main type to extract bindings from a schema
+ */
+export type ExtractedBindings<S extends Schema.Schema> = S extends {
+    ROOT: infer RootNode;
+} ? RootNode extends Schema.Node ? ProcessNodeFields<RootNode, S, ""> : never : never;
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,97 @@
+import type { Asset, Template } from "@player-ui/types";
+import { type BaseBuildContext } from "../base-builder";
+import { type TaggedTemplateValue } from "../tagged-template";
+/**
+ * Symbol marker to identify template functions
+ */
+export declare const TEMPLATE_MARKER: unique symbol;
+/**
+ * Type guard to check if a function is a template function
+ */
+export declare function isTemplate(fn: unknown): fn is ReturnType<typeof template>;
+/**
+ * Arguments for creating a template configuration
+ * @template T - The type of asset that will be created for each item in the array
+ */
+interface TemplateArgs<T extends Asset<string>> {
+    /** A binding that points to an array in the model */
+    readonly data: string | TaggedTemplateValue;
+    /** A property to put the mapped objects. If not provided, will be inferred from context */
+    readonly output?: string;
+    /** The asset creator - can be a static asset, a FluentBuilder, or a builder function that returns an asset */
+    readonly value: T | {
+        build(context?: BaseBuildContext): T;
+    } | (<K extends BaseBuildContext>(ctx: K) => T);
+    /** Whether template should be recomputed when data changes */
+    readonly dynamic?: boolean;
+}
+/**
+ * Creates a template configuration for dynamically creating a list of assets based on array data.
+ * Templates provide a way to dynamically create a list of assets, or any object, based on data from the model.
+ * All of the templating semantics are removed by the time it reaches an asset's transform or UI layer.
+ *
+ * Within a template, the `_index_` string can be used to substitute the array-index of the item being mapped.
+ *
+ * Multiple templates:
+ * - Templates can be nested. Use `_index_` for the outer loop, `_index1_` for the inner loop, and so on.
+ * - Multiple templates can output to the same property using the same output name. Items will be appended.
+ * - Templates can append to existing arrays by using the same output property name.
+ *
+ * Dynamic vs Static Templates:
+ * - If dynamic is false (default), the template will be parsed when a view first renders and won't update as data changes.
+ * - If dynamic is true, template will be updated whenever data changes while a view is still showing.
+ *
+ * @param args - The template configuration arguments
+ * @returns A function that takes parent context and returns a Template configuration
+ * @see https://player-ui.github.io/next/content/assets-views/#templates
+ * @example
+ * ```ts
+ * // Using a static asset
+ * template({
+ *   data: binding`users`,
+ *   output: "items",
+ *   value: text({ value: binding`users._index_.name` })
+ * })(parentCtx)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using a builder function
+ * template({
+ *   data: binding`users`,
+ *   output: "items",
+ *   value: (ctx) => text({ value: binding`users._index_.name` }).withId(genId(ctx))
+ * })(parentCtx)
+ * ```
+ *
+ * @example Multiple templates with the same output
+ * ```ts
+ * [
+ *   template({
+ *     data: binding`names`,
+ *     output: "values",
+ *     value: text({ id: `name-_index_`, value: binding`names._index_` })
+ *   })(parentCtx),
+ *   template({
+ *     data: binding`otherNames`,
+ *     output: "values",
+ *     value: text({ id: `other-name-_index_`, value: binding`otherNames._index_` })
+ *   })(parentCtx)
+ * ]
+ * ```
+ *
+ * @example Dynamic template that updates when data changes
+ * ```ts
+ * template({
+ *   data: binding`users`,
+ *   output: "items",
+ *   dynamic: true,
+ *   value: text({ value: binding`users._index_.name` })
+ * })(parentCtx)
+ * ```
+ */
+export declare const template: <T extends Asset<string>>({ data, output, value, dynamic, }: TemplateArgs<T>) => (parentCtx: BaseBuildContext) => Template<{
+    asset: T;
+}>;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,47 @@
+import { TaggedTemplateValue } from "../tagged-template";
+/**
+ * Type that can be either a direct value T or a TaggedTemplateValue
+ */
+export type TaggedOr<T> = T | TaggedTemplateValue;
+/**
+ * Safely extract a string if TaggedTemplateValue is present
+ */
+export declare function safeToString<T extends TaggedOr<string | unknown>>(value: T): string;
+/**
+ * Safely extract a boolean if TaggedTemplateValue is present
+ */
+export declare function safeToBoolean<T extends TaggedOr<boolean | unknown>>(value: T): boolean;
+/**
+ * Safely extract a number if TaggedTemplateValue is present
+ */
+export declare function safeToNumber<T extends TaggedOr<number | unknown>>(value: T): number;
+/**
+ * Type for an item that could be in an array with TaggedTemplate values
+ */
+export type ArrayItem<T> = T extends (infer U)[] ? U : T;
+/**
+ * Safely extract an array of values if TaggedTemplateValue is present
+ * Preserves element types when possible and handles nested arrays recursively
+ */
+export declare function safeToArray<T extends unknown[] | unknown>(value: TaggedOr<T>): Array<DeepUnwrapTagged<ArrayItem<T>>>;
+/**
+ * Recursively transforms a type by replacing TaggedTemplateValue with string
+ * and handling unions that contain TaggedTemplateValue
+ */
+export type DeepUnwrapTagged<T> = T extends TaggedTemplateValue ? T extends string ? string : string : TaggedTemplateValue extends T ? T extends TaggedTemplateValue ? string : Exclude<T, TaggedTemplateValue> : T extends Array<infer U> ? Array<DeepUnwrapTagged<U>> : T extends Record<string, unknown> ? {
+    [K in keyof T]: DeepUnwrapTagged<T[K]>;
+} : T;
+/**
+ * Safely extract an object if TaggedTemplateValue is present
+ * Recursively handles nested TaggedTemplateValues
+ */
+export declare function safeToObject<T extends Record<string, unknown>>(value: T): DeepUnwrapTagged<T>;
+/**
+ * Processes a value that could be a string, TaggedTemplateValue, or
+ * a complex object with nested TaggedTemplateValue instances
+ *
+ * This is useful for handling complex union types like:
+ * string | TaggedTemplateValue | Record<string, string | TaggedTemplateValue>
+ */
+export declare function safeFromMixedType<T>(value: unknown): DeepUnwrapTagged<T>;
+//# sourceMappingURL=index.d.ts.map

package/types/fp/index.d.ts

@@ -0,0 +1,149 @@
+import type { Result, Success, Failure } from "../types";
+/**
+ * Function composition utility that applies a sequence of functions to an initial value
+ * Each function receives the result of the previous function
+ * @param initialValue The initial value to start the pipeline
+ * @param fns The functions to apply in sequence
+ * @returns The final result after applying all functions
+ */
+export declare function pipe<A, B>(initialValue: A, fn1: (input: A) => B): B;
+export declare function pipe<A, B, C>(initialValue: A, fn1: (input: A) => B, fn2: (input: B) => C): C;
+export declare function pipe<A, B, C, D>(initialValue: A, fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D): D;
+export declare function pipe<A, B, C, D, E>(initialValue: A, fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E): E;
+export declare function pipe<A, B, C, D, E, F>(initialValue: A, fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E, fn5: (input: E) => F): F;
+export declare function pipe<A, B, C, D, E, F, G>(initialValue: A, fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E, fn5: (input: E) => F, fn6: (input: F) => G): G;
+export declare function pipe<A, B, C, D, E, F, G, H>(initialValue: A, fn1: (input: A) => B, fn2: (input: B) => C, fn3: (input: C) => D, fn4: (input: D) => E, fn5: (input: E) => F, fn6: (input: F) => G, fn7: (input: G) => H): H;
+/**
+ * Create a success result
+ * @param value The success value
+ * @returns A Success result
+ */
+export declare function success<T>(value: T): Success<T>;
+/**
+ * Create a failure result
+ * @param error The error object
+ * @returns A Failure result
+ */
+export declare function failure<E = Error>(error: E): Failure<E>;
+/**
+ * Type guard to check if a result is a Success
+ * @param result The result to check
+ * @returns Whether the result is a Success
+ */
+export declare function isSuccess<T, E = Error>(result: Result<T, E>): result is Success<T>;
+/**
+ * Type guard to check if a result is a Failure
+ * @param result The result to check
+ * @returns Whether the result is a Failure
+ */
+export declare function isFailure<T, E = Error>(result: Result<T, E>): result is Failure<E>;
+/**
+ * Map a function over a Result if it's a Success
+ * @param result The result to map over
+ * @param fn The mapping function
+ * @returns A new result with the mapping applied
+ */
+export declare function map<T, U, E = Error>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+/**
+ * Chain results together with a function that returns a new Result
+ * @param result The result to chain from
+ * @param fn The function that returns a new result
+ * @returns The result of applying the function
+ */
+export declare function flatMap<T, U, E = Error, F = Error>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F>;
+/**
+ * Apply a recovery function to transform a Failure into a Success
+ * @param result The result to recover from
+ * @param fn The recovery function
+ * @returns A Success result
+ */
+export declare function recover<T, E = Error>(result: Result<T, E>, fn: (error: E) => T): Success<T>;
+/**
+ * Get the value from a Result or throw if it's a Failure
+ * @param result The result to get the value from
+ * @returns The success value
+ * @throws The error from the Failure
+ */
+export declare function getOrThrow<T, E extends Error>(result: Result<T, E>): T;
+/**
+ * Get the value or a default if it's a Failure
+ * @param result The result to get the value from
+ * @param defaultValue The default value to use
+ * @returns The success value or the default
+ */
+export declare function getOrElse<T, E = Error>(result: Result<T, E>, defaultValue: T): T;
+/**
+ * Execute a function and return its result wrapped in a Result
+ * @param fn The function to execute
+ * @returns A Result containing the function's return value or error
+ */
+export declare function tryResult<T>(fn: () => T): Result<T, Error>;
+/**
+ * Handle both success and error cases with dedicated handlers
+ * @param result The result to match against
+ * @param onSuccess Handler for success case
+ * @param onFailure Handler for failure case
+ * @returns The result of the appropriate handler
+ */
+export declare function match<T, E = Error, U = unknown>(result: Result<T, E>, onSuccess: (value: T) => U, onFailure: (error: E) => U): U;
+/**
+ * Filter an array and return only successful results
+ * @param results Array of results to filter
+ * @returns Array of successful values
+ */
+export declare function filterSuccesses<T, E = Error>(results: Array<Result<T, E>>): T[];
+/**
+ * Transform an array of values using a function that returns Results
+ * @param values Array of values to transform
+ * @param fn Function that transforms each value to a Result
+ * @returns Array of Results
+ */
+export declare function mapToResults<T, U, E = Error>(values: T[], fn: (value: T) => Result<U, E>): Array<Result<U, E>>;
+/**
+ * Validate a value using a predicate function
+ * @param value The value to validate
+ * @param predicate The validation function
+ * @param errorMessage Error message if validation fails
+ * @returns Success if valid, Failure if invalid
+ */
+export declare function validate<T>(value: T, predicate: (value: T) => boolean, errorMessage: string): Result<T, Error>;
+/**
+ * Create a memoized version of a function
+ * @param fn The function to memoize
+ * @returns Memoized function
+ */
+export declare function memoize<T extends unknown[], R>(fn: (...args: T) => R): (...args: T) => R;
+/**
+ * Check if a value is not null or undefined
+ * @param value The value to check
+ * @returns Type guard for non-null values
+ */
+export declare function isNotNullish<T>(value: T | null | undefined): value is T;
+/**
+ * Safe array access that returns a Result
+ * @param array The array to access
+ * @param index The index to access
+ * @returns Success with the value or Failure if index is out of bounds
+ */
+export declare function safeArrayAccess<T>(array: T[], index: number): Result<T, Error>;
+/**
+ * Combine multiple Results into a single Result containing an array
+ * @param results Array of Results to combine
+ * @returns Success with array of values if all succeed, Failure with first error if any fail
+ */
+export declare function combineResults<T, E = Error>(results: Array<Result<T, E>>): Result<T[], E>;
+/**
+ * Result-aware pipe function that follows the railway pattern
+ * Chains functions that return Results, short-circuiting on the first failure
+ * @param initialResult The initial Result to start the pipeline
+ * @param fns The functions to apply in sequence, each taking a value and returning a Result
+ * @returns The final Result after applying all functions, or the first failure encountered
+ */
+export declare function pipeResult<A, B, E = Error>(initialResult: Result<A, E>, fn1: (input: A) => Result<B, E>): Result<B, E>;
+export declare function pipeResult<A, B, C, E = Error>(initialResult: Result<A, E>, fn1: (input: A) => Result<B, E>, fn2: (input: B) => Result<C, E>): Result<C, E>;
+export declare function pipeResult<A, B, C, D, E = Error>(initialResult: Result<A, E>, fn1: (input: A) => Result<B, E>, fn2: (input: B) => Result<C, E>, fn3: (input: C) => Result<D, E>): Result<D, E>;
+export declare function pipeResult<A, B, C, D, E, Err = Error>(initialResult: Result<A, Err>, fn1: (input: A) => Result<B, Err>, fn2: (input: B) => Result<C, Err>, fn3: (input: C) => Result<D, Err>, fn4: (input: D) => Result<E, Err>): Result<E, Err>;
+export declare function pipeResult<A, B, C, D, E, F, Err = Error>(initialResult: Result<A, Err>, fn1: (input: A) => Result<B, Err>, fn2: (input: B) => Result<C, Err>, fn3: (input: C) => Result<D, Err>, fn4: (input: D) => Result<E, Err>, fn5: (input: E) => Result<F, Err>): Result<F, Err>;
+export declare function pipeResult<A, B, C, D, E, F, G, Err = Error>(initialResult: Result<A, Err>, fn1: (input: A) => Result<B, Err>, fn2: (input: B) => Result<C, Err>, fn3: (input: C) => Result<D, Err>, fn4: (input: D) => Result<E, Err>, fn5: (input: E) => Result<F, Err>, fn6: (input: F) => Result<G, Err>): Result<G, Err>;
+export declare function pipeResult<A, B, C, D, E, F, G, H, Err = Error>(initialResult: Result<A, Err>, fn1: (input: A) => Result<B, Err>, fn2: (input: B) => Result<C, Err>, fn3: (input: C) => Result<D, Err>, fn4: (input: D) => Result<E, Err>, fn5: (input: E) => Result<F, Err>, fn6: (input: F) => Result<G, Err>, fn7: (input: G) => Result<H, Err>): Result<H, Err>;
+//# sourceMappingURL=index.d.ts.map

package/types/gen/common.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Re-exports from base-builder for generated builder files.
+ */
+export { FluentBuilderBase, type FluentBuilder, type BaseBuildContext, type FluentPartial, createInspectMethod, } from "../core/base-builder/index.js";
+export { type TaggedTemplateValue, isTaggedTemplateValue, } from "../core/tagged-template/types.js";
+//# sourceMappingURL=common.d.ts.map

package/types/index.d.ts

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