@resultsafe/core-fp-result 0.1.0

package/dist/types/methods/expectErr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expectErr.d.ts","sourceRoot":"","sources":["../../../src/methods/expectErr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,MAAM,KAAG,CAKnE,CAAC"}

package/dist/types/methods/flatten.d.ts

@@ -0,0 +1,21 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Схлопывает вложенный `Result<Result<T, E>, E>` на один уровень.
+ *
+ * @typeParam T - The inner success value type.
+ * @typeParam E - The shared error value type.
+ * @param result - Вложенный `Result` для схлопывания.
+ * @returns A single-layer `Result<T, E>`.
+ * @since 0.1.0
+ * @see {@link andThen} - Chains computations that already return `Result`.
+ * @example
+ * ```ts
+ * import { Ok, flatten } from '@resultsafe/core-fp-result';
+ *
+ * const value = flatten(Ok(Ok(3)));
+ * console.log(value.ok); // true
+ * ```
+ * @public
+ */
+export declare const flatten: <T, E>(result: Result<Result<T, E>, E>) => Result<T, E>;
+//# sourceMappingURL=flatten.d.ts.map

package/dist/types/methods/flatten.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.ts","sourceRoot":"","sources":["../../../src/methods/flatten.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CACZ,CAAC"}

package/dist/types/methods/index.d.ts

@@ -0,0 +1,20 @@
+export { andThen } from './andThen.js';
+export { err } from './err.js';
+export { expect } from './expect.js';
+export { expectErr } from './expectErr.js';
+export { flatten } from './flatten.js';
+export { inspect } from './inspect.js';
+export { inspectErr } from './inspectErr.js';
+export { map } from './map.js';
+export { mapErr } from './mapErr.js';
+export { match } from './match.js';
+export { ok } from './ok.js';
+export { orElse } from './orElse.js';
+export { tap } from './tap.js';
+export { tapErr } from './tapErr.js';
+export { transpose } from './transpose.js';
+export { unwrap } from './unwrap.js';
+export { unwrapErr } from './unwrapErr.js';
+export { unwrapOr } from './unwrapOr.js';
+export { unwrapOrElse } from './unwrapOrElse.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/methods/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/methods/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAC7B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/types/methods/inspect.d.ts

@@ -0,0 +1,22 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Выполняет побочный эффект для успешного значения и возвращает исходный `Result`.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param fn - Функция побочного эффекта для ветки успеха.
+ * @returns Тот же экземпляр `Result`.
+ * @since 0.1.0
+ * @see {@link tap} - Эквивалентный helper для ветки успеха.
+ * @example
+ * ```ts
+ * import { Ok, inspect } from '@resultsafe/core-fp-result';
+ *
+ * const result = inspect(Ok(1), (value) => console.log(value)); // 1
+ * console.log(result.ok); // true
+ * ```
+ * @public
+ */
+export declare const inspect: <T, E>(result: Result<T, E>, fn: (value: T) => void) => Result<T, E>;
+//# sourceMappingURL=inspect.d.ts.map

package/dist/types/methods/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../src/methods/inspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAC1B,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KACrB,MAAM,CAAC,CAAC,EAAE,CAAC,CAKb,CAAC"}

package/dist/types/methods/inspectErr.d.ts

@@ -0,0 +1,22 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Выполняет побочный эффект для значения ошибки и возвращает исходный `Result`.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param fn - Функция побочного эффекта для ветки ошибки.
+ * @returns Тот же экземпляр `Result`.
+ * @since 0.1.0
+ * @see {@link tapErr} - Эквивалентный helper для ветки ошибки.
+ * @example
+ * ```ts
+ * import { Err, inspectErr } from '@resultsafe/core-fp-result';
+ *
+ * const result = inspectErr(Err('boom'), (error) => console.log(error)); // boom
+ * console.log(result.ok); // false
+ * ```
+ * @public
+ */
+export declare const inspectErr: <T, E>(result: Result<T, E>, fn: (error: E) => void) => Result<T, E>;
+//# sourceMappingURL=inspectErr.d.ts.map

