@nlozgachev/pipelined 0.44.0 → 0.46.0

package/dist/utils.d.ts

@@ -1,56 +1,7 @@
-import { N as NonEmptyArr } from './InternalTypes-7o9-yrHq.js';
-import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-DM2eh6wj.js';
-import './types.js';
+import { a as NonEmptyArr, N as NonEmpty } from './InternalTypes-Mssktd7z.js';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-BMsvixWH.js';
+import { Brand } from './types.js';
 
-declare namespace ArrMaybe {
-    /**
-     * Maps each element to a Maybe and collects the results.
-     * Returns None if any mapping returns None.
-     *
-     * @example
-     * ```ts
-     * const parseNum = (s: string): Maybe<number> => {
-     *   const n = Number(s);
-     *   return isNaN(n) ? Maybe.none() : Maybe.some(n);
-     * };
-     *
-     * pipe(["1", "2", "3"], Arr.Maybe.traverse(parseNum)); // Some([1, 2, 3])
-     * pipe(["1", "x", "3"], Arr.Maybe.traverse(parseNum)); // None
-     * ```
-     */
-    const traverse: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => Maybe<readonly B[]>;
-    /**
-     * Collects an array of Maybe instances into a Maybe of array.
-     * Returns None if any element is None.
-     *
-     * @example
-     * ```ts
-     * Arr.Maybe.sequence([Maybe.some(1), Maybe.some(2)]); // Some([1, 2])
-     * Arr.Maybe.sequence([Maybe.some(1), Maybe.none()]); // None
-     * ```
-     */
-    const sequence: <A>(data: readonly Maybe<A>[]) => Maybe<readonly A[]>;
-}
-declare namespace ArrResult {
-    /**
-     * Maps each element to a Result and collects the results.
-     * Returns the first Err if any mapping fails.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   [1, 2, 3],
-     *   Arr.Result.traverse(n => n > 0 ? Result.ok(n) : Result.err("negative"))
-     * ); // Ok([1, 2, 3])
-     * ```
-     */
-    const traverse: <E, A, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => Result<E, readonly B[]>;
-    /**
-     * Collects an array of Results into a Result of array.
-     * Returns the first Err if any element is Err.
-     */
-    const sequence: <E, A>(data: readonly Result<E, A>[]) => Result<E, readonly A[]>;
-}
 declare namespace ArrTaskResult {
     /**
      * Maps each element to a Task.Result and runs them sequentially.
@@ -79,25 +30,6 @@ declare namespace ArrTaskResult {
      */
     const sequence: <E, A>(data: readonly Task<Result<E, A>>[]) => Task<Result<E, readonly A[]>>;
 }
-declare namespace ArrTask {
-    /**
-     * Maps each element to a Task and runs all in parallel.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   [1, 2, 3],
-     *   Arr.Task.traverse(n => Task.resolve(n * 2))
-     * )(); // Promise<[2, 4, 6]>
-     * ```
-     */
-    const traverse: <A, B>(f: (a: A) => Task<B>) => (data: readonly A[]) => Task<readonly B[]>;
-    /**
-     * Collects an array of Tasks into a Task of array. Runs in parallel.
-     */
-    const sequence: <A>(data: readonly Task<A>[]) => Task<readonly A[]>;
-    const Result: typeof ArrTaskResult;
-}
 declare namespace ArrNonEmpty {
     /**
      * Creates a single-element list.
@@ -108,16 +40,18 @@ declare namespace ArrNonEmpty {
      * ```
      */
     const singleton: <A>(value: A) => NonEmptyArr<A>;
-    /**
-     * Returns Some if the array is non-empty, None otherwise.
-     *
-     * @example
-     * ```ts
-     * Arr.NonEmpty.fromArray([1, 2]); // Some([1, 2])
-     * Arr.NonEmpty.fromArray([]); // None
-     * ```
-     */
-    const fromArray: <A>(data: readonly A[]) => Maybe<NonEmptyArr<A>>;
+    namespace from {
+        /**
+         * Returns Some if the array is non-empty, None otherwise.
+         *
+         * @example
+         * ```ts
+         * Arr.NonEmpty.from.Array([1, 2]); // Some([1, 2])
+         * Arr.NonEmpty.from.Array([]); // None
+         * ```
+         */
+        const Array: <A>(data: readonly A[]) => Maybe<NonEmptyArr<A>>;
+    }
     /**
      * Returns the first element of a NonEmptyArr.
      *
@@ -154,6 +88,51 @@ declare namespace ArrNonEmpty {
      * ```
      */
     const reduce: <A>(f: (acc: A, a: A) => A) => (data: NonEmptyArr<A>) => A;
+    /**
+     * Transforms each element of a NonEmptyArr.
+     *
+     * @example
+     * ```ts
+     * pipe(Arr.NonEmpty.singleton(1), Arr.NonEmpty.map(n => n * 2)); // [2]
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => (data: NonEmptyArr<A>) => NonEmptyArr<B>;
+    /**
+     * Transforms each element of a NonEmptyArr, also receiving the index.
+     *
+     * @example
+     * ```ts
+     * pipe(Arr.NonEmpty.singleton("a"), Arr.NonEmpty.mapWithIndex((i, s) => `${i}:${s}`)); // ["0:a"]
+     * ```
+     */
+    const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: NonEmptyArr<A>) => NonEmptyArr<B>;
+    /**
+     * Inserts a separator between every element of a NonEmptyArr.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2] as Arr.NonEmpty<number>, Arr.NonEmpty.intersperse(0)); // [1, 0, 2]
+     * ```
+     */
+    const intersperse: <A>(sep: A) => (data: NonEmptyArr<A>) => NonEmptyArr<A>;
+    /**
+     * Concatenates a NonEmptyArr with a standard array.
+     *
+     * @example
+     * ```ts
+     * pipe(Arr.NonEmpty.singleton(1), Arr.NonEmpty.concat([2, 3])); // [1, 2, 3]
+     * ```
+     */
+    const concat: <A>(other: readonly A[]) => (data: NonEmptyArr<A>) => NonEmptyArr<A>;
+    /**
+     * Reverses a NonEmptyArr.
+     *
+     * @example
+     * ```ts
+     * pipe(Arr.NonEmpty.singleton(1), Arr.NonEmpty.reverse); // [1]
+     * ```
+     */
+    const reverse: <A>(data: NonEmptyArr<A>) => NonEmptyArr<A>;
 }
 /**
  * Functional array utilities that compose well with pipe.
@@ -180,7 +159,7 @@ declare namespace Arr {
      * const list: Arr.NonEmpty<number> = [1, 2, 3];
      * ```
      */
-    type NonEmpty<A> = NonEmptyArr<A>;
+    export type NonEmpty<A> = NonEmptyArr<A>;
     /**
      * Returns the first element of an array, or None if the array is empty.
      *
@@ -190,7 +169,7 @@ declare namespace Arr {
      * Arr.head([]); // None
      * ```
      */
-    const head: <A>(data: readonly A[]) => Maybe<A>;
+    export const head: <A>(data: readonly A[]) => Maybe<A>;
     /**
      * Returns the last element of an array, or None if the array is empty.
      *
@@ -200,7 +179,7 @@ declare namespace Arr {
      * Arr.last([]); // None
      * ```
      */
-    const last: <A>(data: readonly A[]) => Maybe<A>;
+    export const last: <A>(data: readonly A[]) => Maybe<A>;
     /**
      * Returns all elements except the first, or None if the array is empty.
      *
@@ -210,7 +189,7 @@ declare namespace Arr {
      * Arr.tail([]); // None
      * ```
      */
-    const tail: <A>(data: readonly A[]) => Maybe<readonly A[]>;
+    export const tail: <A>(data: readonly A[]) => Maybe<readonly A[]>;
     /**
      * Returns all elements except the last, or None if the array is empty.
      *
@@ -220,7 +199,7 @@ declare namespace Arr {
      * Arr.init([]); // None
      * ```
      */
-    const init: <A>(data: readonly A[]) => Maybe<readonly A[]>;
+    export const init: <A>(data: readonly A[]) => Maybe<readonly A[]>;
     /**
      * Returns the first element matching the predicate, or None.
      *
@@ -229,7 +208,7 @@ declare namespace Arr {
      * pipe([1, 2, 3, 4], Arr.findFirst(n => n > 2)); // Some(3)
      * ```
      */
-    const findFirst: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<A>;
+    export const findFirst: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<A>;
     /**
      * Returns the last element matching the predicate, or None.
      *
@@ -238,7 +217,7 @@ declare namespace Arr {
      * pipe([1, 2, 3, 4], Arr.findLast(n => n > 2)); // Some(4)
      * ```
      */
