@golemui/core 0.0.2

package/lib/store/actions.d.ts

@@ -0,0 +1,121 @@
+import { FormWidget } from '../form-widget';
+import { DotPath, Uid, ValidateOn } from '../shared';
+import { FormHealth } from './model';
+export type INITIALIZE = {
+    type: 'INITIALIZE';
+    payload: {
+        formDef: string | Record<string, any>;
+        formName: string;
+    };
+};
+/**
+ * Sets the data for the entire form.
+ */
+export type SET_DATA = {
+    type: 'SET_DATA';
+    payload: {
+        data: Record<string, any>;
+    };
+};
+/**
+ * Sets the i18n language
+ */
+export type SET_LANGUAGE = {
+    type: 'SET_LANGUAGE';
+    payload: {
+        /**
+         * The BCP 47 language tag of the current locale (e.g., 'en-US', 'es', 'fr-CA').
+         */
+        lang: string;
+    };
+};
+export type ADD_WIDGET = {
+    type: 'ADD_WIDGET';
+    payload: {
+        widget: FormWidget<string>;
+    };
+};
+export type REMOVE_WIDGET = {
+    type: 'REMOVE_WIDGET';
+    payload: {
+        uid: Uid;
+    };
+};
+/**
+ * Sets the default value for a single form widget.
+ */
+export type SET_WIDGET_INITIAL_DATA = {
+    type: 'SET_WIDGET_INITIAL_DATA';
+    payload: {
+        path: DotPath;
+        data: any;
+    };
+};
+/**
+ * Sets the data for a single form widget.
+ */
+export type SET_WIDGET_DATA = {
+    type: 'SET_WIDGET_DATA';
+    payload: {
+        path: DotPath;
+        data: any;
+    };
+};
+/**
+ * Overrides a property in a form widget's `props` object.
+ */
+export type OVERRIDE_WIDGET_PROP = {
+    type: 'OVERRIDE_WIDGET_PROP';
+    payload: {
+        path: DotPath;
+        prop: string;
+        value: any;
+    };
+};
+export type SET_FORM_HEALTH = {
+    type: 'SET_FORM_HEALTH';
+    payload: {
+        formHealth: FormHealth;
+    };
+};
+/**
+ * Action type indicating an attempt to validate form data.
+ *
+ * When dispatched, this action triggers validation for the entire form based on
+ * the form's validation configuration. However, validation errors will only be
+ * displayed for the specific widget identified by the `path` property, which will
+ * be marked as _touched_.
+ *
+ * The actual validation behavior is determined by the form's configuration and
+ * may not execute immediately upon dispatch.
+ * ```
+ */
+export type ATTEMPT_VALIDATION = {
+    type: 'ATTEMPT_VALIDATION';
+    payload: {
+        reason: Exclude<ValidateOn, any[] | 'eager' | 'submit'>;
+        path: DotPath;
+        uid: Uid;
+    };
+};
+/**
+ * Action type that validates all form widgets and marks them as _touched_.
+ *
+ * When dispatched, this action triggers validation for every widget in the form
+ * and marks all widgets as _touched_, causing validation errors to be displayed
+ * for all invalid widgets regardless of the form's validation configuration.
+ *
+ * This action is typically dispatched when the user attempts to submit the form,
+ * ensuring all validation errors are visible before submission proceeds.
+ */
+export type VALIDATE_ALL = {
+    type: 'VALIDATE_ALL';
+};
+export type INJECT_VALIDATION_ISSUES = {
+    type: 'INJECT_VALIDATION_ISSUES';
+    payload: {
+        issues: string[] | null;
+        path: DotPath;
+    };
+};
+export type Action = INITIALIZE | SET_LANGUAGE | SET_DATA | ADD_WIDGET | REMOVE_WIDGET | SET_WIDGET_INITIAL_DATA | SET_WIDGET_DATA | OVERRIDE_WIDGET_PROP | SET_FORM_HEALTH | INJECT_VALIDATION_ISSUES | ATTEMPT_VALIDATION | VALIDATE_ALL;

package/lib/store/model.d.ts