package/dist/types/methods/inspectErr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectErr.d.ts","sourceRoot":"","sources":["../../../src/methods/inspectErr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAC7B,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KACrB,MAAM,CAAC,CAAC,EAAE,CAAC,CAKb,CAAC"}

package/dist/types/methods/map.d.ts

@@ -0,0 +1,23 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Преобразует успешное значение, сохраняя ветку ошибки.
+ *
+ * @typeParam T - Тип входного успешного значения.
+ * @typeParam U - Тип выходного успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param fn - Функция преобразования успешного значения.
+ * @returns Преобразованный `Ok` или исходный `Err`.
+ * @since 0.1.0
+ * @see {@link mapErr} - Преобразует ветку ошибки.
+ * @example
+ * ```ts
+ * import { Ok, map } from '@resultsafe/core-fp-result';
+ *
+ * const result = map(Ok(2), (value) => value * 10);
+ * console.log(result.ok); // true
+ * ```
+ * @public
+ */
+export declare const map: <T, U, E>(result: Result<T, E>, fn: (value: T) => U) => Result<U, E>;
+//# sourceMappingURL=map.d.ts.map

package/dist/types/methods/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../src/methods/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EACzB,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,KAClB,MAAM,CAAC,CAAC,EAAE,CAAC,CAGgB,CAAC"}

package/dist/types/methods/mapErr.d.ts

@@ -0,0 +1,23 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Преобразует значение ошибки, сохраняя ветку успеха.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип входного значения ошибки.
+ * @typeParam F - Тип выходного значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param fn - Функция преобразования значения ошибки.
+ * @returns Преобразованный `Err` или исходный `Ok`.
+ * @since 0.1.0
+ * @see {@link map} - Transforms the success branch.
+ * @example
+ * ```ts
+ * import { Err, mapErr } from '@resultsafe/core-fp-result';
+ *
+ * const result = mapErr(Err('e1'), (error) => `mapped:${error}`);
+ * console.log(result.ok); // false
+ * ```
+ * @public
+ */
+export declare const mapErr: <T, E, F>(result: Result<T, E>, fn: (error: E) => F) => Result<T, F>;
+//# sourceMappingURL=mapErr.d.ts.map

package/dist/types/methods/mapErr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapErr.d.ts","sourceRoot":"","sources":["../../../src/methods/mapErr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC5B,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,KAClB,MAAM,CAAC,CAAC,EAAE,CAAC,CAGgB,CAAC"}

package/dist/types/methods/match.d.ts

@@ -0,0 +1,24 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Выполняет сопоставление `Result` в единое выходное значение.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @typeParam U - The output type returned by both handlers.
+ * @param result - Исходный `Result`.
+ * @param okFn - Обработчик для ветки успеха.
+ * @param errFn - Обработчик для ветки ошибки.
+ * @returns Выходное значение, полученное от выбранного обработчика.
+ * @since 0.1.0
+ * @see {@link unwrapOrElse} - Similar shape with default fallback semantics.
+ * @example
+ * ```ts
+ * import { Ok, match } from '@resultsafe/core-fp-result';
+ *
+ * const value = match(Ok(3), (x) => `ok:${x}`, (e) => `err:${e}`);
+ * console.log(value); // ok:3
+ * ```
+ * @public
+ */
+export declare const match: <T, E, U>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => U) => U;
+//# sourceMappingURL=match.d.ts.map

package/dist/types/methods/match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../../src/methods/match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC3B,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,MAAM,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EACrB,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,KACrB,CAOF,CAAC"}

package/dist/types/methods/ok.d.ts