-    const findLast: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<A>;
+    export const findLast: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<A>;
     /**
      * Returns the index of the first element matching the predicate, or None.
      *
@@ -247,7 +226,7 @@ declare namespace Arr {
      * pipe([1, 2, 3, 4], Arr.findIndex(n => n > 2)); // Some(2)
      * ```
      */
-    const findIndex: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<number>;
+    export const findIndex: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<number>;
     /**
      * Transforms each element of an array.
      *
@@ -256,10 +235,7 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.map(n => n * 2)); // [2, 4, 6]
      * ```
      */
-    const map: <A, B>(f: (a: A) => B) => {
-        (data: NonEmpty<A>): NonEmpty<B>;
-        (data: readonly A[]): readonly B[];
-    };
+    export const map: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly B[];
     /**
      * Transforms each element using both its value and its zero-based index.
      *
@@ -271,10 +247,7 @@ declare namespace Arr {
      * ); // [{ position: 1, value: "a" }, { position: 2, value: "b" }, { position: 3, value: "c" }]
      * ```
      */
-    const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => {
-        (data: NonEmpty<A>): NonEmpty<B>;
-        (data: readonly A[]): readonly B[];
-    };
+    export const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: readonly A[]) => readonly B[];
     /**
      * Filters elements that satisfy the predicate.
      *
@@ -283,7 +256,7 @@ declare namespace Arr {
      * pipe([1, 2, 3, 4], Arr.filter(n => n % 2 === 0)); // [2, 4]
      * ```
      */
-    const filter: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    export const filter: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
     /**
      * Maps each element to a Maybe and collects only the Some values.
      * Combines map and filter in a single pass.
@@ -292,13 +265,13 @@ declare namespace Arr {
      * ```ts
      * const parseNum = (s: string): Maybe<number> => {
      *   const n = Number(s);
-     *   return isNaN(n) ? Maybe.none() : Maybe.some(n);
+     *   return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
      * };
      *
      * pipe(["1", "abc", "3"], Arr.filterMap(parseNum)); // [1, 3]
      * ```
      */
-    const filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => readonly B[];
+    export const filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => readonly B[];
     /**
      * Splits an array into two groups based on a predicate.
      * First group contains elements that satisfy the predicate,
@@ -309,27 +282,27 @@ declare namespace Arr {
      * pipe([1, 2, 3, 4], Arr.partition(n => n % 2 === 0)); // [[2, 4], [1, 3]]
      * ```
      */
-    const partition: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly [readonly A[], readonly A[]];
+    export const partition: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly [readonly A[], readonly A[]];
     /**
      * Narrows a list of Maybe values down to a list of their underlying values,
      * discarding all None instances.
      *
      * @example
      * ```ts
-     * Arr.compact([Maybe.some(1), Maybe.none(), Maybe.some(3)]); // [1, 3]
+     * Arr.compact([Maybe.make.some(1), Maybe.make.none(), Maybe.make.some(3)]); // [1, 3]
      * ```
      */
-    const compact: <A>(data: readonly Maybe<A>[]) => readonly A[];
+    export const compact: <A>(data: readonly Maybe<A>[]) => readonly A[];
     /**
      * Separates an array of Result values into two separate lists of errors and successes.
      * Returns a tuple containing `[errors, successes]`.
      *
      * @example
      * ```ts
-     * Arr.separate([Result.ok(1), Result.err("bad"), Result.ok(3)]); // [["bad"], [1, 3]]
+     * Arr.separate([Result.make.ok(1), Result.make.err("bad"), Result.make.ok(3)]); // [["bad"], [1, 3]]
      * ```
      */