@@ -0,0 +1,107 @@
+import { DotPath, Uid, ValidationStatus } from '../shared';
+import * as Form from '../form';
+import * as Widget from '../form-widget';
+export type State = {
+    formName: string;
+    /**
+     * The complete form definition.
+     */
+    formDef: Form.Form<string>;
+    /**
+     * Flattened representation of `formDef` as a map from UID to widget definition.
+     * Enables more efficient lookup and processing in downstream operations.
+     */
+    flatForm: Record<Uid, Widget.FormWidget<string>>;
+    /**
+     * List of states computed for the current form state.
+     */
+    currentStates: string[];
+    /**
+     * Tracks widgets whose components have been rendered.
+     * A widget is added when its component mounts and removed when it unmounts.
+     */
+    calculatedWidgets: Record<Uid, DerivedWidget<Widget.FormWidget<string>>>;
+    /**
+     * Validations statuses derived from the schema validators expressed declaratively.
+     *
+     * These validation statuses are produced automatically by the configured schema
+     * validators (e.g. zod), and are fully managed by the validation engine and should
+     * not be mutated directly.
+     */
+    validations: Record<DotPath, ValidationStatus>;
+    /**
+     * Tracks controls that have been _touched_ hence can display validation errors.
+     */
+    touchedControls: Record<DotPath, boolean>;
+    /**
+     * Validation statuses injected imperatively via the public API.
+     *
+     * These validation statuses are not derived from the schema validators and are intended
+     * for contextual validations that cannot be expressed declaratively.
+     */
+    injectedValidations: Record<DotPath, ValidationStatus>;
+    /**
+     * Tracks widgets with state expressions.
+     * When data changes, these widgets are updated and their flags recalculated.
+     */
+    widgetFlags: Record<Uid, {
+        hidden?: boolean;
+        readonly?: boolean;
+        disabled?: boolean;
+    }>;
+    /**
+     * Allows overriding a widget’s `prop` properties externally via its event handler mechanism.
+     * For example, this can be used to load options for a select widget asynchronously.
+     */
+    widgetPropOverrides: Record<Uid, Record<string, any>>;
+    data: Record<string, any>;
+    /**
+     * This reflects whether the form is currently functioning normally
+     * or is in an errored state.
+     */
+    formHealth: FormHealth;
+    /**
+     * Indicates whether the user has interacted with the form.
+     * Set to true when a validateOn-type event occurs on any form control.
+     */
+    touched: boolean;
+    /**
+     * The BCP 47 language tag of the current locale (e.g., 'en-US', 'es', 'fr-CA').
+     */
+    lang: string;
+};
+export declare const createInitialState: (lang: string) => State;
+export type MiddlewareAPI<S, A> = {
+    getState: () => S;
+    dispatch: (action: A) => void;
+};
+export type Middleware<S, A> = (api: MiddlewareAPI<S, A>) => (next: (action: A) => void) => (action: A) => void;
+/**
+ * Represents the current operational state of the form.
+ * When in an errored state, the form is considered non-operational
+ * until the error is cleared.
+ */
+export type FormHealth = {
+    status: 'ok';
+} | {
+    status: 'errored';
+    message: string;
+};
+/**
+ * Represents a form widget whose value is derived from a computation
+ * and evaluated against its previous derived state.
+ *
+ * A `DerivedWidget<T>` captures the source widget, the previous derived value,
+ * the newly derived value, and whether a structural change occurred between
+ * derivations.
+ */
+export type DerivedWidget<F extends Widget.FormWidget<string>> = {
+    /** The source widget from which the derived value is computed */
+    source: F;
+    /** The previously derived value */
+    previous: Exclude<F, Widget.FunctionWidget<string>>;
+    /** The newly derived value */
+    current: Exclude<F, Widget.FunctionWidget<string>>;
+    /** Indicates whether the newly derived value changed structurally */
+    changed?: boolean;
+};

package/lib/store/reducer.d.ts

@@ -0,0 +1,10 @@
+import { ValidatorFn } from '../form-validator';
+import { I18nTranslator } from '../i18n';
+import { ValidateOn } from '../shared';
+import { Action } from './actions';
+import { State } from './model';
+export declare const reducer: ({ validators, validateOn, localization, }: {
+    validators: ValidatorFn<any>;
+    validateOn: ValidateOn;
+    localization: I18nTranslator;
+}) => (state: State, action: Action) => State;

package/lib/store/reducers/add-widget.d.ts

@@ -0,0 +1,3 @@
+import { ADD_WIDGET } from '../actions';
+import { State } from '../model';
+export declare function addWidget(state: State, action: ADD_WIDGET): State;

