@duplojs/utils 0.3.0 → 1.0.0

package/dist/either/nullish/filled.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var is$1 = require('../left/is.cjs');
+var create = require('../right/create.cjs');
+var is = require('../right/is.cjs');
+var create$1 = require('./create.cjs');
+var base = require('./base.cjs');
+
+const eitherNullishFilledKind = kind.createKind("either-nullish-filled");
+function nullishFilled(value) {
+    return base.eitherNullishKind.addTo(eitherNullishFilledKind.addTo(create.right("nullish", value)));
+}
+function isNullishFilled(input) {
+    return is.isRight(input)
+        && base.eitherNullishKind.has(input)
+        && base.eitherNullishKind.has(input);
+}
+function whenIsNullishFilled(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullishFilled(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isLeft(input)) {
+        return input;
+    }
+    else if (!isNullishFilled(input) && is.isRight(input)) {
+        return input;
+    }
+    const either = is.isRight(input) || is$1.isLeft(input)
+        ? input
+        : create$1.nullish(input);
+    if (isNullishFilled(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.eitherNullishFilledKind = eitherNullishFilledKind;
+exports.isNullishFilled = isNullishFilled;
+exports.nullishFilled = nullishFilled;
+exports.whenIsNullishFilled = whenIsNullishFilled;

package/dist/either/nullish/filled.d.ts

@@ -0,0 +1,15 @@
+import { type EitherRight } from "../right";
+import { type EitherLeft } from "../left";
+import { nullish } from "./create";
+import { type Kind } from "../../common/kind";
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { eitherNullishKind } from "./base";
+export declare const eitherNullishFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullish-filled", unknown>>;
+export type EitherNullishFilled<GenericValue extends unknown = unknown> = (EitherRight<"nullish", GenericValue> & Kind<typeof eitherNullishKind.definition> & Kind<typeof eitherNullishFilledKind.definition>);
+export declare function nullishFilled<const GenericValue extends unknown>(value: GenericValue): EitherNullishFilled<GenericValue>;
+type Either = EitherRight | EitherLeft;
+export declare function isNullishFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishFilled>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullish<GenericValue>>;
+export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishFilled>;
+export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishFilled>;
+export {};

package/dist/either/nullish/filled.mjs

@@ -0,0 +1,39 @@
+import { createKind } from '../../common/kind.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { isLeft } from '../left/is.mjs';
+import { right } from '../right/create.mjs';
+import { isRight } from '../right/is.mjs';
+import { nullish } from './create.mjs';
+import { eitherNullishKind } from './base.mjs';
+
+const eitherNullishFilledKind = createKind("either-nullish-filled");
+function nullishFilled(value) {
+    return eitherNullishKind.addTo(eitherNullishFilledKind.addTo(right("nullish", value)));
+}
+function isNullishFilled(input) {
+    return isRight(input)
+        && eitherNullishKind.has(input)
+        && eitherNullishKind.has(input);
+}
+function whenIsNullishFilled(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullishFilled(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isLeft(input)) {
+        return input;
+    }
+    else if (!isNullishFilled(input) && isRight(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : nullish(input);
+    if (isNullishFilled(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { eitherNullishFilledKind, isNullishFilled, nullishFilled, whenIsNullishFilled };

package/dist/either/nullish/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./create";
+export * from "./empty";
+export * from "./filled";
+export * from "./base";

package/dist/either/optional/base.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+
+const eitherOptionalKind = kind.createKind("either-optional");
+
+exports.eitherOptionalKind = eitherOptionalKind;

package/dist/either/optional/base.d.ts

@@ -0,0 +1 @@
+export declare const eitherOptionalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-optional", unknown>>;

package/dist/either/optional/base.mjs

@@ -0,0 +1,5 @@
+import { createKind } from '../../common/kind.mjs';
+
+const eitherOptionalKind = createKind("either-optional");
+
+export { eitherOptionalKind };

package/dist/either/optional/create.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var empty = require('./empty.cjs');
+var filled = require('./filled.cjs');
+
+function optional(value) {
+    return value === undefined
+        ? empty.optionalEmpty()
+        : filled.optionalFilled(value);
+}
+
+exports.optional = optional;

package/dist/either/optional/create.d.ts

@@ -0,0 +1,3 @@
+import { type EitherOptionalEmpty } from "./empty";
+import { type EitherOptionalFilled } from "./filled";
+export declare function optional<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends undefined ? EitherOptionalEmpty : EitherOptionalFilled<GenericValue>;

package/dist/either/optional/create.mjs

@@ -0,0 +1,10 @@
+import { optionalEmpty } from './empty.mjs';
+import { optionalFilled } from './filled.mjs';
+
+function optional(value) {
+    return value === undefined
+        ? optionalEmpty()
+        : optionalFilled(value);
+}
+
+export { optional };

package/dist/either/optional/empty.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var create = require('../left/create.cjs');
+var is = require('../left/is.cjs');
+var is$1 = require('../right/is.cjs');
+var create$1 = require('./create.cjs');
+var base = require('./base.cjs');
+
+const eitherOptionalEmptyKind = kind.createKind("either-optional-empty");
+function optionalEmpty() {
+    return base.eitherOptionalKind.addTo(eitherOptionalEmptyKind.addTo(create.left("optional", undefined)));
+}
+function isOptionalEmpty(input) {
+    return is.isLeft(input)
+        && base.eitherOptionalKind.has(input)
+        && eitherOptionalEmptyKind.has(input);
+}
+function whenIsOptionalEmpty(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsOptionalEmpty(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isRight(input)) {
+        return input;
+    }
+    else if (!isOptionalEmpty(input) && is.isLeft(input)) {
+        return input;
+    }
+    const either = is$1.isRight(input) || is.isLeft(input)
+        ? input
+        : create$1.optional(input);
+    if (isOptionalEmpty(either)) {
+        return theFunction(undefined);
+    }
+    return either;
+}
+
+exports.eitherOptionalEmptyKind = eitherOptionalEmptyKind;
+exports.isOptionalEmpty = isOptionalEmpty;
+exports.optionalEmpty = optionalEmpty;
+exports.whenIsOptionalEmpty = whenIsOptionalEmpty;

package/dist/either/optional/empty.d.ts

@@ -0,0 +1,15 @@
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "../right";
+import { optional } from "./create";
+import { eitherOptionalKind } from "./base";
+export declare const eitherOptionalEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-optional-empty", unknown>>;
+export type EitherOptionalEmpty = (EitherLeft<"optional", undefined> & Kind<typeof eitherOptionalKind.definition> & Kind<typeof eitherOptionalEmptyKind.definition>);
+type Either = EitherRight | EitherLeft;
+export declare function optionalEmpty(): EitherOptionalEmpty;
+export declare function isOptionalEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalEmpty>;
+type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;
+export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalEmpty>;
+export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalEmpty>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalEmpty>;
+export {};

package/dist/either/optional/empty.mjs

@@ -0,0 +1,38 @@
+import { createKind } from '../../common/kind.mjs';
+import { left } from '../left/create.mjs';
+import { isLeft } from '../left/is.mjs';
+import { isRight } from '../right/is.mjs';
+import { optional } from './create.mjs';
+import { eitherOptionalKind } from './base.mjs';
+
+const eitherOptionalEmptyKind = createKind("either-optional-empty");
+function optionalEmpty() {
+    return eitherOptionalKind.addTo(eitherOptionalEmptyKind.addTo(left("optional", undefined)));
+}
+function isOptionalEmpty(input) {
+    return isLeft(input)
+        && eitherOptionalKind.has(input)
+        && eitherOptionalEmptyKind.has(input);
+}
+function whenIsOptionalEmpty(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsOptionalEmpty(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isRight(input)) {
+        return input;
+    }
+    else if (!isOptionalEmpty(input) && isLeft(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : optional(input);
+    if (isOptionalEmpty(either)) {
+        return theFunction(undefined);
+    }
+    return either;
+}
+
+export { eitherOptionalEmptyKind, isOptionalEmpty, optionalEmpty, whenIsOptionalEmpty };

package/dist/either/optional/filled.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var is$1 = require('../left/is.cjs');
+var create = require('../right/create.cjs');
+var is = require('../right/is.cjs');
+var create$1 = require('./create.cjs');
+var base = require('./base.cjs');
+
+const eitherOptionalFilledKind = kind.createKind("either-optional-filled");
+function optionalFilled(value) {
+    return base.eitherOptionalKind.addTo(eitherOptionalFilledKind.addTo(create.right("optional", value)));
+}
+function isOptionalFilled(input) {
+    return is.isRight(input)
+        && base.eitherOptionalKind.has(input)
+        && eitherOptionalFilledKind.has(input);
+}
+function whenIsOptionalFilled(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsOptionalFilled(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isLeft(input)) {
+        return input;
+    }
+    else if (!isOptionalFilled(input) && is.isRight(input)) {
+        return input;
+    }
+    const either = is.isRight(input) || is$1.isLeft(input)
+        ? input
+        : create$1.optional(input);
+    if (isOptionalFilled(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.eitherOptionalFilledKind = eitherOptionalFilledKind;
+exports.isOptionalFilled = isOptionalFilled;
+exports.optionalFilled = optionalFilled;
+exports.whenIsOptionalFilled = whenIsOptionalFilled;

package/dist/either/optional/filled.d.ts

@@ -0,0 +1,15 @@
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "../right";
+import { optional } from "./create";
+import { eitherOptionalKind } from "./base";
+export declare const eitherOptionalFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-optional-filled", unknown>>;
+export type EitherOptionalFilled<GenericValue extends unknown = unknown> = (EitherRight<"optional", GenericValue> & Kind<typeof eitherOptionalKind.definition> & Kind<typeof eitherOptionalFilledKind.definition>);
+type Either = EitherRight | EitherLeft;
+export declare function optionalFilled<const GenericValue extends unknown>(value: GenericValue): EitherOptionalFilled<GenericValue>;
+export declare function isOptionalFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalFilled>;
+type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;
+export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalFilled>;
+export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalFilled>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalFilled>;
+export {};

package/dist/either/optional/filled.mjs

@@ -0,0 +1,39 @@
+import { createKind } from '../../common/kind.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { isLeft } from '../left/is.mjs';
+import { right } from '../right/create.mjs';
+import { isRight } from '../right/is.mjs';
+import { optional } from './create.mjs';
+import { eitherOptionalKind } from './base.mjs';
+
+const eitherOptionalFilledKind = createKind("either-optional-filled");
+function optionalFilled(value) {
+    return eitherOptionalKind.addTo(eitherOptionalFilledKind.addTo(right("optional", value)));
+}
+function isOptionalFilled(input) {
+    return isRight(input)
+        && eitherOptionalKind.has(input)
+        && eitherOptionalFilledKind.has(input);
+}
+function whenIsOptionalFilled(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsOptionalFilled(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isLeft(input)) {
+        return input;
+    }
+    else if (!isOptionalFilled(input) && isRight(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : optional(input);
+    if (isOptionalFilled(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { eitherOptionalFilledKind, isOptionalFilled, optionalFilled, whenIsOptionalFilled };

package/dist/either/optional/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./create";
+export * from "./empty";
+export * from "./filled";
+export * from "./base";

package/dist/either/right/asyncPipe.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var unwrap = require('../../common/unwrap.cjs');
+var is = require('../left/is.cjs');
+var create = require('../future/create.cjs');
+var success = require('./success.cjs');
+var is$1 = require('./is.cjs');
+
+function rightAsyncPipe(input, ...pipes) {
+    return create.future((async () => {
+        const awaitedInput = await input;
+        if (is.isLeft(awaitedInput)) {
+            return awaitedInput;
+        }
+        let acc = is$1.isRight(awaitedInput)
+            ? awaitedInput
+            : success.success(awaitedInput);
+        for (const pipe of pipes) {
+            acc = await pipe(unwrap.unwrap(acc));
+            if (is.isLeft(acc)) {
+                return acc;
+            }
+        }
+        return acc;
+    })());
+}
+
+exports.rightAsyncPipe = rightAsyncPipe;

package/dist/either/right/asyncPipe.d.ts

@@ -0,0 +1,22 @@
+import { type EitherRight } from "./create";
+import { type EitherLeft } from "../left";
+import { type MaybeFutureEither } from "../future/MaybeFutureEither";
+import { type Future } from "../future";
+import { type EitherSuccess } from "./success";
+import { type Unwrap, type AnyValue } from "../../common";
+type Either = EitherRight | EitherLeft;
+type EitherOrFutureEither = Either | Future<any>;
+export type EitherRightAsyncPipeFunction<GenericInput extends Either = Either, GenericOutput extends EitherOrFutureEither = EitherOrFutureEither> = (input: Unwrap<Extract<GenericInput, EitherRight>>) => GenericOutput;
+export type EitherRightAsyncPipeResult<GenericInput extends EitherOrFutureEither, GenericOutputPipes extends EitherOrFutureEither, GenericLastPipe extends EitherOrFutureEither> = Extract<GenericInput | GenericOutputPipes, EitherLeft> | Extract<GenericLastPipe, EitherRight>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : EitherSuccess<GenericValue>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1, GenericOutputPipe1>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2, GenericOutputPipe2>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3, GenericOutputPipe3>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4, GenericOutputPipe4>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5, GenericOutputPipe5>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither, GenericOutputPipe6 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>, pipe6: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe5>, GenericOutputPipe6>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6, GenericOutputPipe6>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither, GenericOutputPipe6 extends EitherOrFutureEither, GenericOutputPipe7 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>, pipe6: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe5>, GenericOutputPipe6>, pipe7: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe6>, GenericOutputPipe7>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7, GenericOutputPipe7>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither, GenericOutputPipe6 extends EitherOrFutureEither, GenericOutputPipe7 extends EitherOrFutureEither, GenericOutputPipe8 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>, pipe6: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe5>, GenericOutputPipe6>, pipe7: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe6>, GenericOutputPipe7>, pipe8: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe7>, GenericOutputPipe8>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7 | GenericOutputPipe8, GenericOutputPipe8>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither, GenericOutputPipe6 extends EitherOrFutureEither, GenericOutputPipe7 extends EitherOrFutureEither, GenericOutputPipe8 extends EitherOrFutureEither, GenericOutputPipe9 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>, pipe6: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe5>, GenericOutputPipe6>, pipe7: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe6>, GenericOutputPipe7>, pipe8: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe7>, GenericOutputPipe8>, pipe9: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe8>, GenericOutputPipe9>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7 | GenericOutputPipe8 | GenericOutputPipe9, GenericOutputPipe9>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither, GenericOutputPipe6 extends EitherOrFutureEither, GenericOutputPipe7 extends EitherOrFutureEither, GenericOutputPipe8 extends EitherOrFutureEither, GenericOutputPipe9 extends EitherOrFutureEither, GenericOutputPipe10 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>, pipe6: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe5>, GenericOutputPipe6>, pipe7: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe6>, GenericOutputPipe7>, pipe8: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe7>, GenericOutputPipe8>, pipe9: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe8>, GenericOutputPipe9>, pipe10: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe9>, GenericOutputPipe10>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7 | GenericOutputPipe8 | GenericOutputPipe9 | GenericOutputPipe10, GenericOutputPipe10>, any>>;
+export {};

package/dist/either/right/asyncPipe.mjs

@@ -0,0 +1,26 @@
+import { unwrap } from '../../common/unwrap.mjs';
+import { isLeft } from '../left/is.mjs';
+import { future } from '../future/create.mjs';
+import { success } from './success.mjs';
+import { isRight } from './is.mjs';
+
+function rightAsyncPipe(input, ...pipes) {
+    return future((async () => {
+        const awaitedInput = await input;
+        if (isLeft(awaitedInput)) {
+            return awaitedInput;
+        }
+        let acc = isRight(awaitedInput)
+            ? awaitedInput
+            : success(awaitedInput);
+        for (const pipe of pipes) {
+            acc = await pipe(unwrap(acc));
+            if (isLeft(acc)) {
+                return acc;
+            }
+        }
+        return acc;
+    })());
+}
+
+export { rightAsyncPipe };

package/dist/either/right/create.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+var base = require('../base.cjs');
+
+const eitherRightKind = kind.createKind("either-right");
+function right(information, value = undefined) {
+    return eitherRightKind.addTo(base.eitherInformationKind.addTo(wrapValue.wrapValue(value), information));
+}
+
+exports.eitherRightKind = eitherRightKind;
+exports.right = right;

package/dist/either/right/create.d.ts

@@ -0,0 +1,6 @@
+import { type Kind } from "../../common/kind";
+import { type WrappedValue } from "../../common/wrapValue";
+import { eitherInformationKind } from "../base";
+export declare const eitherRightKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-right", unknown>>;
+export type EitherRight<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (Kind<typeof eitherRightKind.definition> & Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue<GenericValue>);
+export declare function right<GenericInformation extends string, const GenericValue extends unknown = undefined>(information: GenericInformation, value?: GenericValue): EitherRight<GenericInformation, GenericValue>;

package/dist/either/right/create.mjs

@@ -0,0 +1,10 @@
+import { createKind } from '../../common/kind.mjs';
+import { wrapValue } from '../../common/wrapValue.mjs';
+import { eitherInformationKind } from '../base.mjs';
+
+const eitherRightKind = createKind("either-right");
+function right(information, value = undefined) {
+    return eitherRightKind.addTo(eitherInformationKind.addTo(wrapValue(value), information));
+}
+
+export { eitherRightKind, right };

package/dist/either/right/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./asyncPipe";
+export * from "./create";
+export * from "./is";
+export * from "./ok";
+export * from "./pipe";
+export * from "./success";
+export * from "./when";

package/dist/either/right/is.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var base = require('../base.cjs');
+var create = require('./create.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+
+function isRight(input) {
+    return create.eitherRightKind.has(input)
+        && base.eitherInformationKind.has(input)
+        && wrapValue.isWrappedValue(input);
+}
+
+exports.isRight = isRight;

package/dist/either/right/is.d.ts

@@ -0,0 +1,2 @@
+import { type EitherRight } from "./create";
+export declare function isRight<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherRight>;

package/dist/either/right/is.mjs

@@ -0,0 +1,11 @@
+import { eitherInformationKind } from '../base.mjs';
+import { eitherRightKind } from './create.mjs';
+import { isWrappedValue } from '../../common/wrapValue.mjs';
+
+function isRight(input) {
+    return eitherRightKind.has(input)
+        && eitherInformationKind.has(input)
+        && isWrappedValue(input);
+}
+
+export { isRight };

package/dist/either/right/ok.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var create = require('./create.cjs');
+
+const eitherOkKind = kind.createKind("either-ok");
+function ok() {
+    return eitherOkKind.addTo(create.right("ok", undefined));
+}
+
+exports.eitherOkKind = eitherOkKind;
+exports.ok = ok;

package/dist/either/right/ok.d.ts

@@ -0,0 +1,5 @@
+import { type Kind } from "../../common/kind";
+import { type EitherRight } from "./create";
+export declare const eitherOkKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-ok", unknown>>;
+export type EitherOk = (EitherRight<"ok", never> & Kind<typeof eitherOkKind.definition>);
+export declare function ok(): EitherOk;

package/dist/either/right/ok.mjs

@@ -0,0 +1,9 @@
+import { createKind } from '../../common/kind.mjs';
+import { right } from './create.mjs';
+
+const eitherOkKind = createKind("either-ok");
+function ok() {
+    return eitherOkKind.addTo(right("ok", undefined));
+}
+
+export { eitherOkKind, ok };

package/dist/either/right/pipe.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var unwrap = require('../../common/unwrap.cjs');
+var is$1 = require('../left/is.cjs');
+var success = require('./success.cjs');
+var is = require('./is.cjs');
+
+/* eslint-disable @typescript-eslint/max-params */
+function rightPipe(input, ...pipes) {
+    let acc = is.isRight(input) || is$1.isLeft(input)
+        ? input
+        : success.success(input);
+    for (const pipe of pipes) {
+        acc = pipe(unwrap.unwrap(acc));
+        if (is$1.isLeft(acc)) {
+            return acc;
+        }
+    }
+    return acc;
+}
+
+exports.rightPipe = rightPipe;

package/dist/either/right/pipe.d.ts

@@ -0,0 +1,19 @@
+import { type EitherRight } from "./create";
+import { type EitherLeft } from "../left";
+import { type EitherSuccess } from "./success";
+import { type Unwrap } from "../../common";
+type Either = EitherRight | EitherLeft;
+export type EitherRightPipeFunction<GenericInput extends Either = Either, GenericOutput extends Either = Either> = (input: Unwrap<Extract<GenericInput, EitherRight>>) => GenericOutput;
+export type EitherRightPipeResult<GenericInput extends Either, GenericPipes extends Either, GenericLastPipe extends Either> = Extract<GenericInput | GenericPipes, EitherLeft> | Extract<GenericLastPipe, EitherRight>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : EitherSuccess<GenericValue>;
+export declare function rightPipe<const GenericInput extends unknown, GenericOutputPipe1 extends Either>(input: GenericInput, pipe1: EitherRightPipeFunction<ToEither<GenericInput>, GenericOutputPipe1>): Extract<EitherRightPipeResult<ToEither<GenericInput>, GenericOutputPipe1, GenericOutputPipe1>, any>;
+export declare function rightPipe<const GenericInput extends unknown, GenericOutputPipe1 extends Either, GenericOutputPipe2 extends Either>(input: GenericInput, pipe1: EitherRightPipeFunction<ToEither<GenericInput>, GenericOutputPipe1>, pipe2: EitherRightPipeFunction<GenericOutputPipe1, GenericOutputPipe2>): Extract<EitherRightPipeResult<ToEither<GenericInput>, GenericOutputPipe1 | GenericOutputPipe2, GenericOutputPipe2>, any>;
+export declare function rightPipe<const GenericInput extends unknown, GenericOutputPipe1 extends Either, GenericOutputPipe2 extends Either, GenericOutputPipe3 extends Either>(input: GenericInput, pipe1: EitherRightPipeFunction<ToEither<GenericInput>, GenericOutputPipe1>, pipe2: EitherRightPipeFunction<GenericOutputPipe1, GenericOutputPipe2>, pipe3: EitherRightPipeFunction<GenericOutputPipe2, GenericOutputPipe3>): Extract<EitherRightPipeResult<ToEither<GenericInput>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3, GenericOutputPipe3>, any>;
+export declare function rightPipe<const GenericInput extends unknown, GenericOutputPipe1 extends Either, GenericOutputPipe2 extends Either, GenericOutputPipe3 extends Either, GenericOutputPipe4 extends Either>(input: GenericInput, pipe1: EitherRightPipeFunction<ToEither<GenericInput>, GenericOutputPipe1>, pipe2: EitherRightPipeFunction<GenericOutputPipe1, GenericOutputPipe2>, pipe3: EitherRightPipeFunction<GenericOutputPipe2, GenericOutputPipe3>, pipe4: EitherRightPipeFunction<GenericOutputPipe3, GenericOutputPipe4>): Extract<EitherRightPipeResult<ToEither<GenericInput>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4, GenericOutputPipe4>, any>;
+export declare function rightPipe<const GenericInput extends unknown, GenericOutputPipe1 extends Either, GenericOutputPipe2 extends Either, GenericOutputPipe3 extends Either, GenericOutputPipe4 extends Either, GenericOutputPipe5 extends Either>(input: GenericInput, pipe1: EitherRightPipeFunction<ToEither<GenericInput>, GenericOutputPipe1>, pipe2: EitherRightPipeFunction<GenericOutputPipe1, GenericOutputPipe2>, pipe3: EitherRightPipeFunction<GenericOutputPipe2, GenericOutputPipe3>, pipe4: EitherRightPipeFunction<GenericOutputPipe3, GenericOutputPipe4>, pipe5: EitherRightPipeFunction<GenericOutputPipe4, GenericOutputPipe5>): Extract<EitherRightPipeResult<ToEither<GenericInput>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5, GenericOutputPipe5>, any>;
+export declare function rightPipe<const GenericInput extends unknown, GenericOutputPipe1 extends Either, GenericOutputPipe2 extends Either, GenericOutputPipe3 extends Either, GenericOutputPipe4 extends Either, GenericOutputPipe5 extends Either, GenericOutputPipe6 extends Either>(input: GenericInput, pipe1: EitherRightPipeFunction<ToEither<GenericInput>, GenericOutputPipe1>, pipe2: EitherRightPipeFunction<GenericOutputPipe1, GenericOutputPipe2>, pipe3: EitherRightPipeFunction<GenericOutputPipe2, GenericOutputPipe3>, pipe4: EitherRightPipeFunction<GenericOutputPipe3, GenericOutputPipe4>, pipe5: EitherRightPipeFunction<GenericOutputPipe4, GenericOutputPipe5>, pipe6: EitherRightPipeFunction<GenericOutputPipe5, GenericOutputPipe6>): Extract<EitherRightPipeResult<ToEither<GenericInput>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6, GenericOutputPipe6>, any>;
+export declare function rightPipe<const GenericInput extends unknown, GenericOutputPipe1 extends Either, GenericOutputPipe2 extends Either, GenericOutputPipe3 extends Either, GenericOutputPipe4 extends Either, GenericOutputPipe5 extends Either, GenericOutputPipe6 extends Either, GenericOutputPipe7 extends Either>(input: GenericInput, pipe1: EitherRightPipeFunction<ToEither<GenericInput>, GenericOutputPipe1>, pipe2: EitherRightPipeFunction<GenericOutputPipe1, GenericOutputPipe2>, pipe3: EitherRightPipeFunction<GenericOutputPipe2, GenericOutputPipe3>, pipe4: EitherRightPipeFunction<GenericOutputPipe3, GenericOutputPipe4>, pipe5: EitherRightPipeFunction<GenericOutputPipe4, GenericOutputPipe5>, pipe6: EitherRightPipeFunction<GenericOutputPipe5, GenericOutputPipe6>, pipe7: EitherRightPipeFunction<GenericOutputPipe6, GenericOutputPipe7>): Extract<EitherRightPipeResult<ToEither<GenericInput>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7, GenericOutputPipe7>, any>;
+export declare function rightPipe<const GenericInput extends unknown, GenericOutputPipe1 extends Either, GenericOutputPipe2 extends Either, GenericOutputPipe3 extends Either, GenericOutputPipe4 extends Either, GenericOutputPipe5 extends Either, GenericOutputPipe6 extends Either, GenericOutputPipe7 extends Either, GenericOutputPipe8 extends Either>(input: GenericInput, pipe1: EitherRightPipeFunction<ToEither<GenericInput>, GenericOutputPipe1>, pipe2: EitherRightPipeFunction<GenericOutputPipe1, GenericOutputPipe2>, pipe3: EitherRightPipeFunction<GenericOutputPipe2, GenericOutputPipe3>, pipe4: EitherRightPipeFunction<GenericOutputPipe3, GenericOutputPipe4>, pipe5: EitherRightPipeFunction<GenericOutputPipe4, GenericOutputPipe5>, pipe6: EitherRightPipeFunction<GenericOutputPipe5, GenericOutputPipe6>, pipe7: EitherRightPipeFunction<GenericOutputPipe6, GenericOutputPipe7>, pipe8: EitherRightPipeFunction<GenericOutputPipe7, GenericOutputPipe8>): Extract<EitherRightPipeResult<ToEither<GenericInput>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7 | GenericOutputPipe8, GenericOutputPipe8>, any>;
+export declare function rightPipe<const GenericInput extends unknown, GenericOutputPipe1 extends Either, GenericOutputPipe2 extends Either, GenericOutputPipe3 extends Either, GenericOutputPipe4 extends Either, GenericOutputPipe5 extends Either, GenericOutputPipe6 extends Either, GenericOutputPipe7 extends Either, GenericOutputPipe8 extends Either, GenericOutputPipe9 extends Either>(input: GenericInput, pipe1: EitherRightPipeFunction<ToEither<GenericInput>, GenericOutputPipe1>, pipe2: EitherRightPipeFunction<GenericOutputPipe1, GenericOutputPipe2>, pipe3: EitherRightPipeFunction<GenericOutputPipe2, GenericOutputPipe3>, pipe4: EitherRightPipeFunction<GenericOutputPipe3, GenericOutputPipe4>, pipe5: EitherRightPipeFunction<GenericOutputPipe4, GenericOutputPipe5>, pipe6: EitherRightPipeFunction<GenericOutputPipe5, GenericOutputPipe6>, pipe7: EitherRightPipeFunction<GenericOutputPipe6, GenericOutputPipe7>, pipe8: EitherRightPipeFunction<GenericOutputPipe7, GenericOutputPipe8>, pipe9: EitherRightPipeFunction<GenericOutputPipe8, GenericOutputPipe9>): Extract<EitherRightPipeResult<ToEither<GenericInput>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7 | GenericOutputPipe8 | GenericOutputPipe9, GenericOutputPipe9>, any>;
+export declare function rightPipe<const GenericInput extends unknown, GenericOutputPipe1 extends Either, GenericOutputPipe2 extends Either, GenericOutputPipe3 extends Either, GenericOutputPipe4 extends Either, GenericOutputPipe5 extends Either, GenericOutputPipe6 extends Either, GenericOutputPipe7 extends Either, GenericOutputPipe8 extends Either, GenericOutputPipe9 extends Either, GenericOutputPipe10 extends Either>(input: GenericInput, pipe1: EitherRightPipeFunction<ToEither<GenericInput>, GenericOutputPipe1>, pipe2: EitherRightPipeFunction<GenericOutputPipe1, GenericOutputPipe2>, pipe3: EitherRightPipeFunction<GenericOutputPipe2, GenericOutputPipe3>, pipe4: EitherRightPipeFunction<GenericOutputPipe3, GenericOutputPipe4>, pipe5: EitherRightPipeFunction<GenericOutputPipe4, GenericOutputPipe5>, pipe6: EitherRightPipeFunction<GenericOutputPipe5, GenericOutputPipe6>, pipe7: EitherRightPipeFunction<GenericOutputPipe6, GenericOutputPipe7>, pipe8: EitherRightPipeFunction<GenericOutputPipe7, GenericOutputPipe8>, pipe9: EitherRightPipeFunction<GenericOutputPipe8, GenericOutputPipe9>, pipe10: EitherRightPipeFunction<GenericOutputPipe9, GenericOutputPipe10>): Extract<EitherRightPipeResult<ToEither<GenericInput>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7 | GenericOutputPipe8 | GenericOutputPipe9 | GenericOutputPipe10, GenericOutputPipe10>, any>;
+export {};