-    const separate: <E, A>(data: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
+    export const separate: <E, A>(data: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
     /**
      * Maps each element to a Result, and separates the results into a tuple of failures and successes.
      *
@@ -337,11 +310,11 @@ declare namespace Arr {
      * ```ts
      * pipe(
      *   [1, 2, 3, 4],
-     *   Arr.partitionMap(n => n % 2 === 0 ? Result.ok(n) : Result.err(`odd: ${n}`))
+     *   Arr.partitionMap(n => n % 2 === 0 ? Result.make.ok(n) : Result.make.err(`odd: ${n}`))
      * ); // [["odd: 1", "odd: 3"], [2, 4]]
      * ```
      */
-    const partitionMap: <A, E, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => readonly [readonly E[], readonly B[]];
+    export const partitionMap: <A, E, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => readonly [readonly E[], readonly B[]];
     /**
      * Groups elements by a key function.
      *
@@ -353,7 +326,7 @@ declare namespace Arr {
      * ); // { a: ["apple", "avocado"], b: ["banana"] }
      * ```
      */
-    const groupBy: <A>(f: (a: A) => string) => (data: readonly A[]) => Record<string, NonEmptyArr<A>>;
+    export const groupBy: <A>(f: (a: A) => string) => (data: readonly A[]) => Record<string, NonEmptyArr<A>>;
     /**
      * Removes duplicate elements using strict equality.
      *
@@ -362,7 +335,7 @@ declare namespace Arr {
      * Arr.uniq([1, 2, 2, 3, 1]); // [1, 2, 3]
      * ```
      */
-    const uniq: <A>(data: readonly A[]) => readonly A[];
+    export const uniq: <A>(data: readonly A[]) => readonly A[];
     /**
      * Removes duplicate elements by comparing the result of a key function.
      *
@@ -374,7 +347,7 @@ declare namespace Arr {
      * ); // [{id: 1, name: "a"}, {id: 2, name: "c"}]
      * ```
      */
-    const uniqBy: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly A[];
+    export const uniqBy: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly A[];
     /**
      * Removes duplicate elements using a custom equality check.
      * Preserves the order of first occurrences. Complements `uniq` (reference equality)
@@ -391,7 +364,7 @@ declare namespace Arr {
      * ); // [{ x: 1, y: 1 }, { x: 2, y: 2 }]
      * ```
      */
-    const uniqWith: <A>(eq: Equality<A>) => (data: readonly A[]) => readonly A[];
+    export const uniqWith: <A>(eq: Equality<A>) => (data: readonly A[]) => readonly A[];
     /**
      * Sorts an array using a comparison function. Returns a new array.
      * To sort with a typed `Ordering<A>`, prefer `Arr.sortWith`.
@@ -401,7 +374,7 @@ declare namespace Arr {
      * pipe([3, 1, 2], Arr.sortBy((a, b) => a - b)); // [1, 2, 3]
      * ```
      */
-    const sortBy: <A>(compare: (a: A, b: A) => number) => (data: readonly A[]) => readonly A[];
+    export const sortBy: <A>(compare: (a: A, b: A) => number) => (data: readonly A[]) => readonly A[];
     /**
      * Sorts an array using an `Ordering<A>`. Returns a new array without mutating the original.
      * Use this over `sortBy` when you have a typed `Ordering<A>` from the `Ordering` module.
@@ -414,7 +387,7 @@ declare namespace Arr {
      * pipe(products, Arr.sortWith(byPrice));
      * ```
      */
-    const sortWith: <A>(ord: Ordering<A>) => (data: readonly A[]) => readonly A[];
+    export const sortWith: <A>(ord: Ordering<A>) => (data: readonly A[]) => readonly A[];
     /**
      * Pairs up elements from two arrays. Stops at the shorter array.
      *
@@ -423,7 +396,7 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.zip(["a", "b"])); // [[1, "a"], [2, "b"]]
      * ```
      */
-    const zip: <B>(other: readonly B[]) => <A>(data: readonly A[]) => readonly (readonly [A, B])[];
+    export const zip: <B>(other: readonly B[]) => <A>(data: readonly A[]) => readonly (readonly [A, B])[];
     /**
      * Combines elements from two arrays using a function. Stops at the shorter array.
      *
@@ -432,7 +405,7 @@ declare namespace Arr {
      * pipe([1, 2], Arr.zipWith((a, b) => a + b, ["a", "b"])); // ["1a", "2b"]
      * ```
      */
-    const zipWith: <A, B, C>(f: (a: A, b: B) => C) => (other: readonly B[]) => (data: readonly A[]) => readonly C[];
+    export const zipWith: <A, B, C>(f: (a: A, b: B) => C) => (other: readonly B[]) => (data: readonly A[]) => readonly C[];
     /**
      * Inserts a separator between every element.
      *
@@ -441,23 +414,16 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.intersperse(0)); // [1, 0, 2, 0, 3]
      * ```
      */
-    const intersperse: <A>(sep: A) => {
-        (data: NonEmpty<A>): NonEmpty<A>;
-        (data: readonly A[]): readonly A[];
-    };
+    export const intersperse: <A>(sep: A) => (data: readonly A[]) => readonly A[];
     /**
-     * Concatenates a standard array or NonEmptyArr with another array.
-     * If the first array is a NonEmptyArr, the result is guaranteed to be a NonEmptyArr.
+     * Concatenates a standard array with another array.
      *
      * @example
      * ```ts
      * pipe([1, 2], Arr.concat([3, 4])); // [1, 2, 3, 4]
      * ```
      */
-    const concat: <A>(other: readonly A[]) => {
-        (data: NonEmpty<A>): NonEmpty<A>;
-        (data: readonly A[]): readonly A[];
-    };
+    export const concat: <A>(other: readonly A[]) => (data: readonly A[]) => readonly A[];
     /**
      * Splits an array into chunks of the given size.
      *
@@ -466,7 +432,7 @@ declare namespace Arr {
      * pipe([1, 2, 3, 4, 5], Arr.chunksOf(2)); // [[1, 2], [3, 4], [5]]
      * ```
      */
-    const chunksOf: (n: number) => <A>(data: readonly A[]) => readonly (readonly A[])[];
+    export const chunksOf: (n: number) => <A>(data: readonly A[]) => readonly (readonly A[])[];
     /**
      * Flattens a nested array by one level.
      *
@@ -475,7 +441,7 @@ declare namespace Arr {
      * Arr.flatten([[1, 2], [3], [4, 5]]); // [1, 2, 3, 4, 5]
      * ```
      */
-    const flatten: <A>(data: readonly (readonly A[])[]) => readonly A[];
+    export const flatten: <A>(data: readonly (readonly A[])[]) => readonly A[];
     /**
      * Maps each element to an array and flattens the result.
      *
@@ -484,7 +450,7 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.flatMap(n => [n, n * 10])); // [1, 10, 2, 20, 3, 30]
      * ```
      */
-    const flatMap: <A, B>(f: (a: A) => readonly B[]) => (data: readonly A[]) => readonly B[];
+    export const flatMap: <A, B>(f: (a: A) => readonly B[]) => (data: readonly A[]) => readonly B[];
     /**
      * Reduces an array from the left.
      *
@@ -493,14 +459,35 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.reduce(0, (acc, n) => acc + n)); // 6
      * ```
      */
-    const reduce: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => B;
-    const Maybe: typeof ArrMaybe;
-    const Result: typeof ArrResult;
-    const Task: typeof ArrTask;
-    /**
-     * Returns true if the array is non-empty (type guard).
-     */
-    const isNonEmpty: <A>(data: readonly A[]) => data is NonEmpty<A>;
+    export const reduce: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => B;
+    interface TaskTraverse {
+        <A, B>(f: (a: A) => Task<B>): (data: readonly A[]) => Task<readonly B[]>;
+        Result: typeof ArrTaskResult.traverse;
+    }
+    interface TaskSequence {
+        <A>(data: readonly Task<A>[]): Task<readonly A[]>;
+        Result: typeof ArrTaskResult.sequence;
+    }
+    export namespace traverse {
+        const Maybe: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => Maybe<readonly B[]>;
+        const Result: <E, A, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => Result<E, readonly B[]>;
+        const Task: TaskTraverse;
+    }
+    export namespace sequence {
+        const Maybe: <A>(data: readonly Maybe<A>[]) => Maybe<readonly A[]>;
+        const Result: <E, A>(data: readonly Result<E, A>[]) => Result<E, readonly A[]>;
+        const Task: TaskSequence;
+    }
+    export namespace is {
+        /**
+         * Returns true if the array is empty.
+         */
+        const empty: <A>(data: readonly A[]) => data is readonly [];
+        /**
+         * Returns true if the array is non-empty (type guard).
+         */
+        const nonEmpty: <A>(data: readonly A[]) => data is NonEmpty<A>;
+    }
     /**
      * Prepends a value to the beginning of an array, returning a NonEmptyArr.
      *
@@ -509,7 +496,7 @@ declare namespace Arr {
      * pipe([1, 2], Arr.prepend(0)); // [0, 1, 2]
      * ```
      */
-    const prepend: <A>(value: A) => (data: readonly A[]) => NonEmpty<A>;
+    export const prepend: <A>(value: A) => (data: readonly A[]) => NonEmpty<A>;
     /**
      * Appends a value to the end of an array, returning a NonEmptyArr.
      *
@@ -518,11 +505,11 @@ declare namespace Arr {
      * pipe([1, 2], Arr.append(3)); // [1, 2, 3]
      * ```
      */
-    const append: <A>(value: A) => (data: readonly A[]) => NonEmpty<A>;
+    export const append: <A>(value: A) => (data: readonly A[]) => NonEmpty<A>;
     /**
      * Returns the length of an array.
      */
-    const size: <A>(data: readonly A[]) => number;
+    export const size: <A>(data: readonly A[]) => number;
     /**
      * Returns true if any element satisfies the predicate.
      *
@@ -531,7 +518,7 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.some(n => n > 2)); // true
      * ```
      */
-    const some: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
+    export const some: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
     /**
      * Returns true if all elements satisfy the predicate.
      *
@@ -540,7 +527,7 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.every(n => n > 0)); // true
      * ```
      */
-    const every: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
+    export const every: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
     /**
      * Reverses an array. Returns a new array.
      *
@@ -549,10 +536,7 @@ declare namespace Arr {
      * Arr.reverse([1, 2, 3]); // [3, 2, 1]
      * ```
      */
-    const reverse: {
-        <A>(data: NonEmpty<A>): NonEmpty<A>;
-        <A>(data: readonly A[]): readonly A[];
-    };
+    export const reverse: <A>(data: readonly A[]) => readonly A[];
     /**
      * Returns a new array with `item` inserted before the element at `index`.
      * Negative indices are clamped to 0; indices beyond the array length append to the end.
@@ -564,7 +548,7 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.insertAt(3, 99)); // [1, 2, 3, 99]
      * ```
      */
-    const insertAt: <A>(index: number, item: A) => (data: readonly A[]) => readonly A[];
+    export const insertAt: <A>(index: number, item: A) => (data: readonly A[]) => readonly A[];
     /**
      * Returns a new array with the element at `index` removed.
      * Returns the original array unchanged if `index` is out of bounds.
@@ -576,7 +560,7 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.removeAt(5)); // [1, 2, 3]
      * ```
      */
-    const removeAt: (index: number) => <A>(data: readonly A[]) => readonly A[];
+    export const removeAt: (index: number) => <A>(data: readonly A[]) => readonly A[];
     /**
      * Takes the first n elements from an array.
      *
@@ -585,7 +569,7 @@ declare namespace Arr {
      * pipe([1, 2, 3, 4], Arr.take(2)); // [1, 2]
      * ```
      */
-    const take: (n: number) => <A>(data: readonly A[]) => readonly A[];
+    export const take: (n: number) => <A>(data: readonly A[]) => readonly A[];
     /**
      * Drops the first n elements from an array.
      *
@@ -594,7 +578,7 @@ declare namespace Arr {
      * pipe([1, 2, 3, 4], Arr.drop(2)); // [3, 4]
      * ```
      */
-    const drop: (n: number) => <A>(data: readonly A[]) => readonly A[];
+    export const drop: (n: number) => <A>(data: readonly A[]) => readonly A[];
     /**
      * Takes elements from the start while the predicate holds.
      *
@@ -603,7 +587,7 @@ declare namespace Arr {
      * pipe([1, 2, 3, 1], Arr.takeWhile(n => n < 3)); // [1, 2]
      * ```
      */
-    const takeWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    export const takeWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
     /**
      * Drops elements from the start while the predicate holds.
      *
@@ -612,7 +596,7 @@ declare namespace Arr {
      * pipe([1, 2, 3, 1], Arr.dropWhile(n => n < 3)); // [3, 1]
      * ```
      */
-    const dropWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    export const dropWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
     /**
      * Like `reduce`, but returns every intermediate accumulator as an array.
      * The initial value is not included — the output has the same length as the input.
@@ -622,7 +606,7 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.scan(0, (acc, n) => acc + n)); // [1, 3, 6]
      * ```
      */
-    const scan: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => readonly B[];
+    export const scan: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => readonly B[];
     /**
      * Splits an array at an index into a `[before, after]` tuple.
      * Negative indices clamp to 0; indices beyond the array length clamp to the end.
@@ -634,10 +618,15 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.splitAt(10));   // [[1, 2, 3], []]
      * ```
      */
-    const splitAt: (index: number) => <A>(data: readonly A[]) => readonly [readonly A[], readonly A[]];
-    const NonEmpty: typeof ArrNonEmpty;
+    export const splitAt: (index: number) => <A>(data: readonly A[]) => readonly [readonly A[], readonly A[]];
+    export const NonEmpty: typeof ArrNonEmpty;
+    export {  };
 }
 
+/**
+ * A branded type representing a key-value dictionary with at least one entry.
+ */
+type NonEmptyMap<K, V> = Brand<NonEmpty<"Dict">, ReadonlyMap<K, V>>;
 /**
  * Functional utilities for key-value dictionaries (`ReadonlyMap<K, V>`). All functions are pure
  * and data-last — they compose naturally with `pipe`.
@@ -651,50 +640,150 @@ declare namespace Arr {
  * import { pipe } from "@nlozgachev/pipelined/composition";
  *
  * const scores = pipe(
- *   Dict.fromEntries([["alice", 10], ["bob", 8], ["carol", 10]] as const),
+ *   Dict.from.entries([["alice", 10], ["bob", 8], ["carol", 10]] as const),
  *   Dict.filter(n => n >= 10),
  *   Dict.map(n => `${n} points`),
  * );
  * // ReadonlyMap { "alice" => "10 points", "carol" => "10 points" }
  * ```
  */
-declare namespace Dict {
+declare namespace DictNonEmpty {
     /**
-     * Creates an empty dictionary.
+     * Creates a NonEmptyMap containing a single key-value entry.
      *
      * @example
      * ```ts
-     * Dict.empty<string, number>(); // ReadonlyMap {}
+     * Dict.NonEmpty.singleton("name", "Alice"); // ReadonlyMap { "name" => "Alice" }
      * ```
      */
-    const empty: <K, V>() => ReadonlyMap<K, V>;
+    const singleton: <K, V>(key: K, value: V) => NonEmptyMap<K, V>;
+    namespace from {
+        /**
+         * Returns Some containing NonEmptyMap if the map is not empty, None otherwise.
+         *
+         * @example
+         * ```ts
+         * Dict.NonEmpty.from.Map(Dict.from.entries([["a", 1]])); // Some(ReadonlyMap { "a" => 1 })
+         * Dict.NonEmpty.from.Map(Dict.empty());                 // None
+         * ```
+         */
+        const Map: <K, V>(m: ReadonlyMap<K, V>) => Maybe<NonEmptyMap<K, V>>;
+    }
     /**
-     * Creates a dictionary with a single entry.
+     * Returns a non-empty array of keys, in insertion order.
      *
      * @example
      * ```ts
-     * Dict.singleton("name", "Alice"); // ReadonlyMap { "name" => "Alice" }
+     * Dict.NonEmpty.keys(Dict.NonEmpty.singleton("a", 1)); // ["a"]
      * ```
      */
-    const singleton: <K, V>(key: K, value: V) => ReadonlyMap<K, V>;
+    const keys: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<K>;
+    /**
+     * Returns a non-empty array of values, in insertion order.
+     *
+     * @example
+     * ```ts
+     * Dict.NonEmpty.values(Dict.NonEmpty.singleton("a", 1)); // [1]
+     * ```
+     */
+    const values: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<V>;
+    /**
+     * Returns a non-empty array of entry tuples, in insertion order.
+     *
+     * @example
+     * ```ts
+     * Dict.NonEmpty.entries(Dict.NonEmpty.singleton("a", 1)); // [["a", 1]]
+     * ```
+     */
+    const entries: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<readonly [K, V]>;
+    /**
+     * Reduces a NonEmptyMap's values from the left without an initial seed value.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.reduce((a, b) => a + b)); // 1
+     * ```
+     */
+    const reduce: <V>(f: (acc: V, value: V) => V) => <K>(m: NonEmptyMap<K, V>) => V;
+    /**
+     * Transforms each value in the non-empty dictionary.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.map(n => n * 2));
+     * // ReadonlyMap { "a" => 2 }
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => <K>(m: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
+    /**
+     * Transforms each value in the non-empty dictionary, also receiving the key.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.mapWithKey((k, v) => `${k}:${v}`));
+     * // ReadonlyMap { "a" => "a:1" }
+     * ```
+     */
+    const mapWithKey: <K, A, B>(f: (key: K, a: A) => B) => (m: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
+}
+declare namespace Dict {
+    /**
+     * A branded type representing a key-value dictionary with at least one entry.
+     */
+    type NonEmpty<K, V> = NonEmptyMap<K, V>;
+    namespace is {
+        /**
+         * Returns `true` if the dictionary has no entries.
+         *
+         * @example
+         * ```ts
+         * Dict.is.empty(Dict.empty()); // true
+         * ```
+         */
+        const empty: <K, V>(m: ReadonlyMap<K, V>) => boolean;
+        /**
+         * Type guard to check if a dictionary is non-empty.
+         */
+        const nonEmpty: <K, V>(m: ReadonlyMap<K, V>) => m is NonEmpty<K, V>;
+    }
     /**
-     * Creates a dictionary from an array of key-value pairs.
+     * Creates an empty dictionary.
      *
      * @example
      * ```ts
-     * Dict.fromEntries([["a", 1], ["b", 2]]); // ReadonlyMap { "a" => 1, "b" => 2 }
+     * Dict.empty<string, number>(); // ReadonlyMap {}
      * ```
      */
-    const fromEntries: <K, V>(entries: readonly (readonly [K, V])[]) => ReadonlyMap<K, V>;
+    const empty: <K, V>() => ReadonlyMap<K, V>;
     /**
-     * Creates a dictionary from a plain object. Keys are always strings.
+     * Creates a dictionary with a single entry.
      *
      * @example
      * ```ts
-     * Dict.fromRecord({ a: 1, b: 2 }); // ReadonlyMap { "a" => 1, "b" => 2 }
+     * Dict.singleton("name", "Alice"); // ReadonlyMap { "name" => "Alice" }
      * ```
      */
-    const fromRecord: <V>(rec: Readonly<Record<string, V>>) => ReadonlyMap<string, V>;
+    const singleton: <K, V>(key: K, value: V) => ReadonlyMap<K, V>;
+    namespace from {
+        /**
+         * Creates a dictionary from an array of key-value pairs.
+         *
+         * @example
+         * ```ts
+         * Dict.from.entries([["a", 1], ["b", 2]]); // ReadonlyMap { "a" => 1, "b" => 2 }
+         * ```
+         */
+        const entries: <K, V>(entries: readonly (readonly [K, V])[]) => ReadonlyMap<K, V>;
+        /**
+         * Creates a dictionary from a plain object. Keys are always strings.
+         *
+         * @example
+         * ```ts
+         * Dict.from.Record({ a: 1, b: 2 }); // ReadonlyMap { "a" => 1, "b" => 2 }
+         * ```
+         */
+        const Record: <V>(rec: Readonly<Record<string, V>>) => ReadonlyMap<string, V>;
+    }
     /**
      * Groups elements of an array into a dictionary keyed by the result of `keyFn`. Each key maps
      * to the array of elements that produced it, in insertion order. Uses the native `Map.groupBy`
@@ -715,8 +804,8 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1]]), Dict.has("a")); // true
-     * pipe(Dict.fromEntries([["a", 1]]), Dict.has("b")); // false
+     * pipe(Dict.from.Entries([["a", 1]]), Dict.has("a")); // true
+     * pipe(Dict.from.Entries([["a", 1]]), Dict.has("b")); // false
      * ```
      */
     const has: <K>(key: K) => <V>(m: ReadonlyMap<K, V>) => boolean;
@@ -725,8 +814,8 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1]]), Dict.lookup("a")); // Some(1)
-     * pipe(Dict.fromEntries([["a", 1]]), Dict.lookup("b")); // None
+     * pipe(Dict.from.Entries([["a", 1]]), Dict.lookup("a")); // Some(1)
+     * pipe(Dict.from.Entries([["a", 1]]), Dict.lookup("b")); // None
      * ```
      */
     const lookup: <K>(key: K) => <V>(m: ReadonlyMap<K, V>) => Maybe<V>;
@@ -735,25 +824,16 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * Dict.size(Dict.fromEntries([["a", 1], ["b", 2]])); // 2
+     * Dict.size(Dict.from.Entries([["a", 1], ["b", 2]])); // 2
      * ```
      */
     const size: <K, V>(m: ReadonlyMap<K, V>) => number;