@@ -0,0 +1,22 @@
+import { type Option } from '../shared-types.js';
+import { type Result } from '../shared-types.js';
+/**
+ * Извлекает успешную ветку в виде `Option`.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @returns `Some(value)` для `Ok`, иначе `None`.
+ * @since 0.1.0
+ * @see {@link err} - Извлекает ветку ошибки.
+ * @example
+ * ```ts
+ * import { Ok, ok } from '@resultsafe/core-fp-result';
+ *
+ * const value = ok(Ok(10));
+ * console.log(value.some); // true
+ * ```
+ * @public
+ */
+export declare const ok: <T, E>(result: Result<T, E>) => Option<T>;
+//# sourceMappingURL=ok.d.ts.map

package/dist/types/methods/ok.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ok.d.ts","sourceRoot":"","sources":["../../../src/methods/ok.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAKjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CACd,CAAC"}

package/dist/types/methods/orElse.d.ts

@@ -0,0 +1,23 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Восстанавливается из ошибки, преобразуя `Err` в другой `Result`.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип входного значения ошибки.
+ * @typeParam F - Тип выходного значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param fn - Функция восстановления, применяемая для `Err`.
+ * @returns Восстановленный `Result` или исходный `Ok`.
+ * @since 0.1.0
+ * @see {@link andThen} - Цепляет ветку успеха.
+ * @example
+ * ```ts
+ * import { Err, Ok, orElse } from '@resultsafe/core-fp-result';
+ *
+ * const result = orElse(Err('network'), () => Ok('cached'));
+ * console.log(result.ok); // true
+ * ```
+ * @public
+ */
+export declare const orElse: <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>) => Result<T, F>;
+//# sourceMappingURL=orElse.d.ts.map

package/dist/types/methods/orElse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orElse.d.ts","sourceRoot":"","sources":["../../../src/methods/orElse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC5B,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAC7B,MAAM,CAAC,CAAC,EAAE,CAAC,CAC+C,CAAC"}

package/dist/types/methods/tap.d.ts

@@ -0,0 +1,22 @@
+import type { Result } from '../shared-types.js';
+/**
+ * Выполняет побочный эффект для значения `Ok` и возвращает входной `Result`.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param fn - Колбэк побочного эффекта для ветки успеха.
+ * @returns Неизмененный `Result`.
+ * @since 0.1.0
+ * @see {@link tapErr} - Executes a side effect for the error branch.
+ * @example
+ * ```ts
+ * import { Ok, tap } from '@resultsafe/core-fp-result';
+ *
+ * const result = tap(Ok(1), (value) => console.log(value)); // 1
+ * console.log(result.ok); // true
+ * ```
+ * @public
+ */
+export declare const tap: <T, E>(result: Result<T, E>, fn: (value: T) => void) => Result<T, E>;
+//# sourceMappingURL=tap.d.ts.map

package/dist/types/methods/tap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.d.ts","sourceRoot":"","sources":["../../../src/methods/tap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EACtB,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KACrB,MAAM,CAAC,CAAC,EAAE,CAAC,CAKb,CAAC"}

package/dist/types/methods/tapErr.d.ts

@@ -0,0 +1,22 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Выполняет побочный эффект для значения `Err` и возвращает входной `Result`.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param fn - Колбэк побочного эффекта для ветки ошибки.
+ * @returns Неизмененный `Result`.
+ * @since 0.1.0
+ * @see {@link tap} - Executes a side effect for the success branch.
+ * @example
+ * ```ts
+ * import { Err, tapErr } from '@resultsafe/core-fp-result';
+ *
+ * const result = tapErr(Err('boom'), (error) => console.log(error)); // boom
+ * console.log(result.ok); // false
+ * ```
+ * @public
+ */
+export declare const tapErr: <T, E>(result: Result<T, E>, fn: (error: E) => void) => Result<T, E>;
+//# sourceMappingURL=tapErr.d.ts.map

package/dist/types/methods/tapErr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tapErr.d.ts","sourceRoot":"","sources":["../../../src/methods/tapErr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EACzB,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KACrB,MAAM,CAAC,CAAC,EAAE,CAAC,CAKb,CAAC"}

