@nunofyobiz/effect-extras 1.0.0 → 2.1.0

package/dist/index.d.ts

@@ -1,3703 +1,22 @@
-import { Data, Effect, Option, Equivalence, Array, Predicate, Order, DateTime, Duration, Cause, Schema, Result } from 'effect';
-import * as effect_Unify from 'effect/Unify';
-
-/**
- * A value carrying a left `L`, a right `R`, or both at once — the data type for
- * an "inclusive or".
- *
- * Where `Result<R, L>` models an exclusive choice (success _or_ failure),
- * `These` adds the third case where both sides are present. It is a tagged enum
- * with three constructors: `LeftOnly` (only `left`), `RightOnly` (only `right`),
- * and `LeftAndRight` (both). Reach for it when an operation can produce partial
- * results — e.g. a parse that yields a value _and_ a list of warnings.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const both: These.These<number, string> = These.LeftAndRight({
- *   left: 1,
- *   right: "a"
- * })
- *
- * assert.deepStrictEqual(both._tag, "LeftAndRight")
- * ```
- *
- * @category models
- * @since 0.0.0
- */
-type These<L, R> = Data.TaggedEnum<{
-    LeftOnly: {
-        readonly left: L;
-    };
-    RightOnly: {
-        readonly right: R;
-    };
-    LeftAndRight: {
-        readonly left: L;
-        readonly right: R;
-    };
-}>;
-/**
- * The `LeftOnly` member of `These` — a value that carries only a `left` and no
- * `right`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const value: These.LeftOnly<number> = These.LeftOnly({ left: 1 })
- *
- * assert.deepStrictEqual(value.left, 1)
- * ```
- *
- * @category models
- * @since 0.0.0
- */
-type LeftOnly<L> = These<L, never> & {
-    _tag: "LeftOnly";
-};
-/**
- * Constructs a `LeftOnly` — a `These` that carries only a `left`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const value = These.LeftOnly({ left: 1 })
- *
- * assert.deepStrictEqual(value._tag, "LeftOnly")
- * assert.deepStrictEqual(value.left, 1)
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const LeftOnly: <A, B>(args: {
-    readonly left: A;
-}) => {
-    readonly _tag: "LeftOnly";
-    readonly left: A;
-};
-/**
- * The `RightOnly` member of `These` — a value that carries only a `right` and no
- * `left`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const value: These.RightOnly<string> = These.RightOnly({ right: "a" })
- *
- * assert.deepStrictEqual(value.right, "a")
- * ```
- *
- * @category models
- * @since 0.0.0
- */
-type RightOnly<R> = These<never, R> & {
-    _tag: "RightOnly";
-};
-/**
- * Constructs a `RightOnly` — a `These` that carries only a `right`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const value = These.RightOnly({ right: "a" })
- *
- * assert.deepStrictEqual(value._tag, "RightOnly")
- * assert.deepStrictEqual(value.right, "a")
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const RightOnly: <A, B>(args: {
-    readonly right: B;
-}) => {
-    readonly _tag: "RightOnly";
-    readonly right: B;
-};
-/**
- * The `LeftAndRight` member of `These` — a value that carries both a `left` and a
- * `right`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const value: These.LeftAndRight<number, string> = These.LeftAndRight({
- *   left: 1,
- *   right: "a"
- * })
- *
- * assert.deepStrictEqual(value, { _tag: "LeftAndRight", left: 1, right: "a" })
- * ```
- *
- * @category models
- * @since 0.0.0
- */
-type LeftAndRight<L, R> = These<L, R> & {
-    _tag: "LeftAndRight";
-};
-/**
- * Constructs a `LeftAndRight` — a `These` that carries both a `left` and a
- * `right`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const value = These.LeftAndRight({ left: 1, right: "a" })
- *
- * assert.deepStrictEqual(value._tag, "LeftAndRight")
- * assert.deepStrictEqual(value.left, 1)
- * assert.deepStrictEqual(value.right, "a")
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const LeftAndRight: <A, B>(args: {
-    readonly left: A;
-    readonly right: B;
-}) => {
-    readonly _tag: "LeftAndRight";
-    readonly left: A;
-    readonly right: B;
-};
-/**
- * Builds per-tag refinements for `These`. `is("LeftOnly")` is a type guard that
- * narrows a `These` to its `LeftOnly` member, and likewise for `"RightOnly"` and
- * `"LeftAndRight"`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(These.is("LeftOnly")(These.LeftOnly({ left: 1 })), true)
- * assert.deepStrictEqual(
- *   These.is("LeftOnly")(These.RightOnly({ right: "a" })),
- *   false
- * )
- * ```
- *
- * @category guards
- * @since 0.0.0
- */
-declare const is: <Tag extends "LeftOnly" | "RightOnly" | "LeftAndRight">(tag: Tag) => {
-    <T extends {
-        readonly _tag: "LeftOnly";
-        readonly left: any;
-    } | {
-        readonly _tag: "RightOnly";
-        readonly right: any;
-    } | {
-        readonly _tag: "LeftAndRight";
-        readonly left: any;
-        readonly right: any;
-    }>(u: T): u is T & {
-        readonly _tag: Tag;
-    };
-    (u: unknown): u is Extract<{
-        readonly _tag: "LeftOnly";
-        readonly left: unknown;
-    }, {
-        readonly _tag: Tag;
-    }> | Extract<{
-        readonly _tag: "RightOnly";
-        readonly right: unknown;
-    }, {
-        readonly _tag: Tag;
-    }> | Extract<{
-        readonly _tag: "LeftAndRight";
-        readonly left: unknown;
-        readonly right: unknown;
-    }, {
-        readonly _tag: Tag;
-    }>;
-};
-/**
- * Folds a `These` over its three tags. Provide a handler for `LeftOnly`,
- * `RightOnly`, and `LeftAndRight` and `match` returns a function from a `These`
- * to the handlers' common result type.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const describe = These.match({
- *   LeftOnly: ({ left }) => `left ${left}`,
- *   RightOnly: ({ right }) => `right ${right}`,
- *   LeftAndRight: ({ left, right }) => `both ${left}/${right}`
- * })
- *
- * assert.deepStrictEqual(
- *   describe(These.LeftAndRight({ left: 1, right: "a" })),
- *   "both 1/a"
- * )
- * ```
- *
- * @category pattern matching
- * @since 0.0.0
- */
-declare const match$1: {
-    <A, B, C, D, Cases extends {
-        readonly LeftOnly: (args: {
-            readonly _tag: "LeftOnly";
-            readonly left: A;
-        }) => any;
-        readonly RightOnly: (args: {
-            readonly _tag: "RightOnly";
-            readonly right: B;
-        }) => any;
-        readonly LeftAndRight: (args: {
-            readonly _tag: "LeftAndRight";
-            readonly left: A;
-            readonly right: B;
-        }) => any;
-    }>(cases: Cases): (self: {
-        readonly _tag: "LeftOnly";
-        readonly left: A;
-    } | {
-        readonly _tag: "RightOnly";
-        readonly right: B;
-    } | {
-        readonly _tag: "LeftAndRight";
-        readonly left: A;
-        readonly right: B;
-    }) => effect_Unify.Unify<ReturnType<Cases["LeftOnly" | "RightOnly" | "LeftAndRight"]>>;
-    <A, B, C, D, Cases extends {
-        readonly LeftOnly: (args: {
-            readonly _tag: "LeftOnly";
-            readonly left: A;
-        }) => any;
-        readonly RightOnly: (args: {
-            readonly _tag: "RightOnly";
-            readonly right: B;
-        }) => any;
-        readonly LeftAndRight: (args: {
-            readonly _tag: "LeftAndRight";
-            readonly left: A;
-            readonly right: B;
-        }) => any;
-    }>(self: {
-        readonly _tag: "LeftOnly";
-        readonly left: A;
-    } | {
-        readonly _tag: "RightOnly";
-        readonly right: B;
-    } | {
-        readonly _tag: "LeftAndRight";
-        readonly left: A;
-        readonly right: B;
-    }, cases: Cases): effect_Unify.Unify<ReturnType<Cases["LeftOnly" | "RightOnly" | "LeftAndRight"]>>;
-};
-/**
- * Any `These` that is guaranteed to carry a `left` — either `LeftOnly` or
- * `LeftAndRight`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const value: These.WithLeft<number, string> = These.LeftOnly({ left: 1 })
- *
- * assert.deepStrictEqual(value.left, 1)
- * ```
- *
- * @category models
- * @since 0.0.0
- */
-type WithLeft<L, R> = LeftOnly<L> | LeftAndRight<L, R>;
-/**
- * Builds a `These` known to carry a `left`, choosing `LeftAndRight` when `right`
- * is present and `LeftOnly` otherwise.
- *
- * Use it when the `left` is mandatory and the `right` is an optional companion:
- * pass an absent (`null`/`undefined`) `right` to get a `LeftOnly`, or a present
- * one to get a `LeftAndRight`. The return type `WithLeft<L, R>` reflects that a
- * `left` is always present.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(
- *   These.WithLeft({ left: 1, right: "a" }),
- *   These.LeftAndRight({ left: 1, right: "a" })
- * )
- *
- * assert.deepStrictEqual(
- *   These.WithLeft({ left: 1 }),
- *   These.LeftOnly({ left: 1 })
- * )
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const WithLeft: <L, R>({ left, right, }: {
-    left: L;
-    right?: R | undefined;
-}) => WithLeft<L, R>;
-/**
- * Any `These` that is guaranteed to carry a `right` — either `RightOnly` or
- * `LeftAndRight`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const value: These.WithRight<number, string> = These.RightOnly({ right: "a" })
- *
- * assert.deepStrictEqual(value.right, "a")
- * ```
- *
- * @category models
- * @since 0.0.0
- */
-type WithRight<L, R> = RightOnly<R> | LeftAndRight<L, R>;
-/**
- * Builds a `These` known to carry a `right`, choosing `LeftAndRight` when `left`
- * is present and `RightOnly` otherwise.
- *
- * The mirror of `WithLeft`: the `right` is mandatory and the `left` is an
- * optional companion. Pass an absent (`null`/`undefined`) `left` to get a
- * `RightOnly`, or a present one to get a `LeftAndRight`. The return type
- * `WithRight<L, R>` reflects that a `right` is always present.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(
- *   These.WithRight({ left: 1, right: "a" }),
- *   These.LeftAndRight({ left: 1, right: "a" })
- * )
- *
- * assert.deepStrictEqual(
- *   These.WithRight({ right: "a" }),
- *   These.RightOnly({ right: "a" })
- * )
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const WithRight: <L, R>({ left, right, }: {
-    left?: L | undefined;
-    right: R;
-}) => WithRight<L, R>;
-/**
- * Builds a `These` from a pair of possibly-nullish inputs, wrapping the result in
- * an `Option` so the all-absent case is expressible.
- *
- * Returns `Option.some(LeftAndRight)` when both are present, `Option.some(LeftOnly)`
- * or `Option.some(RightOnly)` when exactly one is present, and `Option.none()`
- * when both are nullish. Use it as the total entry point for turning two optional
- * values into a `These`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- * import { Option } from "effect"
- *
- * assert.deepStrictEqual(
- *   These.optionFromNullables({ left: 1, right: "a" }),
- *   Option.some(These.LeftAndRight({ left: 1, right: "a" }))
- * )
- *
- * assert.deepStrictEqual(
- *   These.optionFromNullables({ left: 1, right: null }),
- *   Option.some(These.LeftOnly({ left: 1 }))
- * )
- *
- * assert.deepStrictEqual(
- *   These.optionFromNullables({ left: null, right: undefined }),
- *   Option.none()
- * )
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const optionFromNullables: <L, R>({ left, right, }: {
-    left?: L | null | undefined;
-    right?: R | null | undefined;
-}) => Option.Option<These<L, R>>;
-/**
- * Builds a `These` from a pair of possibly-nullish inputs, falling back to the
- * `orElse` thunk when both are absent.
- *
- * The non-optional companion to `optionFromNullables`: it unwraps the same logic
- * but resolves the all-absent case with `orElse` instead of an `Option`. The
- * default `orElse` throws, so omit it only when at least one side is guaranteed
- * present.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(
- *   These.fromNullables({ left: 1, right: "a" }),
- *   These.LeftAndRight({ left: 1, right: "a" })
- * )
- *
- * // Both absent — fall back via orElse instead of throwing
- * assert.deepStrictEqual(
- *   These.fromNullables({
- *     left: null,
- *     right: null,
- *     orElse: () => These.LeftOnly({ left: 0 })
- *   }),
- *   These.LeftOnly({ left: 0 })
- * )
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const fromNullables: <L, R>({ left, right, orElse, }: {
-    left?: L | null | undefined;
-    right?: R | null | undefined;
-    orElse?: () => These<L, R>;
-}) => These<L, R>;
-/**
- * Folds a `These` from the left's perspective, collapsing the three tags into two
- * handlers.
- *
- * Both `LeftOnly` and `LeftAndRight` carry a `left`, so they route to the `Left`
- * handler; only `RightOnly` lacks a `left` and routes to `RightOnly`. Use it when
- * you care about the `left` value and treat the right-only case as the exception.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const onLeft = These.matchLeft({
- *   Left: (left: number) => `left ${left}`,
- *   RightOnly: (right: string) => `right ${right}`
- * })
- *
- * assert.deepStrictEqual(onLeft(These.LeftOnly({ left: 1 })), "left 1")
- * assert.deepStrictEqual(
- *   onLeft(These.LeftAndRight({ left: 1, right: "a" })),
- *   "left 1"
- * )
- * assert.deepStrictEqual(onLeft(These.RightOnly({ right: "a" })), "right a")
- * ```
- *
- * @category pattern matching
- * @since 0.0.0
- */
-declare const matchLeft: <L, R, A>({ Left, RightOnly, }: {
-    Left: (left: L) => A;
-    RightOnly: (right: R) => A;
-}) => (these: These<L, R>) => A;
-/**
- * Folds a `These` from the right's perspective, collapsing the three tags into two
- * handlers.
- *
- * The mirror of `matchLeft`: both `RightOnly` and `LeftAndRight` carry a `right`,
- * so they route to the `Right` handler; only `LeftOnly` lacks a `right` and routes
- * to `LeftOnly`. Use it when you care about the `right` value and treat the
- * left-only case as the exception.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const onRight = These.matchRight({
- *   LeftOnly: (left: number) => `left ${left}`,
- *   Right: (right: string) => `right ${right}`
- * })
- *
- * assert.deepStrictEqual(onRight(These.RightOnly({ right: "a" })), "right a")
- * assert.deepStrictEqual(
- *   onRight(These.LeftAndRight({ left: 1, right: "a" })),
- *   "right a"
- * )
- * assert.deepStrictEqual(onRight(These.LeftOnly({ left: 1 })), "left 1")
- * ```
- *
- * @category pattern matching
- * @since 0.0.0
- */
-declare const matchRight: <L, R, A>({ LeftOnly, Right, }: {
-    LeftOnly: (left: L) => A;
-    Right: (right: R) => A;
-}) => (these: These<L, R>) => A;
-/**
- * Completes a `These` into a guaranteed `LeftAndRight` by filling whichever side
- * is missing from the matching `orElse` thunk.
- *
- * A `LeftAndRight` passes through unchanged; a `LeftOnly` gains a `right` from
- * `orElseRight`; a `RightOnly` gains a `left` from `orElseLeft`. Use it to
- * normalise a partial `These` into the both-present shape before reading both
- * sides.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const fill = These.orElse({
- *   orElseLeft: () => 0,
- *   orElseRight: () => "default"
- * })
- *
- * assert.deepStrictEqual(
- *   fill(These.LeftOnly({ left: 1 })),
- *   These.LeftAndRight({ left: 1, right: "default" })
- * )
- * assert.deepStrictEqual(
- *   fill(These.RightOnly({ right: "a" })),
- *   These.LeftAndRight({ left: 0, right: "a" })
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const orElse: <L2, R2>({ orElseLeft, orElseRight, }: {
-    orElseLeft: () => L2;
-    orElseRight: () => R2;
-}) => (<L, R>(these: These<L, R>) => LeftAndRight<L | L2, R | R2>);
-/**
- * Completes a `These` into a `LeftAndRight` whose missing side is filled with
- * `undefined`.
- *
- * A specialisation of `orElse` that supplies `undefined` for whichever side is
- * absent, so the result always exposes both `left` and `right` keys (each
- * possibly `undefined`). Use it when you want to destructure both sides without
- * branching on the tag.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(
- *   These.orUndefined(These.LeftOnly({ left: 1 })),
- *   These.LeftAndRight({ left: 1, right: undefined })
- * )
- * assert.deepStrictEqual(
- *   These.orUndefined(These.RightOnly({ right: "a" })),
- *   These.LeftAndRight({ left: undefined, right: "a" })
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const orUndefined: <L, R>(these: {
-    readonly _tag: "LeftOnly";
-    readonly left: L;
-} | {
-    readonly _tag: "RightOnly";
-    readonly right: R;
-} | {
-    readonly _tag: "LeftAndRight";
-    readonly left: L;
-    readonly right: R;
-}) => {
-    readonly _tag: "LeftAndRight";
-    readonly left: L | undefined;
-    readonly right: R | undefined;
-} & {
-    _tag: "LeftAndRight";
-};
-/**
- * Extracts the `left` of a `These`, falling back to `orElseReturn` when no `left`
- * is present.
- *
- * `LeftOnly` and `LeftAndRight` return their `left`; `RightOnly` returns the
- * result of `orElseReturn`. Use it to read the left side with a default in one
- * step.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const leftOrZero = These.leftOrElse(() => 0)
- *
- * assert.deepStrictEqual(leftOrZero(These.LeftOnly({ left: 1 })), 1)
- * assert.deepStrictEqual(
- *   leftOrZero(These.LeftAndRight({ left: 1, right: "a" })),
- *   1
- * )
- * assert.deepStrictEqual(leftOrZero(These.RightOnly({ right: "a" })), 0)
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const leftOrElse: <A>(orElseReturn: () => A) => <L, R>(these: These<L, R>) => L | A;
-/**
- * Extracts the `left` of a `These`, returning `undefined` when no `left` is
- * present.
- *
- * A specialisation of `leftOrElse` whose fallback is `undefined`: `LeftOnly` and
- * `LeftAndRight` yield their `left`, while `RightOnly` yields `undefined`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(These.leftOrUndefined(These.LeftOnly({ left: 1 })), 1)
- * assert.deepStrictEqual(
- *   These.leftOrUndefined(These.RightOnly({ right: "a" })),
- *   undefined
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const leftOrUndefined: <L, R>(these: {
-    readonly _tag: "LeftOnly";
-    readonly left: L;
-} | {
-    readonly _tag: "RightOnly";
-    readonly right: R;
-} | {
-    readonly _tag: "LeftAndRight";
-    readonly left: L;
-    readonly right: R;
-}) => L | undefined;
-/**
- * Extracts the `right` of a `These`, falling back to `orElseReturn` when no
- * `right` is present.
- *
- * The mirror of `leftOrElse`: `RightOnly` and `LeftAndRight` return their
- * `right`; `LeftOnly` returns the result of `orElseReturn`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const rightOrDefault = These.rightOrElse(() => "default")
- *
- * assert.deepStrictEqual(
- *   rightOrDefault(These.RightOnly({ right: "a" })),
- *   "a"
- * )
- * assert.deepStrictEqual(
- *   rightOrDefault(These.LeftOnly({ left: 1 })),
- *   "default"
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const rightOrElse: <A>(orElseReturn: () => A) => <L, R>(these: These<L, R>) => R | A;
-/**
- * Extracts the `right` of a `These`, returning `undefined` when no `right` is
- * present.
- *
- * A specialisation of `rightOrElse` whose fallback is `undefined`: `RightOnly` and
- * `LeftAndRight` yield their `right`, while `LeftOnly` yields `undefined`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(
- *   These.rightOrUndefined(These.RightOnly({ right: "a" })),
- *   "a"
- * )
- * assert.deepStrictEqual(
- *   These.rightOrUndefined(These.LeftOnly({ left: 1 })),
- *   undefined
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const rightOrUndefined: <L, R>(these: {
-    readonly _tag: "LeftOnly";
-    readonly left: L;
-} | {
-    readonly _tag: "RightOnly";
-    readonly right: R;
-} | {
-    readonly _tag: "LeftAndRight";
-    readonly left: L;
-    readonly right: R;
-}) => R | undefined;
-/**
- * Extracts the `right` of a `These` as an `Option`.
- *
- * `RightOnly` and `LeftAndRight` yield `Option.some(right)`; `LeftOnly` yields
- * `Option.none()`. Use it when you want to chain the right side through `Option`
- * combinators rather than fall back to a default eagerly.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- * import { Option } from "effect"
- *
- * assert.deepStrictEqual(
- *   These.rightOption(These.RightOnly({ right: "a" })),
- *   Option.some("a")
- * )
- * assert.deepStrictEqual(
- *   These.rightOption(These.LeftOnly({ left: 1 })),
- *   Option.none()
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const rightOption: <L, R>(these: These<L, R>) => Option.Option<R>;
-/**
- * Extracts the `left` of a `These` as an `Option`.
- *
- * The mirror of `rightOption`: `LeftOnly` and `LeftAndRight` yield
- * `Option.some(left)`, while `RightOnly` yields `Option.none()`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- * import { Option } from "effect"
- *
- * assert.deepStrictEqual(
- *   These.leftOption(These.LeftOnly({ left: 1 })),
- *   Option.some(1)
- * )
- * assert.deepStrictEqual(
- *   These.leftOption(These.RightOnly({ right: "a" })),
- *   Option.none()
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const leftOption: <L, R>(these: These<L, R>) => Option.Option<L>;
-/**
- * Transforms both sides of a `These`, applying `mapLeft` to any `left` and
- * `mapRight` to any `right`.
- *
- * Each constructor is rebuilt with its mapped contents, so `LeftOnly` maps only
- * the left, `RightOnly` only the right, and `LeftAndRight` both. The tag is
- * preserved. Use it as the bifunctor map over `These`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const both = These.mapBoth({
- *   mapLeft: (left: number) => left + 1,
- *   mapRight: (right: string) => right.toUpperCase()
- * })
- *
- * assert.deepStrictEqual(
- *   both(These.LeftAndRight({ left: 1, right: "a" })),
- *   These.LeftAndRight({ left: 2, right: "A" })
- * )
- * assert.deepStrictEqual(
- *   both(These.LeftOnly({ left: 1 })),
- *   These.LeftOnly({ left: 2 })
- * )
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const mapBoth: <L1, R1, L2, R2>({ mapLeft, mapRight, }: {
-    mapLeft: (left: L1) => L2;
-    mapRight: (right: R1) => R2;
-}) => ((these: These<L1, R1>) => These<L2, R2>);
-/**
- * Effectful `mapBoth`: transforms each present side through an `Effect`,
- * reassembling the results into a `These` inside an `Effect`.
- *
- * For `LeftAndRight` both effects run via `Effect.all` and their results are
- * combined; `LeftOnly`/`RightOnly` run only the relevant effect. Errors and
- * requirements from both mappers are unioned into the result type. Use it when
- * mapping a `These`'s sides requires effects (validation, IO).
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- * import { Effect } from "effect"
- *
- * const both = These.mapBothEffect({
- *   mapLeft: (left: number) => Effect.succeed(left + 1),
- *   mapRight: (right: string) => Effect.succeed(right.toUpperCase())
- * })
- *
- * assert.deepStrictEqual(
- *   Effect.runSync(both(These.LeftAndRight({ left: 1, right: "a" }))),
- *   These.LeftAndRight({ left: 2, right: "A" })
- * )
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const mapBothEffect: <L1, R1, L2, R2, EL, ER, RL, RR>({ mapLeft, mapRight, }: {
-    mapLeft: (left: L1) => Effect.Effect<L2, EL, RL>;
-    mapRight: (right: R1) => Effect.Effect<R2, ER, RR>;
-}) => ((these: These<L1, R1>) => Effect.Effect<These<L2, R2>, EL | ER, RL | RR>);
-/**
- * Transforms the `left` of a `These`, leaving any `right` untouched.
- *
- * A specialisation of `mapBoth` with the right mapper set to `identity`:
- * `LeftOnly` and `LeftAndRight` have their `left` mapped, while `RightOnly` passes
- * through unchanged.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const inc = These.mapLeft((left: number) => left + 1)
- *
- * assert.deepStrictEqual(
- *   inc(These.LeftAndRight({ left: 1, right: "a" })),
- *   These.LeftAndRight({ left: 2, right: "a" })
- * )
- * assert.deepStrictEqual(
- *   inc(These.RightOnly({ right: "a" })),
- *   These.RightOnly({ right: "a" })
- * )
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const mapLeft: <L1, L2>(mapLeft: (left: L1) => L2) => (<R>(these: These<L1, R>) => These<L2, R>);
-/**
- * Chains the `left` of a `These` into a new `These`, flattening the result.
- *
- * Whenever a `left` is present (`LeftOnly` or `LeftAndRight`) it is passed to
- * `mapLeft`, whose returned `These` replaces the original; `RightOnly` passes
- * through unchanged. Use it to sequence left-driven computations that themselves
- * produce a `These`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const chain = These.flatMapLeft((left: number) =>
- *   left > 0
- *     ? These.LeftOnly({ left: left * 10 })
- *     : These.RightOnly({ right: "non-positive" })
- * )
- *
- * assert.deepStrictEqual(
- *   chain(These.LeftOnly({ left: 2 })),
- *   These.LeftOnly({ left: 20 })
- * )
- * assert.deepStrictEqual(
- *   chain(These.RightOnly({ right: "a" })),
- *   These.RightOnly({ right: "a" })
- * )
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const flatMapLeft: <L1, L2, R2>(mapLeft: (left: L1) => These<L2, R2>) => (<R1>(these: These<L1, R1>) => These<L2, R1 | R2>);
-/**
- * Effectful `mapLeft`: transforms the `left` of a `These` through an `Effect`,
- * leaving any `right` untouched.
- *
- * A specialisation of `mapBothEffect` with the right mapper set to
- * `Effect.succeed`: the `left` (when present) is mapped effectfully and the
- * `right` is carried through unchanged.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- * import { Effect } from "effect"
- *
- * const inc = These.mapLeftEffect((left: number) => Effect.succeed(left + 1))
- *
- * assert.deepStrictEqual(
- *   Effect.runSync(inc(These.LeftAndRight({ left: 1, right: "a" }))),
- *   These.LeftAndRight({ left: 2, right: "a" })
- * )
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const mapLeftEffect: <L1, L2, EL, RL>(mapLeft: (left: L1) => Effect.Effect<L2, EL, RL>) => (<R>(these: These<L1, R>) => Effect.Effect<These<L2, R>, EL, RL>);
-/**
- * Effectful `flatMapLeft`: chains the `left` of a `These` into an `Effect` that
- * yields a new `These`, flattening the result.
- *
- * When a `left` is present it is passed to `mapLeft`, whose effectful `These`
- * replaces the original; `RightOnly` is lifted unchanged via `Effect.succeed`. Use
- * it to sequence left-driven effectful computations that produce a `These`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- * import { Effect } from "effect"
- *
- * const chain = These.flatMapLeftEffect((left: number) =>
- *   Effect.succeed(These.LeftOnly({ left: left * 10 }))
- * )
- *
- * assert.deepStrictEqual(
- *   Effect.runSync(chain(These.LeftOnly({ left: 2 }))),
- *   These.LeftOnly({ left: 20 })
- * )
- * assert.deepStrictEqual(
- *   Effect.runSync(chain(These.RightOnly({ right: "a" }))),
- *   These.RightOnly({ right: "a" })
- * )
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const flatMapLeftEffect: <L1, L2, R2, EL, RL>(mapLeft: (left: L1) => Effect.Effect<These<L2, R2>, EL, RL>) => (<R1>(these: These<L1, R1>) => Effect.Effect<These<L2, R1 | R2>, EL, RL>);
-/**
- * Transforms the `right` of a `These`, leaving any `left` untouched.
- *
- * The mirror of `mapLeft`: `RightOnly` and `LeftAndRight` have their `right`
- * mapped, while `LeftOnly` passes through unchanged.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const upper = These.mapRight((right: string) => right.toUpperCase())
- *
- * assert.deepStrictEqual(
- *   upper(These.LeftAndRight({ left: 1, right: "a" })),
- *   These.LeftAndRight({ left: 1, right: "A" })
- * )
- * assert.deepStrictEqual(
- *   upper(These.LeftOnly({ left: 1 })),
- *   These.LeftOnly({ left: 1 })
- * )
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const mapRight: <R1, R2>(mapRight: (right: R1) => R2) => (<L>(these: These<L, R1>) => These<L, R2>);
-/**
- * Chains the `right` of a `These` into a new `These`, flattening the result.
- *
- * The mirror of `flatMapLeft`: whenever a `right` is present (`RightOnly` or
- * `LeftAndRight`) it is passed to `mapRight`, whose returned `These` replaces the
- * original; `LeftOnly` passes through unchanged.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- *
- * const chain = These.flatMapRight((right: string) =>
- *   These.RightOnly({ right: right.toUpperCase() })
- * )
- *
- * assert.deepStrictEqual(
- *   chain(These.RightOnly({ right: "a" })),
- *   These.RightOnly({ right: "A" })
- * )
- * assert.deepStrictEqual(
- *   chain(These.LeftOnly({ left: 1 })),
- *   These.LeftOnly({ left: 1 })
- * )
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const flatMapRight: <L2, R1, R2>(mapRight: (right: R1) => These<L2, R2>) => (<L1>(these: These<L1, R1>) => These<L1 | L2, R2>);
-/**
- * Effectful `mapRight`: transforms the `right` of a `These` through an `Effect`,
- * leaving any `left` untouched.
- *
- * The mirror of `mapLeftEffect`: the `right` (when present) is mapped effectfully
- * and the `left` is carried through unchanged via `Effect.succeed`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- * import { Effect } from "effect"
- *
- * const upper = These.mapRightEffect((right: string) =>
- *   Effect.succeed(right.toUpperCase())
- * )
- *
- * assert.deepStrictEqual(
- *   Effect.runSync(upper(These.LeftAndRight({ left: 1, right: "a" }))),
- *   These.LeftAndRight({ left: 1, right: "A" })
- * )
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const mapRightEffect: <R1, R2, ER, RR>(mapRight: (right: R1) => Effect.Effect<R2, ER, RR>) => (<L>(these: These<L, R1>) => Effect.Effect<These<L, R2>, ER, RR>);
-/**
- * Effectful `flatMapRight`: chains the `right` of a `These` into an `Effect` that
- * yields a new `These`, flattening the result.
- *
- * The mirror of `flatMapLeftEffect`: when a `right` is present it is passed to
- * `mapRight`, whose effectful `These` replaces the original; `LeftOnly` is lifted
- * unchanged via `Effect.succeed`.
- *
- * @example
- * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
- * import { Effect } from "effect"
- *
- * const chain = These.flatMapRightEffect((right: string) =>
- *   Effect.succeed(These.RightOnly({ right: right.toUpperCase() }))
- * )
- *
- * assert.deepStrictEqual(
- *   Effect.runSync(chain(These.RightOnly({ right: "a" }))),
- *   These.RightOnly({ right: "A" })
- * )
- * assert.deepStrictEqual(
- *   Effect.runSync(chain(These.LeftOnly({ left: 1 }))),
- *   These.LeftOnly({ left: 1 })
- * )
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const flatMapRightEffect: <L2, R1, R2, ER, RR>(mapRight: (right: R1) => Effect.Effect<These<L2, R2>, ER, RR>) => (<L1>(these: These<L1, R1>) => Effect.Effect<These<L1 | L2, R2>, ER, RR>);
-
-declare const These$1_LeftAndRight: typeof LeftAndRight;
-declare const These$1_LeftOnly: typeof LeftOnly;
-declare const These$1_RightOnly: typeof RightOnly;
-type These$1_These<L, R> = These<L, R>;
-declare const These$1_WithLeft: typeof WithLeft;
-declare const These$1_WithRight: typeof WithRight;
-declare const These$1_flatMapLeft: typeof flatMapLeft;
-declare const These$1_flatMapLeftEffect: typeof flatMapLeftEffect;
-declare const These$1_flatMapRight: typeof flatMapRight;
-declare const These$1_flatMapRightEffect: typeof flatMapRightEffect;
-declare const These$1_fromNullables: typeof fromNullables;
-declare const These$1_is: typeof is;
-declare const These$1_leftOption: typeof leftOption;
-declare const These$1_leftOrElse: typeof leftOrElse;
-declare const These$1_leftOrUndefined: typeof leftOrUndefined;
-declare const These$1_mapBoth: typeof mapBoth;
-declare const These$1_mapBothEffect: typeof mapBothEffect;
-declare const These$1_mapLeft: typeof mapLeft;
-declare const These$1_mapLeftEffect: typeof mapLeftEffect;
-declare const These$1_mapRight: typeof mapRight;
-declare const These$1_mapRightEffect: typeof mapRightEffect;
-declare const These$1_matchLeft: typeof matchLeft;
-declare const These$1_matchRight: typeof matchRight;
-declare const These$1_optionFromNullables: typeof optionFromNullables;
-declare const These$1_orElse: typeof orElse;
-declare const These$1_orUndefined: typeof orUndefined;
-declare const These$1_rightOption: typeof rightOption;
-declare const These$1_rightOrElse: typeof rightOrElse;
-declare const These$1_rightOrUndefined: typeof rightOrUndefined;
-declare namespace These$1 {
-  export { These$1_LeftAndRight as LeftAndRight, These$1_LeftOnly as LeftOnly, These$1_RightOnly as RightOnly, type These$1_These as These, These$1_WithLeft as WithLeft, These$1_WithRight as WithRight, These$1_flatMapLeft as flatMapLeft, These$1_flatMapLeftEffect as flatMapLeftEffect, These$1_flatMapRight as flatMapRight, These$1_flatMapRightEffect as flatMapRightEffect, These$1_fromNullables as fromNullables, These$1_is as is, These$1_leftOption as leftOption, These$1_leftOrElse as leftOrElse, These$1_leftOrUndefined as leftOrUndefined, These$1_mapBoth as mapBoth, These$1_mapBothEffect as mapBothEffect, These$1_mapLeft as mapLeft, These$1_mapLeftEffect as mapLeftEffect, These$1_mapRight as mapRight, These$1_mapRightEffect as mapRightEffect, match$1 as match, These$1_matchLeft as matchLeft, These$1_matchRight as matchRight, These$1_optionFromNullables as optionFromNullables, These$1_orElse as orElse, These$1_orUndefined as orUndefined, These$1_rightOption as rightOption, These$1_rightOrElse as rightOrElse, These$1_rightOrUndefined as rightOrUndefined };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Array` module.
- *
- * @since 0.0.0
- */
-
-/**
- * Returns a shallow copy of `array` between `start` (inclusive) and `end`
- * (exclusive), as a pipeable, dual-form alias for `Array.prototype.slice`.
- *
- * `Array.prototype.slice` is already non-mutating (it returns a shallow copy),
- * but it isn't pipeable. This helper makes it composable inside `pipe(...)`
- * chains alongside the rest of the codebase's Effect-style utilities.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(ArrayX.slice([1, 2, 3, 4], 1, 3), [2, 3])
- *
- * // data-last (pipeable)
- * assert.deepStrictEqual(pipe([1, 2, 3, 4], ArrayX.slice(1, 3)), [2, 3])
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const slice: (<A>(start: number, end: number) => (array: readonly A[]) => A[]) & (<A>(array: readonly A[], start: number, end: number) => A[]);
-/**
- * Zips two arrays into one, calling `f` with a `These` for each index so that
- * length mismatches are handled explicitly rather than truncated.
- *
- * Unlike `Array.zipWith` (which stops at the shorter array), this walks to the
- * length of the *longer* array. At each index `f` receives a `These.These<A, B>`:
- * `LeftAndRight` when both arrays have an element, `LeftOnly` when only the
- * first does, and `RightOnly` when only the second does. Use it when the
- * "extra" tail of either array still carries meaning.
- *
- * @example
- * ```ts
- * import { ArrayX, These } from "@nunofyobiz/effect-extras"
- *
- * const describe = These.match({
- *   LeftOnly: ({ left }) => `left ${left}`,
- *   RightOnly: ({ right }) => `right ${right}`,
- *   LeftAndRight: ({ left, right }) => `both ${left}/${right}`,
- * })
- *
- * assert.deepStrictEqual(ArrayX.zipWithThese([1, 2, 3], [10, 20], describe), [
- *   "both 1/10",
- *   "both 2/20",
- *   "left 3",
- * ])
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const zipWithThese: (<A, B, C>(f: (ab: These<A, B>) => C) => (array1: readonly A[], array2: readonly B[]) => C[]) & (<A, B, C>(array1: readonly A[], array2: readonly B[], f: (ab: These<A, B>) => C) => C[]);
-/**
- * Inserts or moves a unique item in an array at a specified position.
- *
- * **Assumption**: Items should be unique in the array based on standard equality.
- *
- * **Happy case**: If the item doesn't exist in the array and the destination reference item is found:
- * The new item is inserted before the destination reference item
- *
- * **Item not found in array**:
- * - If destination reference item is found: The new item is inserted before the destination reference item
- * - If destination reference item is not found: The new item is inserted at the end of the array
- *
- * **Item found but duplicated**:
- * - If destination reference item is found: All existing copies are removed, then a single copy is inserted before the destination reference item
- * - If destination reference item is not found: All existing copies are removed, then a single copy is inserted at the end of the array
- *
- * @param array - The input array to modify
- * @param config - Configuration object containing:
- *   - `item`: The item to insert or update (must be a string or number)
- *   - `insertToBeLeftOf`: The item to position the new/updated item before,
- *                         or null to insert at the end
- *
- * @returns A new array with the item inserted or moved to the specified position
- *
- * @example
- * ```ts
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * // Move an existing item to sit just before "c"
- * assert.deepStrictEqual(
- *   ArrayX.insertUniq(["a", "b", "c", "d"], { item: "a", insertToBeLeftOf: "c" }),
- *   ["b", "a", "c", "d"],
- * )
- *
- * // Insert a brand-new item; unknown destination falls through to the end
- * assert.deepStrictEqual(
- *   ArrayX.insertUniq(["a", "b"], { item: "new", insertToBeLeftOf: null }),
- *   ["a", "b", "new"],
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const insertUniq: (<A extends string | number>(config: {
-    item: A;
-    insertToBeLeftOf: A | null;
-}) => (array: readonly A[] | A[]) => A[]) & (<A extends string | number>(array: readonly A[] | A[], config: {
-    item: A;
-    insertToBeLeftOf: A | null;
-}) => A[]);
-/**
- * Maps over `array` while threading an accumulator, iterating from right to
- * left instead of left to right.
- *
- * Identical to `Array.mapAccum`, except the traversal order is reversed: `f` is
- * called on the last element first, and the resulting array is returned in the
- * original (left-to-right) order. Use it when each element's mapped value
- * depends on state accumulated from the elements that follow it.
- *
- * @example
- * ```ts
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * // Running suffix-sum: each slot holds the sum of itself and everything after it
- * assert.deepStrictEqual(
- *   ArrayX.mapRightAccum([1, 2, 3], 0, (total, n) => [total + n, total + n]),
- *   [6, [6, 5, 3]],
- * )
- * ```
- *
- * @category folding
- * @since 0.0.0
- */
-declare const mapRightAccum: (<A, B, C>(initialAccumulator: C, f: (accumulator: C, a: A, index: number) => [C, B]) => (array: A[]) => [C, B[]]) & (<A, B, C>(array: A[], initialAccumulator: C, f: (accumulator: C, a: A, index: number) => [C, B]) => [C, B[]]);
-/**
- * Returns the maximum element of `array` according to `order`, wrapped in an
- * `Option` so that empty arrays are handled safely.
- *
- * Effect's `Array.max` throws on an empty array; this returns `Option.none()`
- * instead, and `Option.some(max)` otherwise. Reach for it whenever the input
- * array might be empty.
- *
- * @example
- * ```ts
- * import { Option, Order, pipe } from "effect"
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(
- *   pipe([3, 7, 2], ArrayX.maxOption(Order.Number)),
- *   Option.some(7),
- * )
- * assert.deepStrictEqual(
- *   pipe([], ArrayX.maxOption(Order.Number)),
- *   Option.none(),
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const maxOption: (<A>(order: Order.Order<A>) => (array: A[]) => Option.Option<A>) & (<A>(array: A[], order: Order.Order<A>) => Option.Option<A>);
-/**
- * Returns the smallest element of `array` (per `order`) that matches
- * `predicate`, narrowed to the refined type `B`, or `Option.none()` if none
- * match.
- *
- * Combines a refinement filter with `Array.min`: only elements satisfying
- * `predicate` are considered, and the minimum of those (by `order`) is
- * returned. The refinement narrows the element type, so the resulting `Option`
- * carries the more specific `B`.
- *
- * @example
- * ```ts
- * import { Option, Order, pipe } from "effect"
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * const isEven = (n: number): n is number => n % 2 === 0
- *
- * assert.deepStrictEqual(
- *   pipe([3, 4, 1, 2, 5], ArrayX.takeFirstWhere(isEven, Order.Number)),
- *   Option.some(2),
- * )
- * assert.deepStrictEqual(
- *   pipe([1, 3, 5], ArrayX.takeFirstWhere(isEven, Order.Number)),
- *   Option.none(),
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const takeFirstWhere$1: (<A, B extends A>(predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => (array: A[]) => Option.Option<B>) & (<A, B extends A>(array: A[], predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => Option.Option<B>);
-/**
- * Returns the largest element of `array` (per `order`) that matches
- * `predicate`, narrowed to the refined type `B`, or `Option.none()` if none
- * match.
- *
- * The mirror of {@link takeFirstWhere}: only elements satisfying `predicate`
- * are considered, and the maximum of those (by `order`) is returned. The
- * refinement narrows the element type, so the resulting `Option` carries the
- * more specific `B`.
- *
- * @example
- * ```ts
- * import { Option, Order, pipe } from "effect"
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * const isEven = (n: number): n is number => n % 2 === 0
- *
- * assert.deepStrictEqual(
- *   pipe([3, 4, 1, 2, 5], ArrayX.takeLastWhere(isEven, Order.Number)),
- *   Option.some(4),
- * )
- * assert.deepStrictEqual(
- *   pipe([1, 3, 5], ArrayX.takeLastWhere(isEven, Order.Number)),
- *   Option.none(),
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const takeLastWhere$1: (<A, B extends A>(predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => (array: A[]) => Option.Option<B>) & (<A, B extends A>(array: A[], predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => Option.Option<B>);
-/**
- * Groups `items` into a partial record keyed by the category each item maps to
- * via `categorize`.
- *
- * Each item is appended to the array under its category, preserving input
- * order. The result is `Partial<Record<C, A[]>>` because not every possible
- * category `C` is guaranteed to appear — only categories that received at least
- * one item are present.
- *
- * @example
- * ```ts
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * const parity = (n: number) => (n % 2 === 0 ? "even" : "odd")
- *
- * assert.deepStrictEqual(ArrayX.categorize([1, 2, 3, 4], parity), {
- *   odd: [1, 3],
- *   even: [2, 4],
- * })
- * ```
- *
- * @category folding
- * @since 0.0.0
- */
-declare const categorize: <A, C extends string>(items: Iterable<A>, categorize: (a: A) => C) => Partial<Record<C, A[]>>;
-/**
- * Removes all `null` and `undefined` elements from `array`, narrowing the
- * element type to `NonNullable<A>`.
- *
- * Falsy-but-present values such as `0` and `""` are kept — only nullish values
- * are dropped. Use it to clean up an array of optionals into a dense array of
- * known-present values.
- *
- * @example
- * ```ts
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(
- *   ArrayX.compactNullable([1, null, 2, undefined, 0, ""]),
- *   [1, 2, 0, ""],
- * )
- * ```
- *
- * @category filtering
- * @since 0.0.0
- */
-declare const compactNullable: <A>(array: A[]) => NonNullable<A>[];
-/**
- * Drops the leading elements of `array` until `predicate` first holds, keeping
- * everything from the first match onward.
- *
- * The first matching element and all subsequent elements are retained
- * regardless of whether they match — only the prefix *before* the first match
- * is trimmed. If nothing matches, returns an empty array.
- *
- * @example
- * ```ts
- * import { Predicate } from "effect"
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * // Trims the leading strings, then keeps everything (including the trailing "b")
- * assert.deepStrictEqual(
- *   ArrayX.filterHead(["a", 1, 2, "b"], Predicate.isNumber),
- *   [1, 2, "b"],
- * )
- * ```
- *
- * @category filtering
- * @since 0.0.0
- */
-declare const filterHead: (<A>(predicate: Predicate.Predicate<A>) => (array: A[]) => A[]) & (<A>(array: A[], predicate: Predicate.Predicate<A>) => A[]);
-/**
- * Drops the trailing elements of `array` after `predicate` last holds, keeping
- * everything up to and including the last match.
- *
- * The mirror of {@link filterHead}: the last matching element and all preceding
- * elements are retained regardless of whether they match — only the suffix
- * *after* the last match is trimmed. If nothing matches, returns an empty
- * array.
- *
- * @example
- * ```ts
- * import { Predicate } from "effect"
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * // Keeps the leading "a" and trims the trailing strings after the last number
- * assert.deepStrictEqual(
- *   ArrayX.filterTail(["a", 1, 2, "b"], Predicate.isNumber),
- *   ["a", 1, 2],
- * )
- * ```
- *
- * @category filtering
- * @since 0.0.0
- */
-declare const filterTail: (<A>(predicate: Predicate.Predicate<A>) => (array: A[]) => A[]) & (<A>(array: A[], predicate: Predicate.Predicate<A>) => A[]);
-/**
- * Maps `f` over `array` and drops every result that is `null` or `undefined`,
- * narrowing the element type to `NonNullable<B>`.
- *
- * A nullable-friendly `Array.filterMap`: where `filterMap` expects `f` to
- * return an `Option`, this accepts a function returning `B | null` (or
- * `undefined`) and treats nullish results as "skip this element". Falsy-but-
- * present values such as `0` and `""` are kept.
- *
- * @example
- * ```ts
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * // Keep only the even numbers, mapped to their halves
- * assert.deepStrictEqual(
- *   ArrayX.filterMapNullable([1, 2, 3, 4], (n) => (n % 2 === 0 ? n / 2 : null)),
- *   [1, 2],
- * )
- * ```
- *
- * @category filtering
- * @since 0.0.0
- */
-declare const filterMapNullable: (<A, B>(f: (a: A) => B | null) => (array: A[]) => NonNullable<B>[]) & (<A, B>(array: A[], f: (a: A) => B | null) => NonNullable<B>[]);
-/**
- * Finds the first element of a 2-dimensional array (row-major order) matching
- * `predicate`, returning it alongside its row and column indices.
- *
- * Scans rows top-to-bottom and, within each row, left-to-right. On a match
- * returns `Option.some([value, rowIndex, columnIndex])`; if no element matches
- * (or the grid is empty), returns `Option.none()`.
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * const grid = [
- *   ["A", "B", "C"],
- *   ["D", "E", "F"],
- * ]
- *
- * assert.deepStrictEqual(
- *   ArrayX.findFirstWithIndex2d(grid, (cell) => cell === "E"),
- *   Option.some(["E", 1, 1]),
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const findFirstWithIndex2d: (<A>(predicate: Predicate.Predicate<A>) => (array: A[][]) => Option.Option<[A, number, number]>) & (<A>(array: A[][], predicate: Predicate.Predicate<A>) => Option.Option<[A, number, number]>);
-/**
- * Splits `array` into runs of consecutive elements that share the same group
- * value, where the group is derived by `chunk` and compared with the provided
- * `Equivalence`.
- *
- * Only *adjacent* elements are grouped: a new run starts every time the group
- * value changes from the previous element. Each entry in the result carries the
- * `group` value and the non-empty array of `values` that produced it, preserving
- * input order. An empty input yields an empty array. Use it for run-length-style
- * segmentation; reach for `Array.groupBy` instead when you want all elements
- * with the same key collapsed regardless of position.
- *
- * @example
- * ```ts
- * import { Equivalence } from "effect"
- * import { ArrayX } from "@nunofyobiz/effect-extras"
- *
- * // Group adjacent numbers by parity
- * assert.deepStrictEqual(
- *   ArrayX.chunkBy([2, 4, 1, 3, 6], (n) => n % 2 === 0, Equivalence.Boolean),
- *   [
- *     { group: true, values: [2, 4] },
- *     { group: false, values: [1, 3] },
- *     { group: true, values: [6] },
- *   ],
- * )
- * ```
- *
- * @category folding
- * @since 0.0.0
- */
-declare const chunkBy: (<A, B>(chunk: (a: A) => B, GroupEquivalence: Equivalence.Equivalence<B>) => (array: A[]) => {
-    group: B;
-    values: Array.NonEmptyArray<A>;
-}[]) & (<A, B>(array: A[], chunk: (a: A) => B, GroupEquivalence: Equivalence.Equivalence<B>) => {
-    group: B;
-    values: Array.NonEmptyArray<A>;
-}[]);
-
-declare const ArrayX_categorize: typeof categorize;
-declare const ArrayX_chunkBy: typeof chunkBy;
-declare const ArrayX_compactNullable: typeof compactNullable;
-declare const ArrayX_filterHead: typeof filterHead;
-declare const ArrayX_filterMapNullable: typeof filterMapNullable;
-declare const ArrayX_filterTail: typeof filterTail;
-declare const ArrayX_findFirstWithIndex2d: typeof findFirstWithIndex2d;
-declare const ArrayX_insertUniq: typeof insertUniq;
-declare const ArrayX_mapRightAccum: typeof mapRightAccum;
-declare const ArrayX_maxOption: typeof maxOption;
-declare const ArrayX_slice: typeof slice;
-declare const ArrayX_zipWithThese: typeof zipWithThese;
-declare namespace ArrayX {
-  export { ArrayX_categorize as categorize, ArrayX_chunkBy as chunkBy, ArrayX_compactNullable as compactNullable, ArrayX_filterHead as filterHead, ArrayX_filterMapNullable as filterMapNullable, ArrayX_filterTail as filterTail, ArrayX_findFirstWithIndex2d as findFirstWithIndex2d, ArrayX_insertUniq as insertUniq, ArrayX_mapRightAccum as mapRightAccum, ArrayX_maxOption as maxOption, ArrayX_slice as slice, takeFirstWhere$1 as takeFirstWhere, takeLastWhere$1 as takeLastWhere, ArrayX_zipWithThese as zipWithThese };
-}
-
-/**
- * Converts a `bigint` to a `number`, throwing when the value cannot be
- * represented exactly.
- *
- * Delegates to Effect's `BigInt.toNumber`, which returns `None` once the
- * `bigint` falls outside the safe integer range (`Number.MAX_SAFE_INTEGER`).
- * This unwraps that `Option`, throwing instead of silently losing precision —
- * use it only when the value is known to fit.
- *
- * @example
- * ```ts
- * import { BigIntX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(BigIntX.toNumberOrThrow(42n), 42)
- *
- * // throws when outside the safe integer range
- * assert.throws(() => BigIntX.toNumberOrThrow(9007199254740993n))
- * ```
- *
- * @category unsafe
- * @since 0.0.0
- */
-declare const toNumberOrThrow: (value: bigint) => number;
-
-declare const BigIntX_toNumberOrThrow: typeof toNumberOrThrow;
-declare namespace BigIntX {
-  export { BigIntX_toNumberOrThrow as toNumberOrThrow };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Boolean` module.
- *
- * @since 0.0.0
- */
-/**
- * Converts a `boolean` to its binary digit: `1` for `true`, `0` for `false`.
- *
- * Useful when a numeric flag is required — summing booleans to count how many
- * predicates hold, or feeding a bit into bitwise math or an external API that
- * expects `0`/`1` rather than `false`/`true`.
- *
- * @example
- * ```ts
- * import { BooleanX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(BooleanX.toBinary(true), 1)
- * assert.deepStrictEqual(BooleanX.toBinary(false), 0)
- * ```
- *
- * @category conversions
- * @since 0.0.0
- */
-declare const toBinary: (value: boolean) => 0 | 1;
-
-declare const BooleanX_toBinary: typeof toBinary;
-declare namespace BooleanX {
-  export { BooleanX_toBinary as toBinary };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Duration` module.
- *
- * @since 0.0.0
- */
-
-/**
- * Computes the elapsed `Duration` from `that` to `self`, clamped at zero.
- *
- * Represents the time that has passed since the reference instant `that`. When
- * `that` lies in the future relative to `self`, the elapsed time is `zero`
- * rather than a negative duration.
- *
- * @example
- * ```ts
- * import { DateTime, Duration, pipe } from "effect"
- * import { DurationX } from "@nunofyobiz/effect-extras"
- *
- * const earlier = DateTime.makeUnsafe(1000)
- * const later = DateTime.makeUnsafe(4000)
- *
- * // data-first
- * assert.deepStrictEqual(DurationX.diff(later, earlier), Duration.seconds(3))
- *
- * // future reference clamps to zero
- * assert.deepStrictEqual(DurationX.diff(earlier, later), Duration.zero)
- *
- * // data-last (piped)
- * assert.deepStrictEqual(
- *   pipe(later, DurationX.diff(earlier)),
- *   Duration.seconds(3),
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const diff: ((that: DateTime.DateTime) => (self: DateTime.DateTime) => Duration.Duration) & ((self: DateTime.DateTime, that: DateTime.DateTime) => Duration.Duration);
-/**
- * Transforms a `Duration` by converting it to a numeric `unit`, applying `map`,
- * then converting back.
- *
- * Lets you operate on a duration in whatever unit is convenient — round it to
- * whole minutes, halve its seconds, floor its days — without juggling
- * conversions by hand. The `map` callback receives the duration expressed as a
- * `number` of `unit`s and returns the new count.
- *
- * @example
- * ```ts
- * import { Duration, Number, pipe } from "effect"
- * import { DurationX } from "@nunofyobiz/effect-extras"
- *
- * // data-first: halve a 4-second duration
- * assert.deepStrictEqual(
- *   DurationX.mapAsUnit(Duration.seconds(4), "second", Number.divideUnsafe(2)),
- *   Duration.seconds(2),
- * )
- *
- * // data-last (piped)
- * assert.deepStrictEqual(
- *   pipe(
- *     Duration.minutes(10),
- *     DurationX.mapAsUnit("minute", (minutes) => minutes + 5),
- *   ),
- *   Duration.minutes(15),
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const mapAsUnit: ((unit: Duration.Unit, map: (numberOfUnits: number) => number) => (duration: Duration.Duration) => Duration.Duration) & ((duration: Duration.Duration, unit: Duration.Unit, map: (numberOfUnits: number) => number) => Duration.Duration);
-
-declare const DurationX_diff: typeof diff;
-declare const DurationX_mapAsUnit: typeof mapAsUnit;
-declare namespace DurationX {
-  export { DurationX_diff as diff, DurationX_mapAsUnit as mapAsUnit };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Effect` module.
- *
- * @since 0.0.0
- */
-
-/**
- * Flattens an `Effect` that succeeds with an `Option` into an `Effect` that
- * fails with `onNone()` when the `Option` is `None`.
- *
- * When the wrapped `Option` is `Some(value)` the effect succeeds with `value`;
- * when it is `None` the effect fails with the error produced by the `onNone`
- * thunk. An existing failure of the source effect is preserved untouched, so the
- * result's error channel is the union of the original error and the `None`
- * error.
- *
- * @example
- * ```ts
- * import { Effect, Option, Result } from "effect"
- * import { EffectX } from "@nunofyobiz/effect-extras"
- *
- * const some = EffectX.flattenOption(
- *   Effect.succeed(Option.some(1)),
- *   () => "missing",
- * )
- * assert.deepStrictEqual(Effect.runSync(Effect.result(some)), Result.succeed(1))
- *
- * const none = EffectX.flattenOption(
- *   Effect.succeed(Option.none<number>()),
- *   () => "missing",
- * )
- * assert.deepStrictEqual(
- *   Effect.runSync(Effect.result(none)),
- *   Result.fail("missing"),
- * )
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const flattenOption: (<A, E1, E2, R>(onNone: () => E2) => (effect: Effect.Effect<Option.Option<A>, E1, R>) => Effect.Effect<A, E1 | E2, R>) & (<A, E1, E2, R>(effect: Effect.Effect<Option.Option<A>, E1, R>, onNone: () => E2) => Effect.Effect<A, E1 | E2, R>);
-/**
- * Converts an `Option` to an `Effect`, mapping the `None` case to a caller-chosen
- * error via the `onNone` thunk.
- *
- * Equivalent to `Effect.mapError(Effect.fromOption(option), onNone)`: it bridges
- * the `NoSuchElementError` that `Effect.fromOption` produces to the caller's own
- * error type, so callers never have to handle `NoSuchElementError`. This fills
- * the v4 gap where `Effect.mapError` no longer accepts an `Option` directly —
- * instead of
- * `pipe(option, Effect.fromOption, Effect.mapError(() => new MyError()))`, write
- * `pipe(option, EffectX.fromOptionOrElse(() => new MyError()))`. The `onNone`
- * thunk runs only when the `Option` is `None`.
- *
- * @example
- * ```ts
- * import { Effect, Option, Result, pipe } from "effect"
- * import { EffectX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * const some = EffectX.fromOptionOrElse(Option.some(42), () => "missing")
- * assert.deepStrictEqual(Effect.runSync(Effect.result(some)), Result.succeed(42))
- *
- * // data-last (piped) — None maps to the chosen error
- * const none = pipe(
- *   Option.none<number>(),
- *   EffectX.fromOptionOrElse(() => "missing"),
- * )
- * assert.deepStrictEqual(
- *   Effect.runSync(Effect.result(none)),
- *   Result.fail("missing"),
- * )
- * ```
- *
- * @category conversions
- * @since 0.0.0
- */
-declare const fromOptionOrElse: {
-    <E>(onNone: () => E): <A>(option: Option.Option<A>) => Effect.Effect<A, E>;
-    <A, E>(option: Option.Option<A>, onNone: () => E): Effect.Effect<A, E>;
-};
-/**
- * Repeatedly calls a synchronous `try` thunk until its result satisfies the
- * `until` refinement, sleeping `sleepDuration` between attempts and failing with
- * a `TimeoutError` once `maxDuration` elapses.
- *
- * The thunk is evaluated immediately; if its first result already passes the
- * refinement the effect succeeds without any delay. Otherwise it polls on the
- * `sleepDuration` interval (defaulting to 200ms — the threshold below which a
- * delay reads as "instant" to a user) until either the predicate holds (the
- * effect succeeds with the narrowed `B` value) or `maxDuration` is exceeded (the
- * effect fails with a `Cause.TimeoutError`). Use it to await an external,
- * non-effectful condition such as a flag flipped by a callback.
- *
- * @example
- * ```ts
- * import { Duration, Effect } from "effect"
- * import { EffectX } from "@nunofyobiz/effect-extras"
- *
- * // First attempt already matches, so it resolves immediately.
- * const effect = EffectX.tryUntil({
- *   try: () => 1,
- *   until: (value: number): value is number => value === 1,
- *   sleepDuration: Duration.millis(100),
- *   maxDuration: Duration.seconds(1),
- * })
- *
- * assert.deepStrictEqual(Effect.runSync(effect), 1)
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const tryUntil: <A, B extends A>({ try: doTry, until: isDone, sleepDuration, maxDuration, }: {
-    try: () => A;
-    until: Predicate.Refinement<A, B>;
-    sleepDuration?: Duration.Duration;
-    maxDuration: Duration.Duration;
-}) => Effect.Effect<B, Cause.TimeoutError, never>;
-
-declare const EffectX_flattenOption: typeof flattenOption;
-declare const EffectX_fromOptionOrElse: typeof fromOptionOrElse;
-declare const EffectX_tryUntil: typeof tryUntil;
-declare namespace EffectX {
-  export { EffectX_flattenOption as flattenOption, EffectX_fromOptionOrElse as fromOptionOrElse, EffectX_tryUntil as tryUntil };
-}
-
-/**
- * Helpers for decoding `FormData` with Effect `Schema`.
- *
- * @since 0.0.0
- */
-
-/**
- * Decodes a `FormData` into a typed value using a `Schema`, throwing on
- * validation failure.
- *
- * Built on v4's native `Schema.fromFormData`, which first parses the `FormData`
- * entries into a nested tree record (bracket-path notation is supported) and then
- * decodes that tree with the provided inner schema. For schemas with non-string
- * fields (for example `Schema.Int`), wrap the inner schema in
- * `Schema.toCodecStringTree(schema, { keepDeclarations: true })` so the
- * string → number/boolean coercion happens. Usable only with schemas that have
- * no decoding services — this is enforced at the type level via
- * `S["DecodingServices"] = never` — and it throws synchronously when the input
- * fails validation.
- *
- * @example
- * ```ts
- * import { Schema } from "effect"
- * import { FormDataX } from "@nunofyobiz/effect-extras"
- *
- * const formData = new FormData()
- * formData.append("name", "John")
- * formData.append("age", "30")
- *
- * const result = FormDataX.decodeSync(
- *   formData,
- *   Schema.Struct({ name: Schema.String, age: Schema.NumberFromString }),
- * )
- *
- * assert.deepStrictEqual(result, { name: "John", age: 30 })
- * ```
- *
- * @category conversions
- * @since 0.0.0
- */
-declare const decodeSync: {
-    <S extends Schema.Top & {
-        readonly DecodingServices: never;
-    }>(formData: FormData, schema: S): S["Type"];
-    <S extends Schema.Top & {
-        readonly DecodingServices: never;
-    }>(schema: S): (formData: FormData) => S["Type"];
-};
-
-declare const FormDataX_decodeSync: typeof decodeSync;
-declare namespace FormDataX {
-  export { FormDataX_decodeSync as decodeSync };
-}
-
-/**
- * Like `Map.prototype.get`, but when the key is absent it stores the computed
- * fallback at that key and returns it. Mutates the input map in place.
- *
- * Use it for memoization-style caches where a miss should both populate the map
- * and yield the value in one step. Throws if the resolved value is nullish (only
- * possible when `fallbackIfNotFound` returns `null`/`undefined` for a value type
- * that admits them — treated as a programmer error). Supports both data-first and
- * data-last (pipeable) call styles.
- *
- * @example
- * ```ts
- * import { MapX } from "@nunofyobiz/effect-extras"
- * import { pipe } from "effect"
- *
- * // Miss: stores the fallback and returns it (data-first)
- * const map = new Map<string, number>()
- * assert.deepStrictEqual(MapX.getOrElseSetGet(map, "a", () => 1), 1)
- * assert.deepStrictEqual(map.get("a"), 1)
- *
- * // Hit: returns the existing value, fallback is ignored (data-last)
- * assert.deepStrictEqual(
- *   pipe(map, MapX.getOrElseSetGet("a", () => 99)),
- *   1
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const getOrElseSetGet: (<K, V>(key: K, fallbackIfNotFound: () => V) => (map: Map<K, V>) => V) & (<K, V>(map: Map<K, V>, key: K, fallbackIfNotFound: () => V) => V);
-
-declare const MapX_getOrElseSetGet: typeof getOrElseSetGet;
-declare namespace MapX {
-  export { MapX_getOrElseSetGet as getOrElseSetGet };
-}
-
-/**
- * Helpers for working with non-nullable values.
- *
- * @since 0.0.0
- */
-
-/**
- * Returns `value` narrowed to `NonNullable<A>`, throwing an `Error` if it is
- * `null` or `undefined`.
- *
- * Use it at trusted boundaries where a value is known to be present but typed as
- * nullable, turning a silent `undefined` into a loud failure. An optional
- * `variableName` is woven into the thrown message to aid debugging. This is the
- * function re-exported as `nn` from the module barrel, a terse shorthand handy
- * inside string interpolations.
- *
- * @example
- * ```ts
- * import { NonNullableX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(NonNullableX.fromNullableOrThrow("value"), "value")
- *
- * assert.throws(
- *   () => NonNullableX.fromNullableOrThrow(null, "varName"),
- *   /Value is nullable: null \(variable name: varName\)/
- * )
- * ```
- *
- * @category unsafe
- * @since 0.0.0
- */
-declare const fromNullableOrThrow: <A>(value: A, variableName?: string) => NonNullable<A>;
-/**
- * Branches on whether `value` is nullish, passing the value narrowed to
- * `NonNullable<A>` to the `whenNotNullable` handler.
- *
- * A nullable-aware sibling of `Match.value`: it folds a present-or-absent value
- * into a single `B` without an `if`/`else` or a manual `!= null` check. Note that
- * falsy-but-present values (`""`, `0`, `false`) take the `whenNotNullable`
- * branch — only `null` and `undefined` are treated as absent. Supports both
- * data-first and data-last (pipeable) call styles.
- *
- * @example
- * ```ts
- * import { NonNullableX } from "@nunofyobiz/effect-extras"
- * import { pipe } from "effect"
- *
- * // Data-first — present value flows through narrowed
- * assert.deepStrictEqual(
- *   NonNullableX.match("value", {
- *     whenNullable: () => "nullable",
- *     whenNotNullable: (value) => value
- *   }),
- *   "value"
- * )
- *
- * // Data-last — null takes the whenNullable branch
- * assert.deepStrictEqual(
- *   pipe(
- *     null,
- *     NonNullableX.match({
- *       whenNullable: () => "nullable",
- *       whenNotNullable: (value) => value
- *     })
- *   ),
- *   "nullable"
- * )
- * ```
- *
- * @category pattern matching
- * @since 0.0.0
- */
-declare const match: (<A, B>(handlers: {
-    whenNullable: () => B;
-    whenNotNullable: (value: NonNullable<A>) => B;
-}) => (value: A) => B) & (<A, B>(value: A, handlers: {
-    whenNullable: () => B;
-    whenNotNullable: (value: NonNullable<A>) => B;
-}) => B);
-/**
- * Applies `map` to `a` only when it is non-nullish, passing nullish inputs
- * through unchanged.
- *
- * This is the nullable-preserving map: a present value is transformed to `B`,
- * while `null` stays `null` and `undefined` stays `undefined`, so nullability is
- * carried through the transformation. Supports both data-first and data-last
- * (pipeable) call styles.
- *
- * @example
- * ```ts
- * import { NonNullableX } from "@nunofyobiz/effect-extras"
- * import { pipe } from "effect"
- *
- * // Data-first — present value is transformed
- * assert.deepStrictEqual(NonNullableX.map(1, (v: number) => v + 1), 2)
- *
- * // Data-last — nullish passes through unchanged
- * const value: number | null = null
- * assert.deepStrictEqual(
- *   pipe(
- *     value,
- *     NonNullableX.map<number | null, number>((v) => v + 1)
- *   ),
- *   null
- * )
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const map: (<A, B>(map: (a: NonNullable<A>) => B) => (a: A) => B | (null & A) | (undefined & A)) & (<A, B>(a: A, map: (a: NonNullable<A>) => B) => B | (null & A) | (undefined & A));
-/**
- * Lifts a total function `(a: A) => B` into one that tolerates nullish input,
- * applying it to present values and passing `null`/`undefined` through unchanged.
- *
- * Where `map` operates on a value, `lift` transforms the function itself,
- * yielding a reusable `(a: A | null | undefined) => B | null | undefined` you can
- * drop into a `pipe`. Use it to adapt a plain transform to a nullable pipeline
- * without wrapping each call site.
- *
- * @example
- * ```ts
- * import { NonNullableX } from "@nunofyobiz/effect-extras"
- * import { Number, pipe } from "effect"
- *
- * const addOne = NonNullableX.lift(Number.sum(1))
- *
- * assert.deepStrictEqual(pipe(1, addOne), 2)
- * assert.deepStrictEqual(pipe(null, addOne), null)
- * assert.deepStrictEqual(pipe(undefined, addOne), undefined)
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const lift: <A, B>(map: (a: A) => B) => (a: A | null | undefined) => B | null | undefined;
-/**
- * Extends an `Order.Order<A>` to an `Order.Order<A | null>`, deciding where
- * `null` sorts relative to present values via the `behavior` argument.
- *
- * Pass `"value-null"` to push `null`s to the end and `"null-value"` to pull them
- * to the front; two present values fall back to the wrapped order. Use it to sort
- * collections that mix real values with gaps without a bespoke comparator.
- * Supports both data-first and data-last (pipeable) call styles.
- *
- * @example
- * ```ts
- * import { NonNullableX } from "@nunofyobiz/effect-extras"
- * import { Array, Order, pipe } from "effect"
- *
- * // "value-null" — nulls sorted last
- * assert.deepStrictEqual(
- *   pipe(
- *     [null, 1, 3, null, 2],
- *     Array.sort(NonNullableX.nullableOrder(Order.Number, "value-null"))
- *   ),
- *   [1, 2, 3, null, null]
- * )
- *
- * // "null-value" — nulls sorted first (data-last)
- * assert.deepStrictEqual(
- *   pipe(
- *     [null, 1, 3, null, 2],
- *     Array.sort(pipe(Order.Number, NonNullableX.nullableOrder("null-value")))
- *   ),
- *   [null, null, 1, 2, 3]
- * )
- * ```
- *
- * @category ordering
- * @since 0.0.0
- */
-declare const nullableOrder: ((behavior: "value-null" | "null-value") => <A>(order: Order.Order<A>) => Order.Order<A | null>) & (<A>(order: Order.Order<A>, behavior: "value-null" | "null-value") => Order.Order<A | null>);
-
-declare const NonNullableX_fromNullableOrThrow: typeof fromNullableOrThrow;
-declare const NonNullableX_lift: typeof lift;
-declare const NonNullableX_map: typeof map;
-declare const NonNullableX_match: typeof match;
-declare const NonNullableX_nullableOrder: typeof nullableOrder;
-declare namespace NonNullableX {
-  export { NonNullableX_fromNullableOrThrow as fromNullableOrThrow, NonNullableX_lift as lift, NonNullableX_map as map, NonNullableX_match as match, NonNullableX_nullableOrder as nullableOrder };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Number` module.
- *
- * @since 0.0.0
- */
-
-/**
- * Computes the logarithm of `number` in the given `base`, throwing when the
- * inputs fall outside the domain of `log`.
- *
- * Throws when `number <= 0`, when `base` is `<= 0` or `1`, or when `number` and
- * `base` sit on opposite sides of `1` (a fractional base with `number >= 1`, or
- * a base `>= 1` with `number < 1`) — cases where the real logarithm is
- * undefined or non-finite. Reach for it only when the inputs are already known
- * to be valid.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { NumberX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(NumberX.unsafeLogBase(8, 2), 3)
- * assert.deepStrictEqual(NumberX.unsafeLogBase(100, 10), 2)
- *
- * // data-last (piped)
- * assert.deepStrictEqual(pipe(8, NumberX.unsafeLogBase(2)), 3)
- *
- * // throws outside the domain of log
- * assert.throws(() => NumberX.unsafeLogBase(0, 2))
- * ```
- *
- * @category unsafe
- * @since 0.0.0
- */
-declare const unsafeLogBase: ((base: number) => (number: number) => number) & ((number: number, base: number) => number);
-/**
- * Expresses `numerator` as a percentage of `total`, throwing on division by
- * zero.
- *
- * Returns `(numerator / total) * 100`. When `total` is `0` the percentage is
- * undefined, so this throws rather than returning `Infinity` or `NaN` — use it
- * only when `total` is known to be non-zero.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { NumberX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(NumberX.unsafeToPercentOf(1, 2), 50)
- * assert.deepStrictEqual(NumberX.unsafeToPercentOf(2, 1), 200)
- *
- * // data-last (piped)
- * assert.deepStrictEqual(pipe(1, NumberX.unsafeToPercentOf(2)), 50)
- *
- * // throws on division by zero
- * assert.throws(() => NumberX.unsafeToPercentOf(1, 0))
- * ```
- *
- * @category unsafe
- * @since 0.0.0
- */
-declare const unsafeToPercentOf: ((total: number) => (numerator: number) => number) & ((numerator: number, total: number) => number);
-/**
- * Formats `number` with a fixed number of decimal places, returning a `string`.
- *
- * A pipeable wrapper around `Number.prototype.toFixed` — the result is rounded
- * (not truncated) to `numberDigits` decimals and always carries exactly that
- * many digits after the point.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { NumberX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(NumberX.toFixed(3.236242, 2), "3.24")
- *
- * // data-last (piped)
- * assert.deepStrictEqual(pipe(3.236242, NumberX.toFixed(0)), "3")
- * ```
- *
- * @category conversions
- * @since 0.0.0
- */
-declare const toFixed: ((numberDigits: number) => (number: number) => string) & ((number: number, numberDigits: number) => string);
-/**
- * Rounds `number` to a fixed number of decimal places, returning a `number`.
- *
- * Unlike {@link toFixed}, the result stays a `number` (no trailing zeroes) — it
- * formats via `toFixed` then parses back, which sidesteps the usual
- * floating-point rounding artifacts. See
- * https://stackoverflow.com/a/29494612/22875620.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { NumberX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(NumberX.roundToDigits(3.236242, 2), 3.24)
- *
- * // data-last (piped)
- * assert.deepStrictEqual(pipe(3.736242, NumberX.roundToDigits(0)), 4)
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const roundToDigits: ((numberDigits: number) => (number: number) => number) & ((number: number, numberDigits: number) => number);
-/**
- * Renders `number` as a `string`, left-padded with zeroes to at least
- * `numberDigits` characters.
- *
- * If the number's string representation is already as long as (or longer than)
- * `numberDigits`, it is returned unchanged.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { NumberX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(NumberX.padLeftZeroes(1, 3), "001")
- *
- * // longer than the target width is returned unchanged
- * assert.deepStrictEqual(NumberX.padLeftZeroes(1000, 3), "1000")
- *
- * // data-last (piped)
- * assert.deepStrictEqual(pipe(10, NumberX.padLeftZeroes(3)), "010")
- * ```
- *
- * @category conversions
- * @since 0.0.0
- */
-declare const padLeftZeroes: ((numberDigits: number) => (number: number) => string) & ((number: number, numberDigits: number) => string);
-/**
- * Converts a `0`-indexed value to its `1`-indexed rank by adding `1`.
- *
- * Handy for presentation where humans count from one (e.g. the element at
- * index `0` is shown as "item 1").
- *
- * @example
- * ```ts
- * import { NumberX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(NumberX.indexToRank(0), 1)
- * assert.deepStrictEqual(NumberX.indexToRank(4), 5)
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const indexToRank: (index: number) => number;
-/**
- * Converts a `0`-indexed column number into its bijective base-26 spreadsheet
- * label (`A`, `B`, …, `Z`, `AA`, `AB`, …).
- *
- * Returns `None` for a negative `index`; every non-negative index maps to a
- * `Some` label. Indexing is `0`-based here, so `0` is `"A"` and `25` is `"Z"`,
- * unlike the `1`-based numbering shown in most spreadsheet references.
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- * import { NumberX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(NumberX.indexToExcel(0), Option.some("A"))
- * assert.deepStrictEqual(NumberX.indexToExcel(26), Option.some("AA"))
- * assert.deepStrictEqual(NumberX.indexToExcel(-1), Option.none())
- * ```
- *
- * @category conversions
- * @since 0.0.0
- */
-declare const indexToExcel: (index: number) => Option.Option<string>;
-
-declare const NumberX_indexToExcel: typeof indexToExcel;
-declare const NumberX_indexToRank: typeof indexToRank;
-declare const NumberX_padLeftZeroes: typeof padLeftZeroes;
-declare const NumberX_roundToDigits: typeof roundToDigits;
-declare const NumberX_toFixed: typeof toFixed;
-declare const NumberX_unsafeLogBase: typeof unsafeLogBase;
-declare const NumberX_unsafeToPercentOf: typeof unsafeToPercentOf;
-declare namespace NumberX {
-  export { NumberX_indexToExcel as indexToExcel, NumberX_indexToRank as indexToRank, NumberX_padLeftZeroes as padLeftZeroes, NumberX_roundToDigits as roundToDigits, NumberX_toFixed as toFixed, NumberX_unsafeLogBase as unsafeLogBase, NumberX_unsafeToPercentOf as unsafeToPercentOf };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Option` module.
- *
- * @since 0.0.0
- */
-
-/**
- * Combines two `Option`s into an `Option` of a tuple, succeeding only when both
- * are `Some`.
- *
- * Returns `Some([a, b])` when both inputs are `Some`, and `None` if either is
- * `None`. Useful when an operation needs two optional values present at once.
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- * import { OptionX } from "@nunofyobiz/effect-extras"
- *
- * // Both Some — succeeds with the pair
- * assert.deepStrictEqual(
- *   OptionX.tupleOf(Option.some(1), Option.some("a")),
- *   Option.some([1, "a"]),
- * )
- *
- * // Either None collapses to None
- * assert.deepStrictEqual(
- *   OptionX.tupleOf(Option.some(1), Option.none()),
- *   Option.none(),
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const tupleOf: (<A>(a: Option.Option<A>) => <B>(b: Option.Option<B>) => Option.Option<[A, B]>) & (<A, B>(a: Option.Option<A>, b: Option.Option<B>) => Option.Option<[A, B]>);
-/**
- * Runs a side effect with the value of an `Option` when it is `Some`, doing
- * nothing when it is `None`.
- *
- * A shorthand for the "if Some, do something" branch of `Option.match` where the
- * `None` case is a no-op. The callback's return value is ignored — `ifSome`
- * always returns `void`.
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- * import { OptionX } from "@nunofyobiz/effect-extras"
- *
- * const log: Array<number> = []
- * OptionX.ifSome(Option.some(1), (value) => log.push(value))
- * OptionX.ifSome(Option.none<number>(), (value) => log.push(value))
- *
- * assert.deepStrictEqual(log, [1])
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const ifSome: (<A>(ifSome: (value: A) => void) => (self: Option.Option<A>) => void) & (<A>(self: Option.Option<A>, ifSome: (value: A) => void) => void);
-/**
- * Runs a side effect with the value of an `Option` when it is `Some`, then
- * returns the `Option` unchanged.
- *
- * The pass-through counterpart of {@link ifSome}: it taps into a `Some` value
- * (for logging, metrics, debugging) without breaking a `pipe` chain, since it
- * returns the original `Option`. For `None` it is a no-op.
- *
- * @example
- * ```ts
- * import { Option, pipe } from "effect"
- * import { OptionX } from "@nunofyobiz/effect-extras"
- *
- * const log: Array<number> = []
- * const result = pipe(
- *   Option.some(1),
- *   OptionX.inspectSome((value) => log.push(value)),
- *   Option.map((value) => value + 1),
- * )
- *
- * assert.deepStrictEqual(result, Option.some(2))
- * assert.deepStrictEqual(log, [1])
- * ```
- *
- * @category sequencing
- * @since 0.0.0
- */
-declare const inspectSome: (<A>(function_: (value: A) => void) => (self: Option.Option<A>) => Option.Option<A>) & (<A>(self: Option.Option<A>, function_: (value: A) => void) => Option.Option<A>);
-/**
- * Normalizes a possibly-nullish `Option` into a plain `Option`, mapping `null`
- * and `undefined` to `None`.
- *
- * Handy at boundaries where an `Option` value might itself arrive as `null` or
- * `undefined` (for example an optional field that holds an `Option`): the result
- * is always a well-formed `Option`, never `null`/`undefined`.
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- * import { OptionX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(OptionX.fromNullableOption(Option.some(1)), Option.some(1))
- * assert.deepStrictEqual(OptionX.fromNullableOption(null), Option.none())
- * assert.deepStrictEqual(OptionX.fromNullableOption(undefined), Option.none())
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const fromNullableOption: <A>(nullableOption: Option.Option<A> | null | undefined) => Option.Option<A>;
-/**
- * Maps the value of an `Option` when it is `Some`, returning `null` when it is
- * `None`.
- *
- * A shorthand for `pipe(self, Option.map(map), Option.getOrNull)`. The `null`
- * fallback makes it especially convenient in JSX/React, where rendering `null`
- * skips output — `mapSomeOrNull(value, (v) => render(v))` replaces a more verbose
- * `Option.match` with `onNone: () => null`.
- *
- * @example
- * ```ts
- * import { Option, pipe } from "effect"
- * import { OptionX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(OptionX.mapSomeOrNull(Option.some(1), (v) => v + 1), 2)
- *
- * // None maps to null
- * assert.deepStrictEqual(
- *   OptionX.mapSomeOrNull(Option.none<number>(), (v) => v + 1),
- *   null,
- * )
- *
- * // data-last (piped)
- * assert.deepStrictEqual(
- *   pipe(Option.some(1), OptionX.mapSomeOrNull((v) => v + 1)),
- *   2,
- * )
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const mapSomeOrNull: (<A, B>(map: (a: A) => B) => (self: Option.Option<A>) => B | null) & (<A, B>(self: Option.Option<A>, map: (a: A) => B) => B | null);
-/**
- * Maps the value of an `Option` when it is `Some`, returning `undefined` when it
- * is `None`.
- *
- * The `undefined`-returning counterpart of {@link mapSomeOrNull}: a shorthand for
- * `pipe(self, Option.map(map), Option.getOrUndefined)`. Reach for it when the
- * consuming API expects `undefined` rather than `null` for "absent" (for example
- * an optional prop or a value spread into an object).
- *
- * @example
- * ```ts
- * import { Option, pipe } from "effect"
- * import { OptionX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(
- *   OptionX.mapSomeOrUndefined(Option.some(1), (v) => v + 1),
- *   2,
- * )
- *
- * // None maps to undefined
- * assert.deepStrictEqual(
- *   OptionX.mapSomeOrUndefined(Option.none<number>(), (v) => v + 1),
- *   undefined,
- * )
- *
- * // data-last (piped)
- * assert.deepStrictEqual(
- *   pipe(Option.some(1), OptionX.mapSomeOrUndefined((v) => v + 1)),
- *   2,
- * )
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const mapSomeOrUndefined: (<A, B>(map: (a: A) => B) => (self: Option.Option<A>) => B | undefined) & (<A, B>(self: Option.Option<A>, map: (a: A) => B) => B | undefined);
-
-declare const OptionX_fromNullableOption: typeof fromNullableOption;
-declare const OptionX_ifSome: typeof ifSome;
-declare const OptionX_inspectSome: typeof inspectSome;
-declare const OptionX_mapSomeOrNull: typeof mapSomeOrNull;
-declare const OptionX_mapSomeOrUndefined: typeof mapSomeOrUndefined;
-declare const OptionX_tupleOf: typeof tupleOf;
-declare namespace OptionX {
-  export { OptionX_fromNullableOption as fromNullableOption, OptionX_ifSome as ifSome, OptionX_inspectSome as inspectSome, OptionX_mapSomeOrNull as mapSomeOrNull, OptionX_mapSomeOrUndefined as mapSomeOrUndefined, OptionX_tupleOf as tupleOf };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Order` module.
- *
- * @since 0.0.0
- */
-
-/**
- * Builds an `Order.Order` for an enum-like set of values from an explicit rank
- * table, sorting each value by its assigned numeric rank.
- *
- * Use it when a union of string (or other `PropertyKey`) literals has a natural
- * priority that isn't its alphabetical order — pass a record mapping every
- * member to a rank and the resulting order sorts ascending by that rank.
- *
- * @example
- * ```ts
- * import { OrderX } from "@nunofyobiz/effect-extras"
- * import { Array } from "effect"
- *
- * const byAge = OrderX.rankedEnum({ child: 0, parent: 1, grandparent: 2 })
- *
- * assert.deepStrictEqual(
- *   Array.sort(["parent", "grandparent", "child"], byAge),
- *   ["child", "parent", "grandparent"]
- * )
- * ```
- *
- * @category ordering
- * @since 0.0.0
- */
-declare const rankedEnum: <const A extends PropertyKey>(ranks: Record<A, number>) => Order.Order<A>;
-
-declare const OrderX_rankedEnum: typeof rankedEnum;
-declare namespace OrderX {
-  export { OrderX_rankedEnum as rankedEnum };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Predicate` module.
- *
- * @since 0.0.0
- */
-
-/**
- * Runs a refinement against `value` and branches on the result, passing the
- * narrowed value to the `whenTrue` handler.
- *
- * It pairs a `Predicate.Refinement<A, B>` with two continuations so the success
- * branch receives `value` already narrowed to `B`, replacing an `if`/`else` that
- * would otherwise re-check or cast. Supports both data-first and data-last
- * (pipeable) call styles.
- *
- * @example
- * ```ts
- * import { PredicateX } from "@nunofyobiz/effect-extras"
- * import { Predicate, pipe } from "effect"
- *
- * // Data-first
- * assert.deepStrictEqual(
- *   PredicateX.matchRefine("hello", Predicate.isString, {
- *     whenTrue: (value) => `String: ${value}`,
- *     whenFalse: () => "Not a string"
- *   }),
- *   "String: hello"
- * )
- *
- * // Data-last (pipeable)
- * assert.deepStrictEqual(
- *   pipe(
- *     42,
- *     PredicateX.matchRefine(Predicate.isString, {
- *       whenTrue: (value) => `String: ${value}`,
- *       whenFalse: () => "Not a string"
- *     })
- *   ),
- *   "Not a string"
- * )
- * ```
- *
- * @category pattern matching
- * @since 0.0.0
- */
-declare const matchRefine: (<A, B extends A, C>(predicate: Predicate.Refinement<A, B>, handlers: {
-    whenFalse: () => C;
-    whenTrue: (value: B) => C;
-}) => (value: A) => C) & (<A, B extends A, C>(value: A, predicate: Predicate.Refinement<A, B>, handlers: {
-    whenFalse: () => C;
-    whenTrue: (value: B) => C;
-}) => C);
-/**
- * Refines an `unknown` value to a non-empty `string`, returning `true` only when
- * the value is present, is a `string`, and has at least one character.
- *
- * This is the compound guard the repo's conventions call for: it folds
- * `Predicate.isNotNullish`, `Predicate.isString`, and `String.isNonEmpty` into a
- * single reusable refinement so call sites get `value is string` narrowing
- * without restating the three checks.
- *
- * @example
- * ```ts
- * import { PredicateX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(PredicateX.isNonEmptyString("hello"), true)
- * assert.deepStrictEqual(PredicateX.isNonEmptyString(""), false)
- * assert.deepStrictEqual(PredicateX.isNonEmptyString(null), false)
- * assert.deepStrictEqual(PredicateX.isNonEmptyString(123), false)
- * ```
- *
- * @category refinements
- * @since 0.0.0
- */
-declare function isNonEmptyString(value: unknown): value is string;
-
-declare const PredicateX_isNonEmptyString: typeof isNonEmptyString;
-declare const PredicateX_matchRefine: typeof matchRefine;
-declare namespace PredicateX {
-  export { PredicateX_isNonEmptyString as isNonEmptyString, PredicateX_matchRefine as matchRefine };
-}
-
-/**
- * Helpers for working with native `Promise`s.
- *
- * @since 0.0.0
- */
-/**
- * Discards the resolved value of a `Promise`, returning a `Promise<void>` that
- * resolves once the original settles.
- *
- * Useful when you await a promise only for its side effect and want the result
- * type to reflect that nothing meaningful is produced — for example when an API
- * expects a `Promise<void>` or when narrowing a value-bearing promise to keep
- * call sites from accidentally depending on the resolved value. A rejection of
- * the original promise still propagates.
- *
- * @example
- * ```ts
- * import { PromiseX } from "@nunofyobiz/effect-extras"
- *
- * const run = async (): Promise<void> => {
- *   const result = await PromiseX.asVoid(Promise.resolve(42))
- *   assert.deepStrictEqual(result, undefined)
- * }
- *
- * void run()
- * ```
- *
- * @category conversions
- * @since 0.0.0
- */
-declare const asVoid: <T>(promise: Promise<T>) => Promise<void>;
-
-declare const PromiseX_asVoid: typeof asVoid;
-declare namespace PromiseX {
-  export { PromiseX_asVoid as asVoid };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Record` module.
- *
- * @since 0.0.0
- */
-
-/**
- * Returns `true` when `record` has at least one entry, narrowing it to a
- * known-non-empty `Record`.
- *
- * The negation of `Record.isEmptyRecord`, packaged as a type guard so it reads
- * naturally at call sites that want to branch on "this record has something in
- * it" without a manual `!Record.isEmptyRecord(...)`.
- *
- * @example
- * ```ts
- * import { RecordX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(RecordX.isNonEmptyRecord({ a: 1 }), true)
- * assert.deepStrictEqual(RecordX.isNonEmptyRecord({}), false)
- * ```
- *
- * @category guards
- * @since 0.0.0
- */
-declare const isNonEmptyRecord: <K extends PropertyKey, V>(record: Record<K, V>) => record is Record<K, V>;
-/**
- * Modifies the value at `key` in `self` with `f`, leaving the record unchanged
- * if the key doesn't exist.
- *
- * v4's `Record.modify` returns `Option<Record>` — `None` when the key is
- * absent. This helper picks the "do nothing if absent" semantics that v3's
- * `Record.modify` had implicitly, and that most call sites assume. The modifier
- * is never invoked when the key is missing.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { RecordX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(
- *   RecordX.modifyIfExists({ a: 1, b: 2 }, "b", (n) => n * 10),
- *   { a: 1, b: 20 },
- * )
- *
- * // a missing key leaves the record untouched
- * const counts: Record<string, number> = { a: 1, b: 2 }
- * assert.deepStrictEqual(
- *   RecordX.modifyIfExists(counts, "missing", (n) => n + 1),
- *   { a: 1, b: 2 },
- * )
- *
- * // data-last (pipeable)
- * assert.deepStrictEqual(
- *   pipe({ a: 1, b: 2 }, RecordX.modifyIfExists("a", (n) => n * 10)),
- *   { a: 10, b: 2 },
- * )
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const modifyIfExists: {
-    <K extends string, A>(key: NoInfer<K>, f: (a: A) => A): (self: Record<K, A>) => Record<K, A>;
-    <K extends string, A>(self: Record<K, A>, key: NoInfer<K>, f: (a: A) => A): Record<K, A>;
-};
-/**
- * Returns the smallest value of `record` (per `order`) that matches
- * `predicate`, narrowed to the refined type `B`, or `Option.none()` if none
- * match.
- *
- * The `Record` counterpart of `ArrayX.takeFirstWhere`: it considers only the
- * record's values, keeps those satisfying `predicate`, and returns the minimum
- * of them by `order`. Keys are ignored entirely.
- *
- * @example
- * ```ts
- * import { Option, Order, pipe } from "effect"
- * import { RecordX } from "@nunofyobiz/effect-extras"
- *
- * const isEven = (n: number): n is number => n % 2 === 0
- *
- * // data-first
- * assert.deepStrictEqual(
- *   RecordX.takeFirstWhere({ a: 3, b: 4, c: 2 }, isEven, Order.Number),
- *   Option.some(2),
- * )
- *
- * // data-last (pipeable); no even values yields None
- * assert.deepStrictEqual(
- *   pipe({ a: 1, b: 3 }, RecordX.takeFirstWhere(isEven, Order.Number)),
- *   Option.none(),
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const takeFirstWhere: (<K extends PropertyKey, A, B extends A>(predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => (record: Record<K, A>) => Option.Option<B>) & (<K extends PropertyKey, A, B extends A>(record: Record<K, A>, predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => Option.Option<B>);
-/**
- * Returns the largest value of `record` (per `order`) that matches `predicate`,
- * narrowed to the refined type `B`, or `Option.none()` if none match.
- *
- * The mirror of {@link takeFirstWhere}: it considers only the record's values,
- * keeps those satisfying `predicate`, and returns the maximum of them by
- * `order`. Keys are ignored entirely.
- *
- * @example
- * ```ts
- * import { Option, Order, pipe } from "effect"
- * import { RecordX } from "@nunofyobiz/effect-extras"
- *
- * const isEven = (n: number): n is number => n % 2 === 0
- *
- * // data-first
- * assert.deepStrictEqual(
- *   RecordX.takeLastWhere({ a: 3, b: 4, c: 2 }, isEven, Order.Number),
- *   Option.some(4),
- * )
- *
- * // data-last (pipeable); no even values yields None
- * assert.deepStrictEqual(
- *   pipe({ a: 1, b: 3 }, RecordX.takeLastWhere(isEven, Order.Number)),
- *   Option.none(),
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const takeLastWhere: (<K extends PropertyKey, A, B extends A>(predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => (record: Record<K, A>) => Option.Option<B>) & (<K extends PropertyKey, A, B extends A>(record: Record<K, A>, predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => Option.Option<B>);
-/**
- * Returns the largest value of `record` according to `order`, wrapped in an
- * `Option` so empty records are handled safely.
- *
- * Sorts the record's values by `order` and takes the last one, yielding
- * `Option.none()` when the record is empty and `Option.some(max)` otherwise.
- * Keys are ignored — only values participate in the ordering.
- *
- * @example
- * ```ts
- * import { Option, Order, pipe } from "effect"
- * import { RecordX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(
- *   RecordX.takeLast({ a: 3, b: 5, c: 1 }, Order.Number),
- *   Option.some(5),
- * )
- *
- * // data-last (pipeable); empty record yields None
- * assert.deepStrictEqual(
- *   pipe({}, RecordX.takeLast(Order.Number)),
- *   Option.none(),
- * )
- * ```
- *
- * @category getters
- * @since 0.0.0
- */
-declare const takeLast: (<K extends PropertyKey, A>(order: Order.Order<A>) => (record: Record<K, A>) => Option.Option<A>) & (<K extends PropertyKey, A>(record: Record<K, A>, order: Order.Order<A>) => Option.Option<A>);
-/**
- * Re-types the keys of a `Record` to a different key type `K2` without touching
- * the runtime value.
- *
- * A purely type-level reinterpretation: the record is returned as-is, but the
- * compiler now treats its keys as `K2` instead of the inferred `K1`. Use it at a
- * boundary where you know the keys conform to a narrower branded or literal key
- * type that TypeScript can't infer from the value alone. It performs no
- * validation — the caller is responsible for the keys actually matching `K2`.
- *
- * @example
- * ```ts
- * import { RecordX } from "@nunofyobiz/effect-extras"
- *
- * type UserId = string & { readonly _brand: "UserId" }
- *
- * const byId: Record<string, number> = { u1: 10, u2: 20 }
- * const branded = RecordX.keysAs<UserId>()(byId)
- *
- * // Same runtime value, keys now seen as `UserId`
- * assert.deepStrictEqual(branded, { u1: 10, u2: 20 })
- * ```
- *
- * @category conversions
- * @since 0.0.0
- */
-declare const keysAs: <K2 extends PropertyKey>() => <K1 extends PropertyKey, V>(record: Record<K1, V>) => Record<K2, V>;
-/**
- * Returns the value at `key` in `record`, throwing an `Error` if the key is
- * absent.
- *
- * The unsafe, get-or-explode counterpart to `Record.get` (which returns an
- * `Option`). The thrown error names the missing key and lists the record's
- * existing keys to aid debugging. Reach for {@link getOrThrowWith} when you need
- * a custom error; prefer `Record.get` whenever absence is a real possibility.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { RecordX } from "@nunofyobiz/effect-extras"
- *
- * const record: Record<string, number> = { a: 1, b: 2 }
- *
- * // data-first
- * assert.deepStrictEqual(RecordX.getOrThrow(record, "a"), 1)
- *
- * // data-last (pipeable)
- * assert.deepStrictEqual(pipe(record, RecordX.getOrThrow("b")), 2)
- *
- * // missing key throws
- * assert.throws(() => RecordX.getOrThrow(record, "missing"))
- * ```
- *
- * @category unsafe
- * @since 0.0.0
- */
-declare const getOrThrow: (<K extends string | symbol>(key: K) => <V>(record: Record<K, V>) => V) & (<K extends string | symbol, V>(record: Record<K, V>, key: K) => V);
-/**
- * Returns the value at `key` in `record`, throwing the result of `onNone(key)`
- * if the key is absent.
- *
- * Like {@link getOrThrow}, but lets the caller supply the thrown value (an
- * `Error`, a string, or any custom failure) computed from the missing key. Use
- * it when the default "key not found" message isn't descriptive enough for the
- * call site.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { RecordX } from "@nunofyobiz/effect-extras"
- *
- * const record: Record<string, number> = { a: 1 }
- * const onNone = (key: string) => new Error(`no ${key}`)
- *
- * // data-first
- * assert.deepStrictEqual(RecordX.getOrThrowWith(record, "a", onNone), 1)
- *
- * // data-last (pipeable)
- * assert.deepStrictEqual(pipe(record, RecordX.getOrThrowWith("a", onNone)), 1)
- *
- * // missing key throws the custom error
- * assert.throws(() => RecordX.getOrThrowWith(record, "missing", onNone))
- * ```
- *
- * @category unsafe
- * @since 0.0.0
- */
-declare const getOrThrowWith: (<K extends string | symbol>(key: K, onNone: (key: K) => unknown) => <V>(record: Record<K, V>) => V) & (<K extends string | symbol, V>(record: Record<K, V>, key: K, onNone: (key: K) => unknown) => V);
-/**
- * Inserts or updates the value at `key`, deriving the new value from the current
- * one via `upsert`.
- *
- * The `upsert` function receives an `Option` of the existing value —
- * `Option.some(value)` when the key is present, `Option.none()` when it's
- * absent — and returns the value to store. This unifies "insert if missing" and
- * "update if present" into a single pass, with `Option.match` as the natural way
- * to handle both cases.
- *
- * @example
- * ```ts
- * import { Option, pipe } from "effect"
- * import { RecordX } from "@nunofyobiz/effect-extras"
- *
- * const bump = Option.match({
- *   onNone: () => 1,
- *   onSome: (n: number) => n + 1,
- * })
- *
- * // data-first: updates an existing entry
- * assert.deepStrictEqual(RecordX.upsert({ a: 1 }, "a", bump), { a: 2 })
- *
- * // data-last (pipeable): inserts a missing entry
- * const counts: Record<string, number> = { a: 1 }
- * assert.deepStrictEqual(pipe(counts, RecordX.upsert("b", bump)), {
- *   a: 1,
- *   b: 1,
- * })
- * ```
- *
- * @category mapping
- * @since 0.0.0
- */
-declare const upsert: (<K extends string | symbol, V>(key: K, upsert: (existingValue: Option.Option<V>) => V) => (record: Record<K, V>) => Record<K, V>) & (<K extends string | symbol, V>(record: Record<K, V>, key: K, upsert: (existingValue: Option.Option<V>) => V) => Record<K, V>);
-/**
- * Indexes an iterable of values into a `Record`, keying each value by the result
- * of `identify`.
- *
- * Builds a lookup table from a collection: every value is stored under the key
- * `identify(value)`. When two values produce the same key the later one wins, so
- * the result holds the last value seen per key. Useful for turning a list of
- * records into a by-id map.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { RecordX } from "@nunofyobiz/effect-extras"
- *
- * const items = [
- *   { id: "a", n: 1 },
- *   { id: "b", n: 2 },
- *   { id: "a", n: 3 }, // wins over the earlier "a"
- * ]
- *
- * // data-first
- * assert.deepStrictEqual(
- *   RecordX.collectBy(items, (item) => item.id),
- *   { a: { id: "a", n: 3 }, b: { id: "b", n: 2 } },
- * )
- *
- * // data-last (pipeable)
- * assert.deepStrictEqual(
- *   pipe(items, RecordX.collectBy((item) => item.id)),
- *   { a: { id: "a", n: 3 }, b: { id: "b", n: 2 } },
- * )
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const collectBy: (<K extends string | symbol, V>(identify: (v: V) => K) => (values: Iterable<V>) => Record<K, V>) & (<K extends string | symbol, V>(values: Iterable<V>, identify: (v: V) => K) => Record<K, V>);
-
-declare const RecordX_collectBy: typeof collectBy;
-declare const RecordX_getOrThrow: typeof getOrThrow;
-declare const RecordX_getOrThrowWith: typeof getOrThrowWith;
-declare const RecordX_isNonEmptyRecord: typeof isNonEmptyRecord;
-declare const RecordX_keysAs: typeof keysAs;
-declare const RecordX_modifyIfExists: typeof modifyIfExists;
-declare const RecordX_takeFirstWhere: typeof takeFirstWhere;
-declare const RecordX_takeLast: typeof takeLast;
-declare const RecordX_takeLastWhere: typeof takeLastWhere;
-declare const RecordX_upsert: typeof upsert;
-declare namespace RecordX {
-  export { RecordX_collectBy as collectBy, RecordX_getOrThrow as getOrThrow, RecordX_getOrThrowWith as getOrThrowWith, RecordX_isNonEmptyRecord as isNonEmptyRecord, RecordX_keysAs as keysAs, RecordX_modifyIfExists as modifyIfExists, RecordX_takeFirstWhere as takeFirstWhere, RecordX_takeLast as takeLast, RecordX_takeLastWhere as takeLastWhere, RecordX_upsert as upsert };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Result` module.
- *
- * @since 0.0.0
- */
-
-/**
- * Lifts an `Option` into a `Result` with a `void` failure: `Some(value)` becomes
- * `Result.succeed(value)` and `None` becomes `Result.failVoid`.
- *
- * Useful in v4 where `Array.filterMap` and `Record.filterMap` expect
- * `Result`-returning predicates (a `Success` keeps the value, a `Failure` drops
- * it); in v3 those APIs accepted `Option`-returning predicates directly:
- *
- * ```ts
- * import { Array } from "effect"
- * import { ResultX } from "@nunofyobiz/effect-extras"
- *
- * declare const items: ReadonlyArray<number>
- * declare const maybeTransform: (item: number) => import("effect").Option.Option<string>
- *
- * // v3: Array.filterMap(items, (item) => maybeTransform(item))
- * // v4:
- * Array.filterMap(items, (item) => ResultX.fromOption(maybeTransform(item)))
- * ```
- *
- * Effect ships `Result.fromOption(option, onNone)` which requires a non-`void`
- * failure value; this helper specializes to the common "drop the item, no error
- * needed" case used by `filterMap`.
- *
- * @example
- * ```ts
- * import { Option, Result } from "effect"
- * import { ResultX } from "@nunofyobiz/effect-extras"
- *
- * assert.deepStrictEqual(
- *   ResultX.fromOption(Option.some(1)),
- *   Result.succeed(1),
- * )
- * assert.deepStrictEqual(
- *   ResultX.fromOption(Option.none<number>()),
- *   Result.failVoid,
- * )
- * ```
- *
- * @category conversions
- * @since 0.0.0
- */
-declare const fromOption: <A>(option: Option.Option<A>) => Result.Result<A, void>;
-
-declare const ResultX_fromOption: typeof fromOption;
-declare namespace ResultX {
-  export { ResultX_fromOption as fromOption };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Schema` module.
- *
- * @since 0.0.0
- */
-
-/**
- * A `Schema` for a non-empty string that is trimmed on both decode and encode.
- *
- * Leading and trailing whitespace is stripped, and the resulting value must be
- * non-empty — so a whitespace-only input (e.g. `"   "`) fails the
- * `NonEmptyString` refinement after trimming. Use it wherever user-supplied text
- * should be normalized and guaranteed to carry content.
- *
- * @example
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { SchemaX } from "@nunofyobiz/effect-extras"
- *
- * const decoded = Effect.runSync(
- *   Schema.decodeEffect(SchemaX.TrimmedNonEmptyString)("  hello  "),
- * )
- * assert.deepStrictEqual(decoded, "hello")
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const TrimmedNonEmptyString: Schema.decodeTo<Schema.toType<Schema.NonEmptyString>, Schema.NonEmptyString, never, never>;
-/**
- * A `Schema` for a URL-safe file path built on top of {@link
- * TrimmedNonEmptyString}.
- *
- * On decode the path is `decodeURIComponent`-ed (percent-escapes are expanded);
- * on encode it is `encodeURIComponent`-ed back into its URL-safe form. The
- * underlying value is also trimmed and required to be non-empty. Use it at the
- * boundary between stored/transmitted encoded paths and the decoded paths your
- * code works with.
- *
- * @example
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { SchemaX } from "@nunofyobiz/effect-extras"
- *
- * // Decoding expands percent-escapes
- * const decoded = Effect.runSync(
- *   Schema.decodeEffect(SchemaX.URLSafeFilePath)("a%2Fb.txt"),
- * )
- * assert.deepStrictEqual(decoded, "a/b.txt")
- *
- * // Encoding produces the URL-safe form
- * const encoded = Effect.runSync(
- *   Schema.encodeEffect(SchemaX.URLSafeFilePath)("a/b.txt"),
- * )
- * assert.deepStrictEqual(encoded, "a%2Fb.txt")
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const URLSafeFilePath: Schema.decodeTo<Schema.toType<Schema.decodeTo<Schema.toType<Schema.NonEmptyString>, Schema.NonEmptyString, never, never>>, Schema.decodeTo<Schema.toType<Schema.NonEmptyString>, Schema.NonEmptyString, never, never>, never, never>;
-/**
- * Transforms a `bigint` `Schema` so its value is clamped to be non-negative,
- * mapping any value below `0n` up to `0n` on both decode and encode.
- *
- * Unlike a refinement that *rejects* negative input, this *coerces* it: a
- * negative `bigint` decodes to `0n` rather than failing. Apply it to a `bigint`
- * schema whenever negative magnitudes are meaningless and should be floored at
- * zero rather than treated as errors.
- *
- * @example
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { SchemaX } from "@nunofyobiz/effect-extras"
- *
- * const NonNegative = SchemaX.nonNegativeBigInt(Schema.BigInt)
- *
- * // Negative values are clamped up to 0n
- * assert.deepStrictEqual(
- *   Effect.runSync(Schema.decodeEffect(NonNegative)(-5n)),
- *   0n,
- * )
- *
- * // Non-negative values pass through unchanged
- * assert.deepStrictEqual(
- *   Effect.runSync(Schema.decodeEffect(NonNegative)(7n)),
- *   7n,
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const nonNegativeBigInt: <S extends Schema.Schema<bigint>>(schema: S) => Schema.decodeTo<Schema.toType<S>, S, never, never>;
-/**
- * Extracts the "constructor input" type of a `Schema` — what `.make({...})`
- * accepts.
- *
- * Differs from `S["Type"]` (the decoded type) in that fields carrying
- * constructor defaults (e.g. an `Overrideable` timestamp) are *optional* in
- * `MakeIn` but *required* in `Type`. Use it in signatures that accept a value to
- * construct, so callers can pass a plain object literal without supplying the
- * defaulted, override-branded fields.
- *
- * @example
- * ```ts
- * import { Schema } from "effect"
- * import { SchemaX } from "@nunofyobiz/effect-extras"
- *
- * const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
- *
- * const input: SchemaX.MakeIn<typeof Person> = { name: "Ada", age: 36 }
- *
- * assert.deepStrictEqual(input, { name: "Ada", age: 36 })
- * ```
- *
- * @category models
- * @since 0.0.0
- */
-type MakeIn<S extends {
-    readonly "~type.make.in": unknown;
-}> = S["~type.make.in"];
-/**
- * Returns a new `Schema.Struct` containing only the named `keys` of `schema`.
- *
- * Restores the v3 ergonomics of `mySchema.pick("a", "b")` — v4 removed the
- * `.pick(...)` method from `Schema.Struct` instances, so this rebuilds it on top
- * of v4's `mapFields` primitive. Each picked field keeps its original schema,
- * including any refinements.
- *
- * @example
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { SchemaX } from "@nunofyobiz/effect-extras"
- *
- * const Source = Schema.Struct({
- *   a: Schema.Number,
- *   b: Schema.String,
- *   c: Schema.Boolean,
- * })
- *
- * const Picked = SchemaX.pick(Source, "a", "b")
- *
- * const decoded = Effect.runSync(
- *   Schema.decodeEffect(Picked)({ a: 1, b: "hi" }),
- * )
- * assert.deepStrictEqual(decoded, { a: 1, b: "hi" })
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const pick: <const Fields extends Schema.Struct.Fields, const Keys extends readonly (keyof Fields & string)[]>(schema: Schema.Struct<Fields>, ...keys: Keys) => Schema.Struct<Pick<Fields, Keys[number]>>;
-/**
- * Returns a new `Schema.Struct` with the named `keys` of `schema` removed.
- *
- * The complement of {@link pick}, restoring the v3 ergonomics of
- * `mySchema.omit("a")` that v4 dropped from `Schema.Struct` instances. Every
- * surviving field keeps its original schema, including any refinements.
- *
- * @example
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { SchemaX } from "@nunofyobiz/effect-extras"
- *
- * const Source = Schema.Struct({
- *   a: Schema.Number,
- *   b: Schema.String,
- *   c: Schema.Boolean,
- * })
- *
- * const Omitted = SchemaX.omit(Source, "c")
- *
- * const decoded = Effect.runSync(
- *   Schema.decodeEffect(Omitted)({ a: 1, b: "hi" }),
- * )
- * assert.deepStrictEqual(decoded, { a: 1, b: "hi" })
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const omit: <const Fields extends Schema.Struct.Fields, const Keys extends readonly (keyof Fields & string)[]>(schema: Schema.Struct<Fields>, ...keys: Keys) => Schema.Struct<Omit<Fields, Keys[number]>>;
-/**
- * Returns a new `Schema.Struct` in which every field of `schema` is made
- * optional.
- *
- * Restores the v3 `Schema.partial(mySchema)` behaviour that v4 removed, by
- * wrapping each field in `Schema.optional`. A decoded value may therefore omit
- * any field; fields that *are* present still have to satisfy their original
- * schema, refinements included.
- *
- * @example
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { SchemaX } from "@nunofyobiz/effect-extras"
- *
- * const Source = Schema.Struct({ a: Schema.Number, b: Schema.String })
- * const Partial = SchemaX.partial(Source)
- *
- * // All fields may be absent
- * assert.deepStrictEqual(Effect.runSync(Schema.decodeEffect(Partial)({})), {})
- *
- * // A present subset still decodes
- * assert.deepStrictEqual(
- *   Effect.runSync(Schema.decodeEffect(Partial)({ a: 1 })),
- *   { a: 1 },
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const partial: <Fields extends Schema.Struct.Fields>(schema: Schema.Struct<Fields>) => Schema.Struct<{ [K in keyof Fields]: Schema.optional<Fields[K]>; }>;
-/**
- * Returns a new `Schema.Struct` containing only the named `keys` of `schema`,
- * with every picked field made optional.
- *
- * Equivalent to `partial(pick(schema, ...keys))`, but reads more directly for
- * the common "partial update over a subset of fields" pattern: select the
- * mutable fields of an entity, then allow any of them to be omitted in the
- * update payload. Composes {@link pick} and {@link partial} in one call.
- *
- * @example
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { SchemaX } from "@nunofyobiz/effect-extras"
- *
- * const Source = Schema.Struct({
- *   a: Schema.Number,
- *   b: Schema.String,
- *   c: Schema.Boolean,
- * })
- *
- * const Update = SchemaX.pickPartial(Source, "a", "b")
- *
- * // Only picked fields are known, and each may be omitted
- * assert.deepStrictEqual(Effect.runSync(Schema.decodeEffect(Update)({})), {})
- * assert.deepStrictEqual(
- *   Effect.runSync(Schema.decodeEffect(Update)({ a: 1 })),
- *   { a: 1 },
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const pickPartial: <const Fields extends Schema.Struct.Fields, const Keys extends readonly (keyof Fields & string)[]>(schema: Schema.Struct<Fields>, ...keys: Keys) => Schema.Struct<{ [K in Keys[number]]: Schema.optional<Fields[K]>; }>;
-
-type SchemaX_MakeIn<S extends {
-    readonly "~type.make.in": unknown;
-}> = MakeIn<S>;
-declare const SchemaX_TrimmedNonEmptyString: typeof TrimmedNonEmptyString;
-declare const SchemaX_URLSafeFilePath: typeof URLSafeFilePath;
-declare const SchemaX_nonNegativeBigInt: typeof nonNegativeBigInt;
-declare const SchemaX_omit: typeof omit;
-declare const SchemaX_partial: typeof partial;
-declare const SchemaX_pick: typeof pick;
-declare const SchemaX_pickPartial: typeof pickPartial;
-declare namespace SchemaX {
-  export { type SchemaX_MakeIn as MakeIn, SchemaX_TrimmedNonEmptyString as TrimmedNonEmptyString, SchemaX_URLSafeFilePath as URLSafeFilePath, SchemaX_nonNegativeBigInt as nonNegativeBigInt, SchemaX_omit as omit, SchemaX_partial as partial, SchemaX_pick as pick, SchemaX_pickPartial as pickPartial };
-}
-
-/**
- * Runs a mutating function against a copy of `set`, leaving the original
- * untouched, and returns the mutated copy.
- *
- * Use it to reuse imperative `Set` mutation code (`.add`, `.delete`) without
- * sacrificing immutability: the callback may freely mutate the set it receives
- * because it operates on a fresh clone. Supports both data-first and data-last
- * (pipeable) call styles.
- *
- * @example
- * ```ts
- * import { SetX } from "@nunofyobiz/effect-extras"
- * import { pipe } from "effect"
- *
- * const original = new Set(["a", "b"])
- *
- * const result = pipe(
- *   original,
- *   SetX.safelyMutate((set) => {
- *     set.delete("a")
- *     return set.add("c")
- *   })
- * )
- *
- * assert.deepStrictEqual(result, new Set(["b", "c"]))
- * // The original is left intact
- * assert.deepStrictEqual(original, new Set(["a", "b"]))
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const safelyMutate: (<A>(mutate: (set: Set<A>) => Set<A>) => (set: Set<A>) => Set<A>) & (<A>(set: Set<A>, mutate: (set: Set<A>) => Set<A>) => Set<A>);
-/**
- * Returns a new `Set` with `value` added, leaving the input set unchanged.
- *
- * When `value` is already present the input set is returned as-is (no copy),
- * making repeated adds of existing members allocation-free. Supports both
- * data-first and data-last (pipeable) call styles.
- *
- * @example
- * ```ts
- * import { SetX } from "@nunofyobiz/effect-extras"
- * import { pipe } from "effect"
- *
- * // Data-first — adds a new element into a fresh set
- * assert.deepStrictEqual(
- *   SetX.add(new Set(["a", "b"]), "c"),
- *   new Set(["a", "b", "c"])
- * )
- *
- * // Data-last — existing element leaves the set unchanged
- * assert.deepStrictEqual(
- *   pipe(new Set(["a", "b"]), SetX.add("b")),
- *   new Set(["a", "b"])
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const add: (<A>(value: A) => (set: Set<A>) => Set<A>) & (<A>(set: Set<A>, value: A) => Set<A>);
-/**
- * Returns a new `Set` with `value` removed, leaving the input set unchanged.
- *
- * When `value` is absent the input set is returned as-is (no copy). Supports both
- * data-first and data-last (pipeable) call styles.
- *
- * @example
- * ```ts
- * import { SetX } from "@nunofyobiz/effect-extras"
- * import { pipe } from "effect"
- *
- * // Data-first — removes an existing element into a fresh set
- * assert.deepStrictEqual(
- *   SetX.remove(new Set(["a", "b", "c"]), "c"),
- *   new Set(["a", "b"])
- * )
- *
- * // Data-last — absent element leaves the set unchanged
- * assert.deepStrictEqual(
- *   pipe(new Set(["a", "b"]), SetX.remove("z")),
- *   new Set(["a", "b"])
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const remove: (<A>(value: A) => (set: Set<A>) => Set<A>) & (<A>(set: Set<A>, value: A) => Set<A>);
-/**
- * Returns a new `Set` with `value` added if it was absent or removed if it was
- * present, leaving the input set unchanged.
- *
- * Use it for membership toggles (selection state, feature flags by key) where a
- * value's presence should flip on each call. Supports both data-first and
- * data-last (pipeable) call styles.
- *
- * @example
- * ```ts
- * import { SetX } from "@nunofyobiz/effect-extras"
- * import { pipe } from "effect"
- *
- * // Data-first — absent value gets added
- * assert.deepStrictEqual(
- *   SetX.toggle(new Set(["a", "b"]), "c"),
- *   new Set(["a", "b", "c"])
- * )
- *
- * // Data-last — present value gets removed
- * assert.deepStrictEqual(
- *   pipe(new Set(["a", "b", "c"]), SetX.toggle("b")),
- *   new Set(["a", "c"])
- * )
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const toggle: (<A>(value: A) => (set: Set<A>) => Set<A>) & (<A>(set: Set<A>, value: A) => Set<A>);
-
-declare const SetX_add: typeof add;
-declare const SetX_remove: typeof remove;
-declare const SetX_safelyMutate: typeof safelyMutate;
-declare const SetX_toggle: typeof toggle;
-declare namespace SetX {
-  export { SetX_add as add, SetX_remove as remove, SetX_safelyMutate as safelyMutate, SetX_toggle as toggle };
-}
-
-/**
- * Prepends `start` to `string_`.
- *
- * v4's `String` module has no native `prepend` (only `concat`), so this fills
- * the gap as a pipeable helper.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { StringX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(StringX.prepend("world", "hello "), "hello world")
- *
- * // data-last (piped)
- * assert.deepStrictEqual(pipe("world", StringX.prepend("hello ")), "hello world")
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const prepend: ((start: string) => (string_: string) => string) & ((string_: string, start: string) => string);
-/**
- * Wraps `string_` between `start` and `end`.
- *
- * No v4 native equivalent — handy for quoting, bracketing, or fencing a value.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { StringX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(StringX.surround("value", "[", "]"), "[value]")
- *
- * // data-last (piped)
- * assert.deepStrictEqual(pipe("value", StringX.surround("(", ")")), "(value)")
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const surround: ((start: string, end: string) => (string_: string) => string) & ((string_: string, start: string, end: string) => string);
-/**
- * Prepends `start` to `string_` unless `string_` already starts with it.
- *
- * Idempotent: applying it to an already-prefixed string is a no-op, so
- * `ensurePrepend("foofoo", "foo")` stays `"foofoo"` rather than gaining a
- * second `"foo"`.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { StringX } from "@nunofyobiz/effect-extras"
- *
- * // data-first — adds the prefix when missing
- * assert.deepStrictEqual(StringX.ensurePrepend("bar", "foo"), "foobar")
- *
- * // idempotent — already prefixed, returned unchanged
- * assert.deepStrictEqual(StringX.ensurePrepend("foobar", "foo"), "foobar")
- *
- * // data-last (piped)
- * assert.deepStrictEqual(pipe("bar", StringX.ensurePrepend("foo")), "foobar")
- * ```
- *
- * @category combinators
- * @since 0.0.0
- */
-declare const ensurePrepend: ((start: string) => (string_: string) => string) & ((string_: string, start: string) => string);
-
-declare const StringX_ensurePrepend: typeof ensurePrepend;
-declare const StringX_prepend: typeof prepend;
-declare const StringX_surround: typeof surround;
-declare namespace StringX {
-  export { StringX_ensurePrepend as ensurePrepend, StringX_prepend as prepend, StringX_surround as surround };
-}
-
-/**
- * Generic, framework-agnostic extensions to Effect's `Struct` module.
- *
- * @since 0.0.0
- */
-
-/**
- * Describes the shape of a per-field transformation over an object `O`: a record
- * `T` whose values are functions taking the corresponding field of `O`.
- *
- * Used to type the "evolve" pattern, where each provided key maps to a function
- * that receives that field's current value. Copied from Effect's internal
- * `Struct.evolve()` type, which is not exported — it would be better to use
- * theirs directly if it ever becomes public.
- *
- * @example
- * ```ts
- * import { StructX } from "@nunofyobiz/effect-extras"
- *
- * type Transform = StructX.PartialTransform<
- *   { a: number; b: string },
- *   { a: (n: number) => boolean }
- * >
- *
- * const evolve: Transform = { a: (n) => n > 0 }
- *
- * assert.deepStrictEqual(evolve.a(1), true)
- * ```
- *
- * @category models
- * @since 0.0.0
- */
-type PartialTransform<O, T> = {
-    [K in keyof T]: T[K] extends (a: O[K & keyof O]) => unknown ? T[K] : (a: O[K & keyof O]) => unknown;
-};
-/**
- * Builds a singleton record `{ [name]: value }` when `value` is defined, or an
- * empty object `{}` when it is `undefined` — meant to be spread into an object
- * literal.
- *
- * This is the canonical fix for `exactOptionalPropertyTypes: true` (which this
- * repo enables for Effect Schema). Under that flag, spreading
- * `{ key: maybeUndefined }` into an object whose key is `key?: T` is a type
- * error: the property must be *absent*, not present-but-`undefined`. Spreading
- * `...defined("key", maybeUndefined)` instead conditionally omits the property
- * altogether. Note that `null` and other falsy-but-defined values (`0`, `""`,
- * `false`) are kept — only `undefined` is dropped.
- *
- * @example
- * ```ts
- * import { StructX } from "@nunofyobiz/effect-extras"
- *
- * // Defined value → singleton record
- * assert.deepStrictEqual(StructX.defined("name", "Ada"), { name: "Ada" })
- *
- * // undefined → property omitted entirely
- * assert.deepStrictEqual(StructX.defined("name", undefined), {})
- *
- * // Falsy-but-defined values are kept
- * assert.deepStrictEqual(StructX.defined("name", 0), { name: 0 })
- *
- * // Typical use: spread to conditionally include an optional field
- * const maybeAge: number | undefined = undefined
- * assert.deepStrictEqual({ id: 1, ...StructX.defined("age", maybeAge) }, {
- *   id: 1,
- * })
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const defined: <const K extends string, V>(name: K, value: V | undefined) => Partial<Record<K, Exclude<V, undefined>>>;
-/**
- * Removes every property whose value is `undefined` from `record`, narrowing
- * each remaining property type to exclude `undefined`.
- *
- * The bulk counterpart of {@link defined}: instead of building one optional
- * field, it filters a whole object. Very useful for update/patch actions where
- * `undefined` means "leave this field unchanged" while every other value —
- * including `null`, `0`, `""`, `false`, and `Option.none()` — means "set the
- * field to exactly this".
- *
- * @example
- * ```ts
- * import { StructX } from "@nunofyobiz/effect-extras"
- *
- * // Drops `b` (undefined) but keeps every other value, including null/0/false
- * assert.deepStrictEqual(
- *   StructX.filterDefined({ a: "x", b: undefined, c: 0, d: null, e: false }),
- *   { a: "x", c: 0, d: null, e: false },
- * )
- * ```
- *
- * @category filtering
- * @since 0.0.0
- */
-declare const filterDefined: <R extends Record<string, unknown>>(record: R) => Partial<{ [P in keyof R]: Exclude<R[P], undefined>; }>;
-/**
- * Builds a singleton record `{ [name]: value }` when `value` is `Some`, or an
- * empty object `{}` when it is `None` — meant to be spread into an object
- * literal.
- *
- * The `Option`-valued sibling of {@link defined}: where `defined` keys off
- * `undefined`, this keys off `Option` presence. Spread `...some("key", opt)` to
- * conditionally include a field only when the `Option` carries a value, which
- * stays correct under `exactOptionalPropertyTypes: true`.
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- * import { StructX } from "@nunofyobiz/effect-extras"
- *
- * // Some → singleton record
- * assert.deepStrictEqual(StructX.some("name", Option.some("Ada")), {
- *   name: "Ada",
- * })
- *
- * // None → property omitted entirely
- * assert.deepStrictEqual(StructX.some("name", Option.none()), {})
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const some: <const K extends string, V>(name: K, value: Option.Option<V>) => Partial<Record<K, V>>;
-/**
- * Looks up `key` in a record of `Option` values and returns a singleton record
- * when the value is `Some`, or `{}` when the key is absent or its value is
- * `None`.
- *
- * Combines `Record.get` + `Option.flatten` + a singleton builder in one call —
- * ideal for spreading an optional field out of a lookup table into an object
- * literal under `exactOptionalPropertyTypes: true`. By default the output key
- * matches the lookup key; pass `renameKeyTo` to emit the value under a different
- * name.
- *
- * @example
- * ```ts
- * import { Option } from "effect"
- * import { StructX } from "@nunofyobiz/effect-extras"
- *
- * const lookup = {
- *   a: Option.some(100),
- *   b: Option.none<number>(),
- * }
- *
- * // Some → singleton record under the same key
- * assert.deepStrictEqual(StructX.pickSome(lookup, "a"), { a: 100 })
- *
- * // None → property omitted entirely
- * assert.deepStrictEqual(StructX.pickSome(lookup, "b"), {})
- *
- * // Rename the output key
- * assert.deepStrictEqual(StructX.pickSome(lookup, "a", "count"), { count: 100 })
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare function pickSome<const K extends string, V>(record: Record<K, Option.Option<V>>, key: K): Partial<Record<K, V>>;
-declare function pickSome<const K1 extends string, V, const K2 extends string>(record: Record<K1, Option.Option<V>>, key: K1, renameKeyTo: K2): Partial<Record<K2, V>>;
-/**
- * Builds a singleton record `{ [name]: value }` when `value` is truthy, or an
- * empty object `{}` otherwise — meant to be spread into an object literal.
- *
- * Stricter than {@link defined}: it drops not just `undefined` but every falsy
- * value (`null`, `false`, `0`, `""`, `NaN`), and narrows the value type
- * accordingly. Use it to spread a field only when it carries a meaningful,
- * non-falsy value.
- *
- * @example
- * ```ts
- * import { StructX } from "@nunofyobiz/effect-extras"
- *
- * // Truthy value → singleton record
- * assert.deepStrictEqual(StructX.truthy("name", "Ada"), { name: "Ada" })
- *
- * // Falsy values → property omitted entirely
- * assert.deepStrictEqual(StructX.truthy("name", ""), {})
- * assert.deepStrictEqual(StructX.truthy("name", 0), {})
- * assert.deepStrictEqual(StructX.truthy("name", false), {})
- * ```
- *
- * @category constructors
- * @since 0.0.0
- */
-declare const truthy: <const K extends string, V>(name: K, value: V) => Partial<Record<K, Exclude<NonNullable<V>, false | 0 | "">>>;
-/**
- * Returns `true` when `object` has `key` set to a non-nullish value, narrowing
- * that property to `NonNullable` on the type level.
- *
- * A type guard combining `hasProperty` with a nullish check: after a successful
- * test, TypeScript treats `object[key]` as present and free of `null` /
- * `undefined`. Handy as a predicate passed to `Array.filter` to keep only the
- * elements whose `key` is populated.
- *
- * @example
- * ```ts
- * import { pipe } from "effect"
- * import { StructX } from "@nunofyobiz/effect-extras"
- *
- * // data-first
- * assert.deepStrictEqual(
- *   StructX.hasNotNullableProperty({ id: "1" }, "id"),
- *   true,
- * )
- *
- * // data-last (pipeable); a null value fails the guard
- * assert.deepStrictEqual(
- *   pipe({ id: null }, StructX.hasNotNullableProperty("id")),
- *   false,
- * )
- * ```
- *
- * @category refinements
- * @since 0.0.0
- */
-declare const hasNotNullableProperty: (<T, K extends keyof T>(key: K) => (object: T) => object is T & Record<K, NonNullable<T[K]>>) & (<T, K extends keyof T>(object: T, key: K) => object is T & Record<K, NonNullable<T[K]>>);
-
-type StructX_PartialTransform<O, T> = PartialTransform<O, T>;
-declare const StructX_defined: typeof defined;
-declare const StructX_filterDefined: typeof filterDefined;
-declare const StructX_hasNotNullableProperty: typeof hasNotNullableProperty;
-declare const StructX_pickSome: typeof pickSome;
-declare const StructX_some: typeof some;
-declare const StructX_truthy: typeof truthy;
-declare namespace StructX {
-  export { type StructX_PartialTransform as PartialTransform, StructX_defined as defined, StructX_filterDefined as filterDefined, StructX_hasNotNullableProperty as hasNotNullableProperty, StructX_pickSome as pickSome, StructX_some as some, StructX_truthy as truthy };
-}
-
-export { ArrayX, BigIntX, BooleanX, DurationX, EffectX, FormDataX, MapX, NonNullableX, NumberX, OptionX, OrderX, PredicateX, PromiseX, RecordX, ResultX, SchemaX, SetX, StringX, StructX, These$1 as These, fromNullableOrThrow as nn };
+export * as ArrayX from "./ArrayX.js";
+export * as BigIntX from "./BigIntX.js";
+export * as BooleanX from "./BooleanX.js";
+export * as DurationX from "./DurationX.js";
+export * as EffectX from "./EffectX.js";
+export * as FormDataX from "./FormDataX.js";
+export * as MapX from "./MapX.js";
+export * as NonNullableX from "./NonNullableX.js";
+export { fromNullableOrThrow as nn } from "./NonNullableX.js";
+export * as NumberX from "./NumberX.js";
+export * as OptionX from "./OptionX.js";
+export * as OrderX from "./OrderX.js";
+export * as PredicateX from "./PredicateX.js";
+export * as PromiseX from "./PromiseX.js";
+export * as RecordX from "./RecordX.js";
+export * as ResultX from "./ResultX.js";
+export * as SchemaX from "./SchemaX.js";
+export * as SetX from "./SetX.js";
+export * as StringX from "./StringX.js";
+export * as StructX from "./StructX.js";
+export * as WarnResult from "./WarnResult.js";
+//# sourceMappingURL=index.d.ts.map