-    /**
-     * Returns `true` if the dictionary has no entries.
-     *
-     * @example
-     * ```ts
-     * Dict.isEmpty(Dict.empty()); // true
-     * ```
-     */
-    const isEmpty: <K, V>(m: ReadonlyMap<K, V>) => boolean;
     /**
      * Returns all keys as a readonly array, in insertion order.
      *
      * @example
      * ```ts
-     * Dict.keys(Dict.fromEntries([["a", 1], ["b", 2]])); // ["a", "b"]
+     * Dict.keys(Dict.from.Entries([["a", 1], ["b", 2]])); // ["a", "b"]
      * ```
      */
     const keys: <K, V>(m: ReadonlyMap<K, V>) => readonly K[];
@@ -762,7 +842,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * Dict.values(Dict.fromEntries([["a", 1], ["b", 2]])); // [1, 2]
+     * Dict.values(Dict.from.Entries([["a", 1], ["b", 2]])); // [1, 2]
      * ```
      */
     const values: <K, V>(m: ReadonlyMap<K, V>) => readonly V[];
@@ -771,7 +851,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * Dict.entries(Dict.fromEntries([["a", 1], ["b", 2]])); // [["a", 1], ["b", 2]]
+     * Dict.entries(Dict.from.Entries([["a", 1], ["b", 2]])); // [["a", 1], ["b", 2]]
      * ```
      */
     const entries: <K, V>(m: ReadonlyMap<K, V>) => readonly (readonly [K, V])[];