package/dist/types/methods/transpose.d.ts

@@ -0,0 +1,22 @@
+import { type Option } from '../shared-types.js';
+import { type Result } from '../shared-types.js';
+/**
+ * Преобразует `Result<Option<T>, E>` в `Option<Result<T, E>>`.
+ *
+ * @typeParam T - The success value type inside `Option`.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`, содержащий `Option`.
+ * @returns Транспонированный `Option<Result<T, E>>`.
+ * @since 0.1.0
+ * @see {@link flatten} - Collapses nested `Result` values.
+ * @example
+ * ```ts
+ * import { Ok, transpose } from '@resultsafe/core-fp-result';
+ *
+ * const value = transpose(Ok({ some: true, value: 2 }));
+ * console.log(value.some); // true
+ * ```
+ * @public
+ */
+export declare const transpose: <T, E>(result: Result<Option<T>, E>) => Option<Result<T, E>>;
+//# sourceMappingURL=transpose.d.ts.map

package/dist/types/methods/transpose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpose.d.ts","sourceRoot":"","sources":["../../../src/methods/transpose.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAC5B,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAC3B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAOrB,CAAC"}

package/dist/types/methods/unwrap.d.ts

@@ -0,0 +1,22 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Возвращает успешное значение или выбрасывает исключение, если результат `Err`.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @returns Payload успеха.
+ * @throws Error - Выбрасывает исключение при вызове на `Err`.
+ * @since 0.1.0
+ * @see {@link unwrapOr} - Возвращает fallback вместо выброса исключения.
+ * @example
+ * ```ts
+ * import { Ok, unwrap } from '@resultsafe/core-fp-result';
+ *
+ * const value = unwrap(Ok(9));
+ * console.log(value); // 9
+ * ```
+ * @public
+ */
+export declare const unwrap: <T, E>(result: Result<T, E>) => T;
+//# sourceMappingURL=unwrap.d.ts.map

package/dist/types/methods/unwrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrap.d.ts","sourceRoot":"","sources":["../../../src/methods/unwrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAKnD,CAAC"}

package/dist/types/methods/unwrapErr.d.ts

@@ -0,0 +1,22 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Возвращает значение ошибки или выбрасывает исключение, если результат `Ok`.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @returns Payload ошибки.
+ * @throws Error - Выбрасывает исключение при вызове на `Ok`.
+ * @since 0.1.0
+ * @see {@link unwrapOrElse} - Возвращает fallback успеха без выброса исключения.
+ * @example
+ * ```ts
+ * import { Err, unwrapErr } from '@resultsafe/core-fp-result';
+ *
+ * const error = unwrapErr(Err('boom'));
+ * console.log(error); // boom
+ * ```
+ * @public
+ */
+export declare const unwrapErr: <T, E>(result: Result<T, E>) => E;
+//# sourceMappingURL=unwrapErr.d.ts.map

package/dist/types/methods/unwrapErr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapErr.d.ts","sourceRoot":"","sources":["../../../src/methods/unwrapErr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAKtD,CAAC"}

package/dist/types/methods/unwrapOr.d.ts

@@ -0,0 +1,22 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Возвращает успешное значение или переданный fallback по умолчанию.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param defaultValue - Fallback-значение для `Err`.
+ * @returns Payload успеха или `defaultValue`.
+ * @since 0.1.0
+ * @see {@link unwrapOrElse} - Вычисляет fallback лениво.
+ * @example
+ * ```ts
+ * import { Err, unwrapOr } from '@resultsafe/core-fp-result';
+ *
+ * const value = unwrapOr(Err('boom'), 0);
+ * console.log(value); // 0
+ * ```
+ * @public
+ */
+export declare const unwrapOr: <T, E>(result: Result<T, E>, defaultValue: T) => T;
+//# sourceMappingURL=unwrapOr.d.ts.map