package/lib/store/reducers/calculate-current-state.d.ts

@@ -0,0 +1,2 @@
+import { State } from '../model';
+export declare const calculateCurrentState: (state: State) => State;

package/lib/store/reducers/calculate-widget-flags.d.ts

@@ -0,0 +1,2 @@
+import { State } from '../model';
+export declare const calculateWidgetFlags: (state: State) => State;

package/lib/store/reducers/calculate-widget-props.d.ts

@@ -0,0 +1,3 @@
+import { I18nTranslator } from '../../i18n';
+import { State } from '../model';
+export declare const calculateWidgetProps: (localization: I18nTranslator) => (state: State) => State;

package/lib/store/reducers/index.d.ts

@@ -0,0 +1,13 @@
+export * from './add-widget';
+export * from './calculate-current-state';
+export * from './calculate-widget-flags';
+export * from './calculate-widget-props';
+export * from './initialize';
+export * from './inject-validation-issues';
+export * from './override-widget-prop';
+export * from './remove-widget';
+export * from './set-data';
+export * from './set-widget-data';
+export * from './set-form-health';
+export * from './set-language';
+export * from './validate-all';

package/lib/store/reducers/initialize.d.ts

@@ -0,0 +1,3 @@
+import { State } from '../model';
+import * as Actions from '../actions';
+export declare const initialize: ({ lang }: State, action: Actions.INITIALIZE) => State;

package/lib/store/reducers/inject-validation-issues.d.ts

@@ -0,0 +1,3 @@
+import { INJECT_VALIDATION_ISSUES } from '../actions';
+import { State } from '../model';
+export declare function injectValidationIssues(state: State, action: INJECT_VALIDATION_ISSUES): State;

package/lib/store/reducers/override-widget-prop.d.ts

@@ -0,0 +1,3 @@
+import { State } from '../model';
+import * as Actions from '../actions';
+export declare const overrideWidgetProp: (state: State, { payload }: Actions.OVERRIDE_WIDGET_PROP) => State;

package/lib/store/reducers/remove-widget.d.ts

@@ -0,0 +1,3 @@
+import { REMOVE_WIDGET } from '../actions';
+import { State } from '../model';
+export declare function removeWidget(state: State, action: REMOVE_WIDGET): State;

package/lib/store/reducers/set-data.d.ts

@@ -0,0 +1,3 @@
+import { State } from '../model';
+import * as Actions from '../actions';
+export declare const setData: (state: State, action: Actions.SET_DATA) => State;

package/lib/store/reducers/set-form-health.d.ts

@@ -0,0 +1,8 @@
+import { State } from '../model';
+import * as Actions from '../actions';
+/**
+ * Updates the operational state of the form.
+ * This reflects whether the form is currently functioning normally
+ * or is in an errored state.
+ */
+export declare const setFormHealth: (state: State, action: Actions.SET_FORM_HEALTH) => State;

package/lib/store/reducers/set-language.d.ts

@@ -0,0 +1,3 @@
+import { State } from '../model';
+import * as Actions from '../actions';
+export declare const setLanguage: (state: State, action: Actions.SET_LANGUAGE) => State;

package/lib/store/reducers/set-widget-data.d.ts

@@ -0,0 +1,3 @@
+import { State } from '../model';
+import * as Actions from '../actions';
+export declare const setWidgetData: (state: State, action: Actions.SET_WIDGET_DATA | Actions.SET_WIDGET_INITIAL_DATA) => State;

package/lib/store/reducers/utils.d.ts

@@ -0,0 +1,32 @@
+import { DotPath } from '../../shared';
+import { State } from '../model';
+/**
+ * Conditionally applies a reducer function based on a predicate
+ *
+ * This higher-order reducer creates a new reducer that only applies the given
+ * reducer function when the predicate function returns true for the current state.
+ * If the predicate returns false, the state is returned unchanged.
+ *
+ * @param predicate - A function that takes the current state and returns a boolean
+ * indicating whether the reducer should be applied
+ * @param reducerFn - The reducer function to apply when the predicate returns true
+ *
+ * @returns A new reducer function that conditionally applies the given reducer
+ *
+ * @example
+ * ```typescript
+ * // Only increment if count is less than 10
+ * const conditionalIncrement = reduceIf(
+ *   (state: { count: number }) => state.count < 10,
+ *   (state) => ({ ...state, count: state.count + 1 })
+ * );
+ *
+ * conditionalIncrement({ count: 5 }); // returns { count: 6 }
+ * conditionalIncrement({ count: 10 }); // returns { count: 10 } (unchanged)
+ * ```
+ */
+export declare const reduceIf: (predicate: (state: State) => boolean, reducerFn: (state: State) => State) => (state: State) => State;
+export declare const isControlTouched: (widgetPath: DotPath) => (state: State) => boolean;
+export declare const hasWhen: (val: unknown) => val is {
+    when: string;
+};