@@ -781,7 +861,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1]]), Dict.insert("b", 2));
+     * pipe(Dict.from.Entries([["a", 1]]), Dict.insert("b", 2));
      * // ReadonlyMap { "a" => 1, "b" => 2 }
      * ```
      */
@@ -792,7 +872,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.remove("a"));
+     * pipe(Dict.from.Entries([["a", 1], ["b", 2]]), Dict.remove("a"));
      * // ReadonlyMap { "b" => 2 }
      * ```
      */
@@ -808,8 +888,8 @@ declare namespace Dict {
      * import { Maybe } from "@nlozgachev/pipelined/core";
      *
      * const increment = (opt: Maybe<number>) => Maybe.getOrElse(() => 0)(opt) + 1;
-     * pipe(Dict.fromEntries([["views", 5]]), Dict.upsert("views", increment)); // { views: 6 }
-     * pipe(Dict.fromEntries([["views", 5]]), Dict.upsert("likes", increment)); // { views: 5, likes: 1 }
+     * pipe(Dict.from.Entries([["views", 5]]), Dict.upsert("views", increment)); // { views: 6 }
+     * pipe(Dict.from.Entries([["views", 5]]), Dict.upsert("likes", increment)); // { views: 5, likes: 1 }
      * ```
      */
     const upsert: <K, V>(key: K, f: (existing: Maybe<V>) => V) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
@@ -818,7 +898,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.map(n => n * 2));
+     * pipe(Dict.from.Entries([["a", 1], ["b", 2]]), Dict.map(n => n * 2));
      * // ReadonlyMap { "a" => 2, "b" => 4 }
      * ```
      */
@@ -828,7 +908,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.mapWithKey((k, v) => `${k}:${v}`));
+     * pipe(Dict.from.Entries([["a", 1], ["b", 2]]), Dict.mapWithKey((k, v) => `${k}:${v}`));
      * // ReadonlyMap { "a" => "a:1", "b" => "b:2" }
      * ```
      */
@@ -838,7 +918,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1], ["b", 3], ["c", 0]]), Dict.filter(n => n > 0));
+     * pipe(Dict.from.Entries([["a", 1], ["b", 3], ["c", 0]]), Dict.filter(n => n > 0));
      * // ReadonlyMap { "a" => 1, "b" => 3 }
      * ```
      */
@@ -849,7 +929,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.filterWithKey((k, v) => k !== "a" && v > 0));
+     * pipe(Dict.from.Entries([["a", 1], ["b", 2]]), Dict.filterWithKey((k, v) => k !== "a" && v > 0));
      * // ReadonlyMap { "b" => 2 }
      * ```
      */
@@ -862,10 +942,10 @@ declare namespace Dict {
      * ```ts
      * import { Maybe } from "@nlozgachev/pipelined/core";
      *