package/dist/types/methods/unwrapOr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapOr.d.ts","sourceRoot":"","sources":["../../../src/methods/unwrapOr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,CAAC,KAAG,CAC3B,CAAC"}

package/dist/types/methods/unwrapOrElse.d.ts

@@ -0,0 +1,22 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Возвращает успешное значение или вычисляет fallback из ошибки.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param fn - Функция-поставщик fallback для `Err`.
+ * @returns Payload успеха или вычисленный fallback.
+ * @since 0.1.0
+ * @see {@link unwrapOr} - Использует eager fallback-значение.
+ * @example
+ * ```ts
+ * import { Err, unwrapOrElse } from '@resultsafe/core-fp-result';
+ *
+ * const value = unwrapOrElse(Err('fatal'), (error) => error.length);
+ * console.log(value); // 5
+ * ```
+ * @public
+ */
+export declare const unwrapOrElse: <T, E>(result: Result<T, E>, fn: (error: E) => T) => T;
+//# sourceMappingURL=unwrapOrElse.d.ts.map

package/dist/types/methods/unwrapOrElse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapOrElse.d.ts","sourceRoot":"","sources":["../../../src/methods/unwrapOrElse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,CAAC,EAC/B,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,KAClB,CAMF,CAAC"}

package/dist/types/refiners/index.d.ts

@@ -0,0 +1,11 @@
+export { isTypedVariant } from './isTypedVariant.js';
+export { isTypedVariantOf } from './isTypedVariantOf.js';
+export { matchVariant } from './matchVariant.js';
+export { matchVariantStrict } from './matchVariantStrict.js';
+export { refineAsyncResult } from './refineAsyncResult.js';
+export { refineAsyncResultU } from './refineAsyncResultU.js';
+export { refineResult } from './refineResult.js';
+export { refineResultU } from './refineResultU.js';
+export { refineVariantMap } from './refineVariantMap.js';
+export type * from './types/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/refiners/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/refiners/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,mBAAmB,kBAAkB,CAAC"}

package/dist/types/refiners/isTypedVariant.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Создает runtime type guard для варианта дискриминированного объединения.
+ *
+ * @typeParam K - The discriminant literal type.
+ * @param variant - Значение дискриминанта для сопоставления.
+ * @returns A predicate that checks `{ type: K }` shape.
+ * @since 0.1.0
+ * @see {@link isTypedVariantOf} - Расширяет проверку ключами payload.
+ * @example
+ * ```ts
+ * import { isTypedVariant } from '@resultsafe/core-fp-result';
+ *
+ * const isCreated = isTypedVariant('created');
+ * console.log(isCreated({ type: 'created' })); // true
+ * ```
+ * @public
+ */
+export declare const isTypedVariant: <K extends string>(variant: K) => (value: unknown) => value is {
+    type: K;
+};
+//# sourceMappingURL=isTypedVariant.d.ts.map

package/dist/types/refiners/isTypedVariant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTypedVariant.d.ts","sourceRoot":"","sources":["../../../src/refiners/isTypedVariant.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,GACxB,CAAC,SAAS,MAAM,EAAE,SAAS,CAAC,MAC5B,OAAO,OAAO,KAAG,KAAK,IAAI;IAAE,IAAI,EAAE,CAAC,CAAA;CAMnC,CAAC"}

package/dist/types/refiners/isTypedVariantOf.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Создает runtime type guard для варианта с дополнительными ключами payload.
+ *
+ * @typeParam K - The discriminant literal type.
+ * @typeParam T - The required payload record shape.
+ * @param variant - Значение дискриминанта для сопоставления.
+ * @returns A predicate that checks variant and payload key presence.
+ * @since 0.1.0
+ * @see {@link isTypedVariant} - Проверяет только дискриминант.
+ * @example
+ * ```ts
+ * import { isTypedVariantOf } from '@resultsafe/core-fp-result';
+ *
+ * const isCreated = isTypedVariantOf<'created', { id: unknown }>('created');
+ * console.log(isCreated({ type: 'created', id: 1 })); // true
+ * ```
+ * @public
+ */
+export declare const isTypedVariantOf: <K extends string, T extends Record<string, unknown>>(variant: K) => (value: unknown) => value is {
+    type: K;
+} & T;
+//# sourceMappingURL=isTypedVariantOf.d.ts.map