package/lib/store/reducers/validate-all.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorFn } from '../../form-validator';
+import { State } from '../model';
+export declare const validateAll: (validators: ValidatorFn<any>) => (state: State) => State;

package/lib/store/selectors.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { LayoutWidget } from '../form-widget';
+import { DotPath, Uid } from '../shared';
+import { State } from './model';
+export declare const dataByPath$: <T = any>(path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<T>>;
+export declare const validationByPath$: (path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<import('../shared').ValidationStatus>>;
+export declare const injectedValidationByPath$: (path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<import('../shared').ValidationStatus>>;
+export declare const calculatedWidgetsByUid$: (uid: Uid) => import('rxjs').UnaryFunction<Observable<State>, Observable<import('../form-widget').NonFunctionWidget<string, any, any>>>;
+export declare const calculatedLayoutChildrenByUid$: (uid: Uid) => import('rxjs').UnaryFunction<Observable<State>, Observable<(import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, /*elided*/ any> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]>>;
+export declare const selectWidgetFlags: import('rxjs').UnaryFunction<Observable<State>, Observable<Record<string, {
+    hidden?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+}>>>;
+export declare const widgetFlagsByUid$: (uid: Uid) => import('rxjs').UnaryFunction<Observable<State>, Observable<{
+    hidden?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+}>>;
+export declare const touchedControlsByPath$: (path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<boolean>>;
+export declare const formHealth: (store: Observable<State>) => Observable<import('./model').FormHealth>;

package/lib/utils/array.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Unique marker value used to explicitly indicate that an element
+ * should be skipped by {@link filterMap}.
+ *
+ * This is a stable singleton and does not allocate per iteration.
+ */
+export declare const SKIP: unique symbol;
+/**
+ * Applies a mapping function to each element of an array and collects
+ * only the values that are not {@link SKIP}.
+ *
+ * This combines `map` and `filter` in a single pass without allocating
+ * intermediate arrays or sentinel objects.
+ *
+ * @typeParam T - The type of the input array elements.
+ * @typeParam U - The type of the mapped output elements.
+ *
+ * @param array - The source array to iterate over.
+ * @param fn - A function that maps each element to a value of type `U`,
+ * or returns {@link SKIP} to exclude the element from the result.
+ *
+ * @returns A new array containing only the mapped values.
+ *
+ * @example
+ * ```ts
+ * const result = filterMap([1, 2, 3, 4], n =>
+ *   n % 2 === 0 ? String(n) : SKIP
+ * );
+ * // result: ["2", "4"]
+ * ```
+ */
+export declare function filterMap<T, U>(array: readonly T[], fn: (value: T, index: number, array: readonly T[]) => U | typeof SKIP): U[];
+/**
+ * Compares two arrays for structural equality by applying a predicate
+ * to each pair of elements.
+ *
+ * The function:
+ * - Fails fast if array lengths differ
+ * - Iterates in a single pass
+ * - Short-circuits immediately when the predicate returns `false`
+ *
+ * @param a - First array.
+ * @param b - Second array.
+ * @param predicate - A function invoked for each pair of elements.
+ * It must return `true` if the elements are considered equal, or `false`
+ * to terminate early and indicate inequality.
+ *
+ * @returns `true` if arrays are structurally equal according to the
+ * predicate; otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * const equal = zipEvery(
+ *   [1, 2, 3],
+ *   [1, 2, 3],
+ *   (a, b) => a === b
+ * );
+ * // true
+ * ```
+ */
+export declare function zipEvery<A, B>(a: readonly A[], b: readonly B[], predicate: (aValue: A, bValue: B, index: number, a: readonly A[], b: readonly B[]) => boolean): boolean;

package/lib/utils/assert-never.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Ensures exhaustiveness in compile-time checks and throws at runtime
+ * if an unhandled case is encountered.
+ */
+export declare const assertNever: (value: never) => never;

package/lib/utils/debug.d.ts

@@ -0,0 +1,3 @@
+export declare const Debug: {
+    log: <T>(value: T, label?: string) => T;
+};

package/lib/utils/decoder.d.ts

@@ -0,0 +1,51 @@
+import * as jd from 'ts.data.json';
+export type KeySpec<A> = Record<string, {
+    suffixed?: boolean;
+    decoder: jd.Decoder<A>;
+}>;
+/**
+ * Creates a JSON decoder for objects whose keys are validated against a
+ * specification map.
+ *
+ * Each entry in `specs` defines:
+ * - the base key name
+ * - whether the key may appear with dot-suffixed variants
+ * - the decoder used to validate the corresponding values
+ *
+ * Matching rules:
+ * - If `suffixed` is `false`, only the exact key is accepted.
+ * - If `suffixed` is `true`, both the base key and any keys starting with
+ *   `<key>.` are accepted.
+ * - Any object key that does not match one of the specifications causes
+ *   decoding to fail.
+ *
+ * All values are decoded independently using the decoder associated with the
+ * matched key. Decoded values are returned under their original object keys
+ * (including suffixes).
+ *
+ * @typeParam T - The resulting object shape after successful decoding.
+ *
+ * @param specs - A map of base keys to their decoding specification.
+ * @param decoderName - Human-readable name used in error messages.
+ *
+ * @returns A `jd.Decoder` that validates and decodes objects according to the
+ *          provided key specifications.
+ *
+ * @example
+ * ```ts
+ * const decoder = objectWithSuffix<Record<string, string>>(
+ *   {
+ *     label: { suffixed: true, decoder: jd.string() },
+ *     title: { suffixed: false, decoder: jd.string() },
+ *   },
+ *   'MyObj',
+ * );
+ *
+ * decoder.decode({
+ *   label: 'Submit',
+ *   'label.register': 'Register',
+ *   title: 'Form',
+ * });
+ * ```
+ */
+export declare function objectWithSuffix<T extends Record<string, any>>(specs: KeySpec<any>, decoderName: string): jd.Decoder<T>;

package/lib/utils/dot-path.d.ts

@@ -0,0 +1,16 @@
+import { DotPath } from '../shared';
+/**
+ * Heuristically checks if a value looks like a dot notation path
+ * rather than a standard string.
+ * To be considered a "potential" dot path, the value must:
+ * 1. Be a string.
+ * 2. Start with one of the allowed prefixes ($form.*, $error.* or $meta.*).
+ * 3. Not contain any spaces (distinguishing it from sentences).
+ *
+ * * @example
+ * isPotentialDotPath('$form.user.id');   // true
+ * isPotentialDotPath('name');      // false (No prefix)
+ * isPotentialDotPath('my file');   // false (Contains space)
+ * isPotentialDotPath(123);         // false (Not a string)
+ */
+export declare const isPotentialDotPath: (path: unknown) => path is DotPath;

package/lib/utils/form.d.ts

@@ -0,0 +1,20 @@
+import * as Widget from '../form-widget';
+/**
+ * Flattens the hierarchical form structure into a single-level array of form widgets.
+ *
+ * @returns A flattened array of all form widgets, including nested ones from layout widgets
+ *
+ * @example
+ * ```typescript
+ * const hierarchicalWidgets = [
+ *   { type: 'text', name: 'firstName' },
+ *   { type: 'layout', children: [
+ *     { type: 'text', name: 'street' },
+ *     { type: 'text', name: 'city' }
+ *   ]}
+ * ];
+ * const flatWidgets = flattenForm(hierarchicalWidgets);
+ * // Result: [firstName, layout, street, city]
+ * ```
+ */
+export declare function flattenForm(widgets: Widget.FormWidget[]): Widget.FormWidget[];

package/lib/utils/function.d.ts

@@ -0,0 +1,71 @@
+/**
+ * A function type that transforms a value of type A to type B
+ */
+type Func<A, B> = (arg: A) => B;
+/**
+ * Performs left-to-right function composition (pipeline).
+ * The output of each function is passed as input to the next function.
+ *
+ * @typeParam A - The initial value type
+ * @param value - The initial value to pipe through the functions
+ * @param fns - Functions to apply in sequence
+ * @returns The result after applying all functions
+ *
+ * @example
+ * ```typescript
+ * const addOne = (x: number) => x + 1;
+ * const double = (x: number) => x * 2;
+ * const toString = (x: number) => `Result: ${x}`;
+ *
+ * const result = pipe(5, addOne, double, toString); // 5 -> 6 -> 12 -> "Result: 12"
+ * ```
+ */
+declare function pipe<A>(value: A): A;
+/** @see {@link pipe} */
+declare function pipe<A, B>(value: A, fn1: Func<A, B>): B;
+/** @see {@link pipe} */
+declare function pipe<A, B, C>(value: A, fn1: Func<A, B>, fn2: Func<B, C>): C;
+/** @see {@link pipe} */
+declare function pipe<A, B, C, D>(value: A, fn1: Func<A, B>, fn2: Func<B, C>, fn3: Func<C, D>): D;
+/** @see {@link pipe} */
+declare function pipe<A, B, C, D, E>(value: A, fn1: Func<A, B>, fn2: Func<B, C>, fn3: Func<C, D>, fn4: Func<D, E>): E;
+/** @see {@link pipe} */
+declare function pipe<A, B, C, D, E, F>(value: A, fn1: Func<A, B>, fn2: Func<B, C>, fn3: Func<C, D>, fn4: Func<D, E>, fn5: Func<E, F>): F;
+/** @see {@link pipe} */
+declare function pipe<A, B, C, D, E, F, G>(value: A, fn1: Func<A, B>, fn2: Func<B, C>, fn3: Func<C, D>, fn4: Func<D, E>, fn5: Func<E, F>, fn6: Func<F, G>): G;
+/** @see {@link pipe} */
+declare function pipe<A, B, C, D, E, F, G, H>(value: A, fn1: Func<A, B>, fn2: Func<B, C>, fn3: Func<C, D>, fn4: Func<D, E>, fn5: Func<E, F>, fn6: Func<F, G>, fn7: Func<G, H>): H;
+/**
+ * Performs right-to-left function composition.
+ * The output of each function is passed as input to the previous function.
+ *
+ * @typeParam A - The input type of the composed function
+ * @returns A new function that applies all the given functions from right to left
+ *
+ * @example
+ * Basic composition
+ * ```typescript
+ * const addOne = (x: number) => x + 1;
+ * const double = (x: number) => x * 2;
+ * const toString = (x: number) => `Result: ${x}`;
+ *
+ * const transform = compose(toString, double, addOne); // Applies: addOne -> double -> toString
+ * console.log(transform(5)); // "Result: 12"
+ * ```
+ */
+declare function compose<A>(fn1: Func<A, A>): Func<A, A>;
+/** @see {@link compose} */
+declare function compose<A, B>(fn1: Func<A, B>, fn2: Func<B, A>): Func<B, B>;
+/** @see {@link compose} */
+declare function compose<A, B, C>(fn1: Func<B, C>, fn2: Func<A, B>): Func<A, C>;
+/** @see {@link compose} */
+declare function compose<A, B, C, D>(fn1: Func<C, D>, fn2: Func<B, C>, fn3: Func<A, B>): Func<A, D>;
+/** @see {@link compose} */
+declare function compose<A, B, C, D, E>(fn1: Func<D, E>, fn2: Func<C, D>, fn3: Func<B, C>, fn4: Func<A, B>): Func<A, E>;
+/** @see {@link compose} */
+declare function compose<A, B, C, D, E, F>(fn1: Func<E, F>, fn2: Func<D, E>, fn3: Func<C, D>, fn4: Func<B, C>, fn5: Func<A, B>): Func<A, F>;
+/** @see {@link compose} */
+declare function compose<A, B, C, D, E, F, G>(fn1: Func<F, G>, fn2: Func<E, F>, fn3: Func<D, E>, fn4: Func<C, D>, fn5: Func<B, C>, fn6: Func<A, B>): Func<A, G>;
+/** @see {@link compose} */
+declare function compose<A, B, C, D, E, F, G, H>(fn1: Func<G, H>, fn2: Func<F, G>, fn3: Func<E, F>, fn4: Func<D, E>, fn5: Func<C, D>, fn6: Func<B, C>, fn7: Func<A, B>): Func<A, H>;
+export { compose, pipe };