-     * Dict.compact(Dict.fromEntries([
-     *   ["a", Maybe.some(1)],
-     *   ["b", Maybe.none()],
-     *   ["c", Maybe.some(3)],
+     * Dict.compact(Dict.from.Entries([
+     *   ["a", Maybe.make.some(1)],
+     *   ["b", Maybe.make.none()],
+     *   ["c", Maybe.make.some(3)],
      * ]));
      * // ReadonlyMap { "a" => 1, "c" => 3 }
      * ```
@@ -879,9 +959,9 @@ declare namespace Dict {
      * ```ts
      * const parse = (s: string): Maybe<number> => {
      *     const n = Number(s);
-     *     return isNaN(n) ? Maybe.none() : Maybe.some(n);
+     *     return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
      * };
-     * Dict.filterMap(parse)(Dict.fromRecord({ a: "1", b: "two", c: "3" }));
+     * Dict.filterMap(parse)(Dict.from.Record({ a: "1", b: "two", c: "3" }));
      * // ReadonlyMap { "a" => 1, "c" => 3 }
      * ```
      */
@@ -893,8 +973,8 @@ declare namespace Dict {
      * @example
      * ```ts
      * pipe(
-     *   Dict.fromEntries([["a", 1], ["b", 2]]),
-     *   Dict.union(Dict.fromEntries([["b", 3], ["c", 4]])),
+     *   Dict.from.Entries([["a", 1], ["b", 2]]),
+     *   Dict.union(Dict.from.Entries([["b", 3], ["c", 4]])),
      * );
      * // ReadonlyMap { "a" => 1, "b" => 3, "c" => 4 }
      * ```
@@ -907,8 +987,8 @@ declare namespace Dict {
      * @example
      * ```ts
      * pipe(
-     *   Dict.fromEntries([["a", 1], ["b", 2], ["c", 3]]),
-     *   Dict.intersection(Dict.fromEntries([["b", 99], ["c", 0]])),
+     *   Dict.from.Entries([["a", 1], ["b", 2], ["c", 3]]),
+     *   Dict.intersection(Dict.from.Entries([["b", 99], ["c", 0]])),
      * );
      * // ReadonlyMap { "b" => 2, "c" => 3 }
      * ```
@@ -920,8 +1000,8 @@ declare namespace Dict {
      * @example
      * ```ts
      * pipe(
-     *   Dict.fromEntries([["a", 1], ["b", 2], ["c", 3]]),
-     *   Dict.difference(Dict.fromEntries([["b", 0]])),
+     *   Dict.from.Entries([["a", 1], ["b", 2], ["c", 3]]),
+     *   Dict.difference(Dict.from.Entries([["b", 0]])),
      * );
      * // ReadonlyMap { "a" => 1, "c" => 3 }
      * ```
@@ -934,7 +1014,7 @@ declare namespace Dict {
      * @example
      * ```ts
      * Dict.reduce(0, (acc, value) => acc + value)(
-     *   Dict.fromEntries([["a", 1], ["b", 2], ["c", 3]])
+     *   Dict.from.Entries([["a", 1], ["b", 2], ["c", 3]])
      * ); // 6
      * ```
      */
@@ -946,20 +1026,23 @@ declare namespace Dict {
      * @example
      * ```ts
      * Dict.reduceWithKey("", (acc, value, key) => acc + key + ":" + value + " ")(
-     *   Dict.fromEntries([["a", 1], ["b", 2]])
+     *   Dict.from.Entries([["a", 1], ["b", 2]])
      * ); // "a:1 b:2 "
      * ```
      */
     const reduceWithKey: <K, A, B>(init: B, f: (acc: B, value: A, key: K) => B) => (m: ReadonlyMap<K, A>) => B;
-    /**
-     * Converts a `ReadonlyMap<string, V>` to a plain object. Only meaningful when keys are strings.
-     *
-     * @example
-     * ```ts
-     * Dict.toRecord(Dict.fromEntries([["a", 1], ["b", 2]])); // { a: 1, b: 2 }
-     * ```
-     */
-    const toRecord: <V>(m: ReadonlyMap<string, V>) => Readonly<Record<string, V>>;
+    namespace to {
+        /**
+         * Converts a `ReadonlyMap<string, V>` to a plain object. Only meaningful when keys are strings.
+         *
+         * @example
+         * ```ts
+         * Dict.to.Record(Dict.from.Entries([["a", 1], ["b", 2]])); // { a: 1, b: 2 }
+         * ```
+         */
+        const Record: <V>(m: ReadonlyMap<string, V>) => Readonly<Record<string, V>>;
+    }
+    const NonEmpty: typeof DictNonEmpty;
 }
 
 /**
@@ -1185,121 +1268,86 @@ declare namespace Num {
     const max: (ns: readonly number[]) => Maybe<number>;
 }
 
-declare const _nonEmptyRecord: unique symbol;
 /**
  * A branded type representing a record with at least one key-value pair.
  */
-type NonEmptyRecord<A> = Readonly<Record<string, A>> & {
-    readonly [_nonEmptyRecord]: true;
-};
-declare namespace RecMaybe {
-    /**
-     * Map a function that returns a `Maybe` over each value of a record,
-     * and combine the results into a single `Maybe` containing the updated record.
-     * If any value results in `None`, the entire operation returns `None` (short-circuits).
-     *
-     * @example
-     * ```ts
-     * const parseNum = (s: string) => s === "NaN" ? Maybe.none() : Maybe.some(Number(s));
-     * pipe({ a: "1", b: "2" }, Rec.Maybe.traverse(parseNum)); // Some({ a: 1, b: 2 })
-     * pipe({ a: "1", b: "NaN" }, Rec.Maybe.traverse(parseNum)); // None
-     * ```
-     */
-    const traverse: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Maybe<Readonly<Record<string, B>>>;
-    /**
-     * Sequence a record of `Maybe` values into a `Maybe` of a record.
-     * If any key contains `None`, the entire operation returns `None`.
-     *
-     * @example
-     * ```ts
-     * Rec.Maybe.sequence({ a: Maybe.some(1), b: Maybe.some(2) }); // Some({ a: 1, b: 2 })
-     * Rec.Maybe.sequence({ a: Maybe.some(1), b: Maybe.none() }); // None
-     * ```
-     */
-    const sequence: <A>(data: Readonly<Record<string, Maybe<A>>>) => Maybe<Readonly<Record<string, A>>>;
-}
-declare namespace RecResult {
-    /**
-     * Map a function that returns a `Result` over each value of a record,
-     * and combine the results into a single `Result` containing the updated record.
-     * If any value results in an `Err`, the entire operation returns that `Err` (short-circuits).
-     *
-     * @example
-     * ```ts
-     * const checkPositive = (n: number) => n < 0 ? Result.err("negative") : Result.ok(n);
-     * pipe({ a: 1, b: 2 }, Rec.Result.traverse(checkPositive)); // Ok({ a: 1, b: 2 })
-     * pipe({ a: 1, b: -2 }, Rec.Result.traverse(checkPositive)); // Err("negative")
-     * ```
-     */
-    const traverse: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Readonly<Record<string, A>>) => Result<E, Readonly<Record<string, B>>>;
+type NonEmptyRecord<A, K extends string = string> = Brand<NonEmpty<"Rec">, Readonly<Record<K, A>>>;
+declare namespace RecNonEmpty {
     /**
-     * Sequence a record of `Result` values into a `Result` of a record.
-     * If any key contains an `Err`, the entire operation returns that `Err`.
+     * Creates a NonEmpty record from a single key-value pair.
      *
      * @example
      * ```ts
-     * Rec.Result.sequence({ a: Result.ok(1), b: Result.ok(2) }); // Ok({ a: 1, b: 2 })
-     * Rec.Result.sequence({ a: Result.ok(1), b: Result.err("oops") }); // Err("oops")
+     * Rec.NonEmpty.singleton("a", 1); // { a: 1 }
      * ```
      */
-    const sequence: <E, A>(data: Readonly<Record<string, Result<E, A>>>) => Result<E, Readonly<Record<string, A>>>;
-}
-declare namespace RecNonEmpty {
+    const singleton: <K extends string, A>(key: K, value: A) => NonEmptyRecord<A, K>;
+    namespace from {
+        /**
+         * Creates a NonEmpty record from a standard record if it is not empty.
+         *
+         * @example
+         * ```ts
+         * Rec.NonEmpty.from.Record({ a: 1 }); // Some({ a: 1 })
+         * Rec.NonEmpty.from.Record({});      // None
+         * ```
+         */
+        const Record: <K extends string, A>(data: Readonly<Record<K, A>>) => Maybe<NonEmptyRecord<A, K>>;
+    }
     /**
-     * Creates a NonEmpty record from a single key-value pair.
+     * Returns a non-empty array of keys for a NonEmpty record.
      *
      * @example
      * ```ts
-     * Rec.NonEmpty.singleton("a", 1); // { a: 1 }
+     * Rec.NonEmpty.keys(Rec.NonEmpty.singleton("a", 1)); // ["a"]
      * ```
      */
-    const singleton: <A>(key: string, value: A) => NonEmptyRecord<A>;
+    const keys: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<K>;
     /**
-     * Creates a NonEmpty record from a standard record if it is not empty.
+     * Returns a non-empty array of values for a NonEmpty record.
      *
      * @example
      * ```ts
-     * Rec.NonEmpty.fromRecord({ a: 1 }); // Some({ a: 1 })
-     * Rec.NonEmpty.fromRecord({});      // None
+     * Rec.NonEmpty.values(Rec.NonEmpty.singleton("a", 1)); // [1]
      * ```
      */
-    const fromRecord: <A>(data: Readonly<Record<string, A>>) => Maybe<NonEmptyRecord<A>>;
+    const values: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<A>;
     /**
-     * Returns a non-empty array of keys for a NonEmpty record.
+     * Returns a non-empty array of entry tuples for a NonEmpty record.
      *
      * @example
      * ```ts
-     * Rec.NonEmpty.keys(Rec.NonEmpty.singleton("a", 1)); // ["a"]
+     * Rec.NonEmpty.entries(Rec.NonEmpty.singleton("a", 1)); // [["a", 1]]
      * ```
      */
-    const keys: <A>(data: NonEmptyRecord<A>) => NonEmptyArr<string>;
+    const entries: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<readonly [K, A]>;
     /**
-     * Returns a non-empty array of values for a NonEmpty record.
+     * Reduces a NonEmpty record's values from the left without an initial value.
      *
      * @example
      * ```ts
-     * Rec.NonEmpty.values(Rec.NonEmpty.singleton("a", 1)); // [1]
+     * pipe(Rec.NonEmpty.singleton("a", 1), Rec.NonEmpty.reduce((a, b) => a + b)); // 1
      * ```
      */
-    const values: <A>(data: NonEmptyRecord<A>) => NonEmptyArr<A>;
+    const reduce: <A>(f: (acc: A, a: A) => A) => <K extends string>(data: NonEmptyRecord<A, K>) => A;
     /**
-     * Returns a non-empty array of entry tuples for a NonEmpty record.
+     * Transforms each value of a NonEmpty record.
      *
      * @example
      * ```ts
-     * Rec.NonEmpty.entries(Rec.NonEmpty.singleton("a", 1)); // [["a", 1]]
+     * pipe(Rec.NonEmpty.singleton("a", 1), Rec.NonEmpty.map(n => n * 2)); // { a: 2 }
      * ```
      */
-    const entries: <A>(data: NonEmptyRecord<A>) => NonEmptyArr<readonly [string, A]>;
+    const map: <A, B>(f: (a: A) => B) => <K extends string>(data: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
     /**
-     * Reduces a NonEmpty record's values from the left without an initial value.
+     * Transforms each value of a NonEmpty record, also receiving the key.
      *
      * @example
      * ```ts
-     * pipe(Rec.NonEmpty.singleton("a", 1), Rec.NonEmpty.reduce((a, b) => a + b)); // 1
+     * pipe(Rec.NonEmpty.singleton("a", 1), Rec.NonEmpty.mapWithKey((k, v) => `${k}:${v}`)); // { a: "a:1" }
      * ```
      */
-    const reduce: <A>(f: (acc: A, a: A) => A) => (data: NonEmptyRecord<A>) => A;
+    const mapWithKey: <A, B>(f: (key: string, a: A) => B) => <K extends string>(data: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
 }
 /**
  * Functional record/object utilities that compose well with pipe.
@@ -1318,11 +1366,17 @@ declare namespace Rec {
     /**
      * A branded type representing a record with at least one key-value pair.
      */
-    type NonEmpty<A> = NonEmptyRecord<A>;
-    /**
-     * Type guard to check if a record is non-empty.
-     */
-    const isNonEmpty: <A>(data: Readonly<Record<string, A>>) => data is NonEmptyRecord<A>;
+    type NonEmpty<A, K extends string = string> = NonEmptyRecord<A, K>;
+    namespace is {
+        /**
+         * Returns true if the record has no keys.
+         */
+        const empty: <A>(data: Readonly<Record<string, A>>) => boolean;
+        /**
+         * Type guard to check if a record is non-empty.
+         */
+        const nonEmpty: <A, K extends string>(data: Readonly<Record<K, A>>) => data is NonEmptyRecord<A, K>;
+    }
     /**
      * Transforms each value in a record.
      *
@@ -1331,10 +1385,7 @@ declare namespace Rec {
      * pipe({ a: 1, b: 2 }, Rec.map(n => n * 2)); // { a: 2, b: 4 }
      * ```
      */
-    const map: <A, B>(f: (a: A) => B) => {
-        (data: NonEmpty<A>): NonEmpty<B>;
-        (data: Readonly<Record<string, A>>): Readonly<Record<string, B>>;
-    };
+    const map: <A, B>(f: (a: A) => B) => <K extends string>(data: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
     const filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
     /**
      * Transforms each value in a record, also receiving the key.
@@ -1345,10 +1396,7 @@ declare namespace Rec {
      * // { a: "a:1", b: "b:2" }
      * ```
      */
-    const mapWithKey: <A, B>(f: (key: string, a: A) => B) => {
-        (data: NonEmpty<A>): NonEmpty<B>;
-        (data: Readonly<Record<string, A>>): Readonly<Record<string, B>>;
-    };
+    const mapWithKey: <A, B>(f: (key: string, a: A) => B) => <K extends string>(data: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
     /**
      * Filters values in a record by a predicate.
      *
@@ -1390,15 +1438,17 @@ declare namespace Rec {
      * Returns all key-value pairs of a record.
      */
     const entries: <T extends Record<string, unknown>>(data: T) => readonly (readonly [keyof T, T[keyof T]])[];
-    /**
-     * Creates a record from key-value pairs.
-     *
-     * @example
-     * ```ts
-     * Rec.fromEntries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
-     * ```
-     */
-    const fromEntries: <A>(data: readonly (readonly [string, A])[]) => Readonly<Record<string, A>>;
+    namespace from {
+        /**
+         * Creates a record from key-value pairs.
+         *
+         * @example
+         * ```ts
+         * Rec.from.entries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
+         * ```
+         */
+        const entries: <A>(data: readonly (readonly [string, A])[]) => Readonly<Record<string, A>>;
+    }
     /**
      * Groups elements of an array into a record keyed by the result of `keyFn`. Each key maps to
      * the array of elements that produced it, in insertion order.
@@ -1442,10 +1492,6 @@ declare namespace Rec {
      * ```
      */
     const merge: <A>(other: Readonly<Record<string, A>>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
-    /**
-     * Returns true if the record has no keys.
-     */
-    const isEmpty: <A>(data: Readonly<Record<string, A>>) => boolean;
     /**
      * Returns the number of keys in a record.
      */
@@ -1467,16 +1513,26 @@ declare namespace Rec {
      *
      * @example
      * ```ts
-     * Rec.compact({ a: Maybe.some(1), b: Maybe.none(), c: Maybe.some(3) });
+     * Rec.compact({ a: Maybe.make.some(1), b: Maybe.make.none(), c: Maybe.make.some(3) });
      * // { a: 1, c: 3 }
      * ```
      */
     const compact: <A>(data: Readonly<Record<string, Maybe<A>>>) => Readonly<Record<string, A>>;
-    const Maybe: typeof RecMaybe;
-    const Result: typeof RecResult;
+    namespace traverse {
+        const Maybe: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Maybe<Readonly<Record<string, B>>>;
+        const Result: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Readonly<Record<string, A>>) => Result<E, Readonly<Record<string, B>>>;
+    }
+    namespace sequence {
+        const Maybe: <A>(data: Readonly<Record<string, Maybe<A>>>) => Maybe<Readonly<Record<string, A>>>;
+        const Result: <E, A>(data: Readonly<Record<string, Result<E, A>>>) => Result<E, Readonly<Record<string, A>>>;
+    }
     const NonEmpty: typeof RecNonEmpty;
 }
 
+/**
+ * A branded type representing a string with at least one character.
+ */
+type NonEmptyString = Brand<NonEmpty<"Str">, string>;
 /**
  * String utilities. All transformation functions are data-last and curried so they
  * compose naturally with `pipe`. Safe parsers return `Maybe` instead of `NaN`.
@@ -1489,7 +1545,41 @@ declare namespace Rec {
  * pipe("  Hello, World!  ", Str.trim, Str.toLowerCase); // "hello, world!"
  * ```
  */
+declare namespace StrNonEmpty {
+    namespace from {
+        /**
+         * Returns Some containing NonEmptyString if the string is not empty, None otherwise.
+         *
+         * @example
+         * ```ts
+         * Str.NonEmpty.from.String("hello"); // Some("hello")
+         * Str.NonEmpty.from.String("");      // None
+         * ```
+         */
+        const String: (s: string) => Maybe<NonEmptyString>;
+    }
+}
 declare namespace Str {
+    /**
+     * A branded type representing a string with at least one character.
+     */
+    type NonEmpty = NonEmptyString;
+    namespace is {
+        /**
+         * Returns `true` when the string is empty.
+         *
+         * @example
+         * ```ts
+         * pipe("", Str.is.empty);   // true
+         * pipe("hi", Str.is.empty); // false
+         * ```
+         */
+        const empty: (s: string) => boolean;
+        /**
+         * Type guard to check if a string is non-empty.
+         */
+        const nonEmpty: (s: string) => s is NonEmpty;
+    }
     /**
      * Splits a string by a separator. Data-last: use in `pipe`.
      *
@@ -1604,16 +1694,6 @@ declare namespace Str {
      * ```
      */
     const words: (s: string) => readonly string[];
-    /**
-     * Returns `true` when the string is empty.
-     *
-     * @example
-     * ```ts
-     * pipe("", Str.isEmpty);   // true
-     * pipe("hi", Str.isEmpty); // false
-     * ```
-     */
-    const isEmpty: (s: string) => boolean;
     /**
      * Returns `true` when the string is empty or contains only whitespace.
      *
@@ -1701,8 +1781,13 @@ declare namespace Str {
      * ```
      */
     const parseJson: (s: string) => Result<SyntaxError, unknown>;
+    const NonEmpty: typeof StrNonEmpty;
 }
 
+/**
+ * A branded type representing a unique collection with at least one element.
+ */
+type NonEmptySet<A> = Brand<NonEmpty<"Uniq">, ReadonlySet<A>>;
 /**
  * Functional utilities for unique-value collections (`ReadonlySet<A>`). All functions are pure
  * and data-last — they compose naturally with `pipe`.
@@ -1715,78 +1800,142 @@ declare namespace Str {
  * import { pipe } from "@nlozgachev/pipelined/composition";
  *
  * const active = pipe(
- *   Uniq.fromArray(["alice", "bob", "alice", "carol"]),
+ *   Uniq.from.Array(["alice", "bob", "alice", "carol"]),
  *   Uniq.remove("bob"),
  *   Uniq.map(name => name.toUpperCase()),
  * );
  * // ReadonlySet { "ALICE", "CAROL" }
  * ```
  */
-declare namespace Uniq {
+declare namespace UniqNonEmpty {
     /**
-     * Creates an empty unique collection.
+     * Creates a single-element unique collection.
      *
      * @example
      * ```ts
-     * Uniq.empty<number>(); // ReadonlySet {}
+     * Uniq.NonEmpty.singleton(42); // ReadonlySet { 42 }
      * ```
      */
-    const empty: <A>() => ReadonlySet<A>;
+    const singleton: <A>(item: A) => NonEmptySet<A>;
+    namespace from {
+        /**
+         * Returns Some containing NonEmptySet if the set is not empty, None otherwise.
+         *
+         * @example
+         * ```ts
+         * Uniq.NonEmpty.from.Set(Uniq.from.Array([1, 2])); // Some(ReadonlySet { 1, 2 })
+         * Uniq.NonEmpty.from.Set(Uniq.empty());           // None
+         * ```
+         */
+        const Set: <A>(s: ReadonlySet<A>) => Maybe<NonEmptySet<A>>;
+    }
     /**
-     * Creates a unique collection containing a single item.
+     * Folds the collection into a single value without an initial seed value.
      *
      * @example
      * ```ts
-     * Uniq.singleton(42); // ReadonlySet { 42 }
+     * pipe(Uniq.NonEmpty.singleton(42), Uniq.NonEmpty.reduce((a, b) => a + b)); // 42
      * ```
      */
-    const singleton: <A>(item: A) => ReadonlySet<A>;
+    const reduce: <A>(f: (acc: A, a: A) => A) => (s: NonEmptySet<A>) => A;
     /**
-     * Creates a unique collection from an array, automatically discarding duplicates.
+     * Transforms each item in the non-empty unique collection.
      *
      * @example
      * ```ts
-     * Uniq.fromArray([1, 2, 2, 3, 3, 3]); // ReadonlySet { 1, 2, 3 }
-     * Uniq.fromArray([]);                  // ReadonlySet {}
+     * pipe(Uniq.NonEmpty.singleton(1), Uniq.NonEmpty.map(n => n * 2)); // ReadonlySet { 2 }
      * ```
      */
-    const fromArray: <A>(arr: readonly A[]) => ReadonlySet<A>;
+    const map: <A, B>(f: (a: A) => B) => (s: NonEmptySet<A>) => NonEmptySet<B>;
+    namespace to {
+        /**
+         * Converts the collection to a non-empty readonly array in insertion order.
+         *
+         * @example
+         * ```ts
+         * Uniq.NonEmpty.to.Array(Uniq.NonEmpty.singleton(42)); // [42]
+         * ```
+         */
+        const Array: <A>(s: NonEmptySet<A>) => NonEmptyArr<A>;
+    }
+}
+declare namespace Uniq {
     /**
-     * Returns `true` if the collection contains the given item.
+     * A branded type representing a unique collection with at least one element.
+     */
+    type NonEmpty<A> = NonEmptySet<A>;
+    namespace is {
+        /**
+         * Returns `true` if the collection has no items.
+         *
+         * @example
+         * ```ts
+         * Uniq.is.empty(Uniq.empty()); // true
+         * ```
+         */
+        const empty: <A>(s: ReadonlySet<A>) => boolean;
+        /**
+         * Type guard to check if a unique collection is non-empty.
+         */
+        const nonEmpty: <A>(s: ReadonlySet<A>) => s is NonEmpty<A>;
+    }
+    /**
+     * Creates an empty unique collection.
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.has(2)); // true
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.has(4)); // false
+     * Uniq.empty<number>(); // ReadonlySet {}
      * ```
      */
-    const has: <A>(item: A) => (s: ReadonlySet<A>) => boolean;
+    const empty: <A>() => ReadonlySet<A>;
     /**
-     * Returns the number of items in the collection.
+     * Creates a unique collection containing a single item.
      *
      * @example
      * ```ts
-     * Uniq.size(Uniq.fromArray([1, 2, 3])); // 3
+     * Uniq.singleton(42); // ReadonlySet { 42 }
      * ```
      */
-    const size: <A>(s: ReadonlySet<A>) => number;
+    const singleton: <A>(item: A) => ReadonlySet<A>;
+    namespace from {
+        /**
+         * Creates a unique collection from an array, automatically discarding duplicates.
+         *
+         * @example
+         * ```ts
+         * Uniq.from.Array([1, 2, 2, 3, 3, 3]); // ReadonlySet { 1, 2, 3 }
+         * Uniq.from.Array([]);                  // ReadonlySet {}
+         * ```
+         */
+        const Array: <A>(arr: readonly A[]) => ReadonlySet<A>;
+    }
     /**
-     * Returns `true` if the collection has no items.
+     * Returns `true` if the collection contains the given item.
      *
      * @example
      * ```ts
-     * Uniq.isEmpty(Uniq.empty()); // true
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.has(2)); // true
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.has(4)); // false
      * ```
      */
-    const isEmpty: <A>(s: ReadonlySet<A>) => boolean;
+    const has: <A>(item: A) => (s: ReadonlySet<A>) => boolean;
+    /**
+     * Returns the number of items in the collection.
+     *
+     * @example
+     * ```ts
+     * Uniq.size(Uniq.from.Array([1, 2, 3])); // 3
+     * ```
+     */
+    const size: <A>(s: ReadonlySet<A>) => number;
     /**
      * Returns `true` if every item in `set` also exists in `other`.
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2]), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3]))); // true
-     * pipe(Uniq.fromArray([1, 4]), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3]))); // false
-     * pipe(Uniq.empty<number>(), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3])));   // true
+     * pipe(Uniq.from.Array([1, 2]), Uniq.isSubsetOf(Uniq.from.Array([1, 2, 3]))); // true
+     * pipe(Uniq.from.Array([1, 4]), Uniq.isSubsetOf(Uniq.from.Array([1, 2, 3]))); // false
+     * pipe(Uniq.empty<number>(), Uniq.isSubsetOf(Uniq.from.Array([1, 2, 3])));   // true
      * ```
      */
     const isSubsetOf: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => boolean;
@@ -1796,8 +1945,8 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2]), Uniq.insert(3)); // ReadonlySet { 1, 2, 3 }
-     * pipe(Uniq.fromArray([1, 2]), Uniq.insert(2)); // ReadonlySet { 1, 2 } — unchanged
+     * pipe(Uniq.from.Array([1, 2]), Uniq.insert(3)); // ReadonlySet { 1, 2, 3 }
+     * pipe(Uniq.from.Array([1, 2]), Uniq.insert(2)); // ReadonlySet { 1, 2 } — unchanged
      * ```
      */
     const insert: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
@@ -1807,8 +1956,8 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.remove(2)); // ReadonlySet { 1, 3 }
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.remove(4)); // ReadonlySet { 1, 2, 3 } — unchanged
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.remove(2)); // ReadonlySet { 1, 3 }
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.remove(4)); // ReadonlySet { 1, 2, 3 } — unchanged
      * ```
      */
     const remove: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
@@ -1818,7 +1967,7 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3, 4]), Uniq.map(n => n % 3)); // ReadonlySet { 1, 2, 0 }
+     * pipe(Uniq.from.Array([1, 2, 3, 4]), Uniq.map(n => n % 3)); // ReadonlySet { 1, 2, 0 }
      * ```
      */
     const map: <A, B>(f: (a: A) => B) => (s: ReadonlySet<A>) => ReadonlySet<B>;
@@ -1827,7 +1976,7 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3, 4, 5]), Uniq.filter(n => n % 2 === 0));
+     * pipe(Uniq.from.Array([1, 2, 3, 4, 5]), Uniq.filter(n => n % 2 === 0));
      * // ReadonlySet { 2, 4 }
      * ```
      */
@@ -1837,7 +1986,7 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.union(Uniq.fromArray([2, 3, 4])));
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.union(Uniq.from.Array([2, 3, 4])));
      * // ReadonlySet { 1, 2, 3, 4 }
      * ```
      */
@@ -1847,7 +1996,7 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.intersection(Uniq.fromArray([2, 3, 4])));
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.intersection(Uniq.from.Array([2, 3, 4])));
      * // ReadonlySet { 2, 3 }
      * ```
      */