package/dist/types/refiners/isTypedVariantOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTypedVariantOf.d.ts","sourceRoot":"","sources":["../../../src/refiners/isTypedVariantOf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,CAAC,MAC/D,OAAO,OAAO,KAAG,KAAK,IAAI;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,GAAG,CAexC,CAAC"}

package/dist/types/refiners/matchVariant.d.ts

@@ -0,0 +1,27 @@
+import type { Matcher, VariantOf } from './types/index.js';
+/**
+ * Создает цепочный matcher для значения дискриминированного объединения.
+ *
+ * @typeParam T - Тип дискриминированного объединения.
+ * @param value - Значение объединения для сопоставления.
+ * @returns Fluent matcher с ветками `with` и `otherwise`.
+ * @since 0.1.0
+ * @see {@link matchVariantStrict} - Требует исчерпывающего сопоставления во время выполнения.
+ * @example
+ * ```ts
+ * import { matchVariant } from '@resultsafe/core-fp-result';
+ *
+ * const out = matchVariant<{ type: 'ok'; value: number } | { type: 'err'; error: string }>({
+ *   type: 'ok',
+ *   value: 1,
+ * })
+ *   .with('ok', (v) => `ok:${v.value}`)
+ *   .otherwise(() => 'fallback')
+ *   .run();
+ *
+ * console.log(out); // ok:1
+ * ```
+ * @public
+ */
+export declare const matchVariant: <T extends VariantOf>(value: T) => Matcher<T, unknown>;
+//# sourceMappingURL=matchVariant.d.ts.map

package/dist/types/refiners/matchVariant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchVariant.d.ts","sourceRoot":"","sources":["../../../src/refiners/matchVariant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,SAAS,EAC9C,OAAO,CAAC,KACP,OAAO,CAAC,CAAC,EAAE,OAAO,CAkEpB,CAAC"}

package/dist/types/refiners/matchVariantStrict.d.ts

@@ -0,0 +1,28 @@
+import type { MatchBuilder, VariantOf } from './types/index.js';
+/**
+ * Создает строгий matcher, выбрасывающий исключение для необработанных вариантов.
+ *
+ * @typeParam T - Тип дискриминированного объединения.
+ * @param value - Значение объединения для сопоставления.
+ * @returns Строгий builder сопоставления, требующий явных обработчиков.
+ * @throws Error - Выбрасывает исключение, если ни один зарегистрированный обработчик не соответствует `value.type`.
+ * @since 0.1.0
+ * @see {@link matchVariant} - Использует fallback-ветку вместо выброса исключения.
+ * @example
+ * ```ts
+ * import { matchVariantStrict } from '@resultsafe/core-fp-result';
+ *
+ * const out = matchVariantStrict<{ type: 'ok'; value: number } | { type: 'err'; error: string }>({
+ *   type: 'err',
+ *   error: 'boom',
+ * })
+ *   .with('ok', (v) => `ok:${v.value}`)
+ *   .with('err', (v) => `err:${v.error}`)
+ *   .run();
+ *
+ * console.log(out); // err:boom
+ * ```
+ * @public
+ */
+export declare const matchVariantStrict: <T extends VariantOf>(value: T) => MatchBuilder<T, unknown>;
+//# sourceMappingURL=matchVariantStrict.d.ts.map

package/dist/types/refiners/matchVariantStrict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchVariantStrict.d.ts","sourceRoot":"","sources":["../../../src/refiners/matchVariantStrict.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,SAAS,EACpD,OAAO,CAAC,KACP,YAAY,CAAC,CAAC,EAAE,OAAO,CA8CzB,CAAC"}