@@ -1857,7 +2006,7 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3, 4]), Uniq.difference(Uniq.fromArray([2, 4])));
+     * pipe(Uniq.from.Array([1, 2, 3, 4]), Uniq.difference(Uniq.from.Array([2, 4])));
      * // ReadonlySet { 1, 3 }
      * ```
      */
@@ -1867,19 +2016,22 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * Uniq.reduce(0, (acc, n) => acc + n)(Uniq.fromArray([1, 2, 3])); // 6
+     * Uniq.reduce(0, (acc, n) => acc + n)(Uniq.from.Array([1, 2, 3])); // 6
      * ```
      */
     const reduce: <A, B>(init: B, f: (acc: B, a: A) => B) => (s: ReadonlySet<A>) => B;
-    /**
-     * Converts the collection to a readonly array in insertion order.
-     *
-     * @example
-     * ```ts
-     * Uniq.toArray(Uniq.fromArray([3, 1, 2])); // [3, 1, 2]
-     * ```
-     */
-    const toArray: <A>(s: ReadonlySet<A>) => readonly A[];
+    namespace to {
+        /**
+         * Converts the collection to a readonly array in insertion order.
+         *
+         * @example
+         * ```ts
+         * Uniq.to.Array(Uniq.from.Array([3, 1, 2])); // [3, 1, 2]
+         * ```
+         */
+        const Array: <A>(s: ReadonlySet<A>) => readonly A[];
+    }
+    const NonEmpty: typeof UniqNonEmpty;
 }
 
-export { Arr, Dict, type NonEmptyRecord, Num, Rec, Str, Uniq };
+export { Arr, Dict, type NonEmptyMap, type NonEmptyRecord, type NonEmptySet, type NonEmptyString, Num, Rec, Str, Uniq };