@typed/async-data 0.13.0 → 1.0.0-beta.0

package/src/index.ts

@@ -1,4 +1,291 @@
-export * from './AsyncData.js'
-export * from './LazyRef.js'
-export * from './Progress.js'
-export * from './TypeId.js'
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import { dual } from "effect/Function";
+import * as Option from "effect/Option";
+import { hasProperty, isObject, isString } from "effect/Predicate";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import type { Unify } from "effect/Unify";
+
+export interface Progress {
+  readonly loaded: number;
+  readonly total?: number | undefined;
+}
+
+export interface NoData {
+  readonly _tag: "NoData";
+}
+
+export interface Loading {
+  readonly _tag: "Loading";
+  readonly progress?: Progress | undefined;
+}
+
+export interface Success<A> {
+  readonly _tag: "Success";
+  readonly value: A;
+  readonly progress?: Progress | undefined;
+}
+
+export interface Failure<E> {
+  readonly _tag: "Failure";
+  readonly cause: Cause.Cause<E>;
+  readonly progress?: Progress | undefined;
+}
+
+export interface Optimistic<A, E> {
+  readonly _tag: "Optimistic";
+  readonly value: A;
+  readonly previous: AsyncData<A, E>;
+}
+
+export type AsyncData<A, E> = NoData | Loading | Success<A> | Failure<E> | Optimistic<A, E>;
+
+export type Refreshing<A, E> = (Success<A> | Failure<E>) & { readonly progress: Progress };
+
+export const AsyncData = <const A extends Schema.Top, E extends Schema.Top>(
+  A: A,
+  E: E,
+): Schema.Codec<
+  AsyncData<A["Type"], E["Type"]>,
+  AsyncData<A["Encoded"], E["Encoded"]>,
+  A["DecodingServices"] | E["DecodingServices"],
+  A["EncodingServices"] | E["EncodingServices"]
+> => {
+  const Progress = Schema.Struct({ loaded: Schema.Number, total: Schema.optional(Schema.Number) });
+  const NoData = Schema.Struct({ _tag: Schema.tag("NoData") });
+  const Loading = Schema.Struct({
+    _tag: Schema.tag("Loading"),
+    progress: Schema.optional(Progress),
+  });
+  const Success = Schema.Struct({
+    _tag: Schema.tag("Success"),
+    value: A,
+    progress: Schema.optional(Progress),
+  });
+  const Failure = Schema.Struct({
+    _tag: Schema.tag("Failure"),
+    cause: E,
+    progress: Schema.optional(Progress),
+  });
+  const Optimistic = Schema.Struct({
+    _tag: Schema.tag("Optimistic"),
+    value: A,
+    previous: Schema.suspend(() => AsyncData),
+  });
+  const AsyncData = Schema.Union([NoData, Loading, Success, Failure, Optimistic]) as Schema.Codec<
+    AsyncData<A["Type"], E["Type"]>,
+    AsyncData<A["Encoded"], E["Encoded"]>,
+    A["DecodingServices"] | E["DecodingServices"],
+    A["EncodingServices"] | E["EncodingServices"]
+  >;
+  return AsyncData;
+};
+
+export const isNoData = <A, E>(asyncData: AsyncData<A, E>): asyncData is NoData =>
+  asyncData._tag === "NoData";
+export const isLoading = <A, E>(asyncData: AsyncData<A, E>): asyncData is Loading =>
+  asyncData._tag === "Loading";
+export const isSuccess = <A, E>(asyncData: AsyncData<A, E>): asyncData is Success<A> =>
+  asyncData._tag === "Success";
+export const isFailure = <A, E>(asyncData: AsyncData<A, E>): asyncData is Failure<E> =>
+  asyncData._tag === "Failure";
+export const isOptimistic = <A, E>(asyncData: AsyncData<A, E>): asyncData is Optimistic<A, E> =>
+  asyncData._tag === "Optimistic";
+
+const TAGS = new Set(["NoData", "Loading", "Success", "Failure", "Optimistic"]);
+
+export const isAsyncData = <A, E>(u: unknown): u is AsyncData<A, E> =>
+  isObject(u) && hasProperty(u, "_tag") && isString(u._tag) && TAGS.has(u._tag);
+
+export const isRefreshing = <A, E>(asyncData: AsyncData<A, E>): asyncData is Refreshing<A, E> =>
+  (asyncData._tag === "Success" || asyncData._tag === "Failure") &&
+  asyncData.progress !== undefined;
+
+export const isPending = <A, E>(
+  asyncData: AsyncData<A, E>,
+): asyncData is Loading | Refreshing<A, E> =>
+  asyncData._tag === "Loading" || isRefreshing(asyncData);
+
+export const NoData: NoData = { _tag: "NoData" };
+
+export const loading = (progress?: Progress): Loading => ({ _tag: "Loading", progress });
+
+export const success = <A>(value: A, progress?: Progress): Success<A> => ({
+  _tag: "Success",
+  value,
+  progress,
+});
+
+export const failure = <E>(cause: Cause.Cause<E>, progress?: Progress): Failure<E> => ({
+  _tag: "Failure",
+  cause,
+  progress,
+});
+
+export const optimistic = <A, E>(previous: AsyncData<A, E>, value: A): Optimistic<A, E> => ({
+  _tag: "Optimistic",
+  value,
+  previous,
+});
+
+export const startLoading = <A, E>(data: AsyncData<A, E>, progress?: Progress): AsyncData<A, E> => {
+  if (isSuccess(data)) {
+    return success(data.value, progress);
+  } else if (isFailure(data)) {
+    return failure(data.cause, progress);
+  } else if (isOptimistic(data)) {
+    return optimistic(startLoading(data.previous, progress), data.value);
+  } else {
+    return loading(progress);
+  }
+};
+
+export const stopLoading = <A, E>(data: AsyncData<A, E>): AsyncData<A, E> => {
+  if (isSuccess(data)) {
+    return success(data.value);
+  } else if (isFailure(data)) {
+    return failure(data.cause);
+  } else if (isOptimistic(data)) {
+    return optimistic(stopLoading(data.previous), data.value);
+  } else {
+    return data;
+  }
+};
+
+export const match: {
+  <A, E, R1, R2, R3, R4, R5>(matchers: {
+    NoData: (data: NoData) => R1;
+    Loading: (data: Loading) => R2;
+    Failure: (cause: Cause.Cause<E>, data: Failure<E>) => R3;
+    Success: (value: A, data: Success<A>) => R4;
+    Optimistic: (value: A, data: Optimistic<A, E>) => R5;
+  }): (data: AsyncData<A, E>) => Unify<R1 | R2 | R3 | R4 | R5>;
+
+  <A, E, R1, R2, R3, R4, R5>(
+    data: AsyncData<A, E>,
+    matchers: {
+      NoData: (data: NoData) => R1;
+      Loading: (data: Loading) => R2;
+      Failure: (cause: Cause.Cause<E>, data: Failure<E>) => R3;
+      Success: (value: A, data: Success<A>) => R4;
+      Optimistic: (value: A, data: Optimistic<A, E>) => R5;
+    },
+  ): Unify<R1 | R2 | R3 | R4 | R5>;
+} = dual(
+  2,
+  <A, E, R1, R2, R3, R4, R5>(
+    data: AsyncData<A, E>,
+    matchers: {
+      NoData: (data: NoData) => R1;
+      Loading: (data: Loading) => R2;
+      Failure: (cause: Cause.Cause<E>, data: Failure<E>) => R3;
+      Success: (value: A, data: Success<A>) => R4;
+      Optimistic: (value: A, data: Optimistic<A, E>) => R5;
+    },
+  ): Unify<R1 | R2 | R3 | R4> => {
+    if (isSuccess(data)) {
+      return matchers.Success(data.value, data) as Unify<R1 | R2 | R3 | R4>;
+    } else if (isFailure(data)) {
+      return matchers.Failure(data.cause, data) as Unify<R1 | R2 | R3 | R4>;
+    } else if (isLoading(data)) {
+      return matchers.Loading(data) as Unify<R1 | R2 | R3 | R4>;
+    } else if (isNoData(data)) {
+      return matchers.NoData(data) as Unify<R1 | R2 | R3 | R4>;
+    } else {
+      return matchers.Optimistic(data.value, data) as Unify<R1 | R2 | R3 | R4>;
+    }
+  },
+);
+
+export function getSuccess<A, E>(data: AsyncData<A, E>): Option.Option<A> {
+  return match(data, {
+    NoData: Option.none,
+    Loading: Option.none,
+    Failure: Option.none,
+    Success: Option.some,
+    Optimistic: Option.some,
+  });
+}
+
+/**
+ * @since 1.0.0
+ */
+export function getCause<A, E>(data: AsyncData<A, E>): Option.Option<Cause.Cause<E>> {
+  return match(data, {
+    NoData: Option.none,
+    Loading: Option.none,
+    Failure: Option.some,
+    Success: Option.none,
+    Optimistic: Option.none,
+  });
+}
+
+/**
+ * @since 1.0.0
+ */
+export function getError<A, E>(data: AsyncData<A, E>): Option.Option<E> {
+  return match(data, {
+    NoData: Option.none,
+    Loading: Option.none,
+    Failure: Cause.findErrorOption,
+    Success: Option.none,
+    Optimistic: Option.none,
+  });
+}
+
+export const map: {
+  <A, B>(f: (a: A) => B): <E>(data: AsyncData<A, E>) => AsyncData<B, E>;
+  <A, E, B>(data: AsyncData<A, E>, f: (a: A) => B): AsyncData<B, E>;
+} = dual(2, function map<A, E, B>(data: AsyncData<A, E>, f: (a: A) => B): AsyncData<B, E> {
+  if (isSuccess(data)) {
+    return success(f(data.value), data.progress);
+  } else if (isOptimistic(data)) {
+    return optimistic(map(data.previous, f), f(data.value));
+  } else {
+    return data;
+  }
+});
+
+export const flatMap: {
+  <A, E, B, E2>(
+    f: (a: A, data: Success<A> | Optimistic<A, E>) => AsyncData<B, E2>,
+  ): (data: AsyncData<A, E>) => AsyncData<B, E | E2>;
+  <A, E, B, E2>(
+    data: AsyncData<A, E>,
+    f: (a: A, data: Success<A> | Optimistic<A, E>) => AsyncData<B, E>,
+  ): AsyncData<B, E | E2>;
+} = dual(2, function <
+  A,
+  E,
+  B,
+  E2,
+>(data: AsyncData<A, E>, f: (a: A, data: Success<A> | Optimistic<A, E>) => AsyncData<B, E2>): AsyncData<
+  B,
+  E | E2
+> {
+  if (isSuccess(data) || isOptimistic(data)) {
+    return f(data.value, data);
+  } else {
+    return data;
+  }
+});
+
+export const mapError: {
+  <A, E, E2>(f: (e: E) => E2): (data: AsyncData<A, E>) => AsyncData<A, E2>;
+  <A, E, E2>(data: AsyncData<A, E>, f: (e: E) => E2): AsyncData<A, E2>;
+} = dual(2, function mapError<A, E, E2>(data: AsyncData<A, E>, f: (e: E) => E2): AsyncData<A, E2> {
+  if (isFailure(data)) {
+    return failure(Cause.map(data.cause, f), data.progress);
+  } else if (isOptimistic(data)) {
+    return optimistic(mapError(data.previous, f), data.value);
+  } else {
+    return data;
+  }
+});
+
+export const fromExit = <A, E>(exit: Exit.Exit<A, E>): AsyncData<A, E> =>
+  Exit.isSuccess(exit) ? success(exit.value) : failure(exit.cause);
+
+export const fromResult = <A, E>(result: Result.Result<A, E>): AsyncData<A, E> =>
+  Result.isSuccess(result) ? success(result.success) : failure(Cause.fail(result.failure));

package/tsconfig.json

@@ -1,27 +1,6 @@
 {
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": [
-      "ES2022",
-      "DOM"
-    ],
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "sourceMap": true,
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "**/*.test.ts"
-  ]
-}
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": { "rootDir": "src", "outDir": "dist" },
+  "include": ["src"],
+  "exclude": ["**/*.test.ts"]
+}

package/.nvmrc

@@ -1 +0,0 @@
-22

package/biome.json

@@ -1,36 +0,0 @@
-{
-  "organizeImports": {
-    "enabled": true
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true,
-      "suspicious": {
-        "noExplicitAny": "off",
-        "noAssignInExpressions": "off",
-        "noShadowRestrictedNames": "off"
-      },
-      "style": {
-        "noParameterAssign": "off",
-        "noUselessElse": "off"
-      },
-      "complexity": {
-        "noBannedTypes": "off"
-      }
-    }
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "lineWidth": 100
-  },
-  "javascript": {
-    "formatter": {
-      "quoteStyle": "single",
-      "trailingCommas": "all",
-      "semicolons": "asNeeded"
-    }
-  }
-}

package/dist/AsyncData.d.ts

@@ -1,196 +0,0 @@
-import { Cause, Effect, Either, Equivalence, Exit, Option, Schema, Unify } from 'effect';
-import { Progress, type ProgressEncoded } from './Progress.js';
-export type AsyncData<A, E = never> = NoData | Loading | Success<A> | Failure<E> | Refreshing<A, E> | Optimistic<A, E>;
-export declare namespace AsyncData {
-    export type Encoded<A, E = never> = typeof NoData.Encoded | typeof Loading.Encoded | SuccessEncoded<A> | FailureEncoded<E> | RefreshingEncoded<A, E> | OptimisticEncoded<A, E>;
-    export interface SuccessEncoded<A> {
-        readonly _tag: 'Success';
-        readonly value: A;
-    }
-    export interface FailureEncoded<E> {
-        readonly _tag: 'Failure';
-        readonly cause: Schema.CauseEncoded<E, unknown>;
-    }
-    export type RefreshingEncoded<A, E = never> = {
-        readonly _tag: 'Refreshing';
-        readonly previous: SuccessEncoded<A> | FailureEncoded<E>;
-        readonly progress?: ProgressEncoded;
-    };
-    export interface OptimisticEncoded<A, E = never> {
-        readonly _tag: 'Optimistic';
-        readonly previous: Encoded<A, E>;
-        readonly value: A;
-    }
-    /**
-     * @category models
-     * @since 1.0.0
-     */
-    export interface Unify<A extends {
-        [Unify.typeSymbol]?: any;
-    }> extends Effect.EffectUnify<A> {
-        AsyncData: () => Unify_<A[Unify.typeSymbol]> extends AsyncData<infer E0, infer A0> | infer _ ? AsyncData<E0, A0> : never;
-    }
-    type Unify_<T extends AsyncData<any, any>> = T extends NoData ? AsyncData<never, never> : T extends Loading ? AsyncData<never, never> : T extends Failure<infer E> ? AsyncData<E, never> : T extends Success<infer A> ? AsyncData<never, A> : T extends Optimistic<infer A, infer E> ? AsyncData<A, E> : T extends Refreshing<infer A, infer E> ? AsyncData<A, E> : never;
-    /**
-     * @category models
-     * @since 1.0.0
-     */
-    export interface IgnoreList extends Effect.EffectUnifyIgnore {
-        Effect: true;
-    }
-    export {};
-}
-declare const NoData_base: Schema.TaggedErrorClass<NoData, "NoData", {
-    readonly _tag: Schema.tag<"NoData">;
-}>;
-export declare class NoData extends NoData_base implements Effect.Effect<never, NoData, never> {
-}
-export declare const noData: {
-    (): NoData;
-    <A, E = never>(): AsyncData<A, E>;
-};
-declare const Loading_base: Schema.TaggedErrorClass<Loading, "Loading", {
-    readonly _tag: Schema.tag<"Loading">;
-} & {
-    progress: Schema.optionalWith<Schema.Struct<{
-        loaded: typeof Schema.Number;
-        total: Schema.optionalWith<typeof Schema.Number, {
-            as: "Option";
-            default: undefined;
-        }>;
-    }>, {
-        as: "Option";
-        default: undefined;
-    }>;
-}>;
-export declare class Loading extends Loading_base implements Effect.Effect<never, Loading, never> {
-}
-export declare function loading(progress?: Progress): Loading;
-export declare function loading<A, E = never>(progress?: Progress): AsyncData<A, E>;
-declare const Success_base: import("./_internal.js").DataEffectClass<"Success">;
-export declare class Success<A> extends Success_base<{
-    readonly value: A;
-}, A> implements Effect.Effect<A> {
-    constructor(value: A);
-    static schema<A, I, R>(value: Schema.Schema<A, I, R>): Schema.SchemaClass<Success<A>, AsyncData.SuccessEncoded<I>, R>;
-}
-export declare function success<A>(value: A): Success<A>;
-export declare function success<A, E = never>(value: A): AsyncData<A, E>;
-declare const Failure_base: import("./_internal.js").DataEffectClass<"Failure">;
-export declare class Failure<E> extends Failure_base<{
-    readonly cause: Cause.Cause<E>;
-}, never, E, never> implements Effect.Effect<never, E, never> {
-    constructor(cause: Cause.Cause<E>);
-    static schema<E, I, R>(error: Schema.Schema<E, I, R>): Schema.SchemaClass<Failure<E>, AsyncData.FailureEncoded<I>, R>;
-}
-export declare function failure<E>(cause: Cause.Cause<E>): Failure<E>;
-export declare function failure<E, A = never>(cause: Cause.Cause<E>): AsyncData<A, E>;
-export declare function die(cause: unknown): Failure<never>;
-export declare function die<A, E = never>(cause: unknown): AsyncData<A, E>;
-export declare function fail<E>(error: E): Failure<E>;
-declare const Refreshing_base: import("./_internal.js").DataEffectClass<"Refreshing">;
-export declare class Refreshing<A, E> extends Refreshing_base<{
-    readonly previous: Success<A> | Failure<E>;
-    readonly progress: Option.Option<Progress>;
-}, A, E, never> implements Effect.Effect<A, E> {
-    constructor(previous: Success<A> | Failure<E>, progress: Option.Option<Progress>);
-    static schema<A, EI, E, AI, R>(previous: Schema.Schema<Success<A> | Failure<E>, AsyncData.SuccessEncoded<AI> | AsyncData.FailureEncoded<EI>, R>): Schema.SchemaClass<Refreshing<A, E>, AsyncData.RefreshingEncoded<AI, EI>, R>;
-}
-export declare function refreshing<A = never, E = never>(previous: Success<A> | Failure<E>, progress?: Progress): Refreshing<A, E>;
-declare const Optimistic_base: import("./_internal.js").DataEffectClass<"Optimistic">;
-export declare class Optimistic<A, E> extends Optimistic_base<{
-    readonly previous: AsyncData<A, E>;
-    readonly value: A;
-}, A> implements Effect.Effect<A> {
-    constructor(previous: AsyncData<A, E>, value: A);
-    static schema<A, EI, E, AI, R, R2>(previous: Schema.Schema<AsyncData<A, E>, AsyncData.Encoded<AI, EI>, R>, value: Schema.Schema<A, AI, R2>): Schema.SchemaClass<Optimistic<A, E>, AsyncData.OptimisticEncoded<AI, EI>, R | R2>;
-}
-export declare const optimistic: {
-    <A>(value: A): <E>(previous: AsyncData<A, E>) => Optimistic<A, E>;
-    <A, E>(previous: AsyncData<A, E>, value: A): Optimistic<A, E>;
-};
-export declare const matchAll: {
-    <A, E, R1, R2, R3, R4, R5, R6>(data: AsyncData<A, E>, matchers: {
-        readonly NoData: () => R1;
-        readonly Loading: (progress: Option.Option<Progress>) => R2;
-        readonly Success: (value: A) => R3;
-        readonly Failure: (cause: Cause.Cause<E>) => R4;
-        readonly Refreshing: (previous: Success<A> | Failure<E>, progress: Option.Option<Progress>) => R5;
-        readonly Optimistic: (value: A, previous: AsyncData<A, E>) => R6;
-    }): R1 | R2 | R3 | R4 | R5 | R6;
-    <A, E, R1, R2, R3, R4, R5, R6>(data: AsyncData<A, E>, matchers: {
-        readonly NoData: () => R1;
-        readonly Loading: (progress: Option.Option<Progress>) => R2;
-        readonly Success: (value: A) => R3;
-        readonly Failure: (cause: Cause.Cause<E>) => R4;
-        readonly Refreshing: (previous: Success<A> | Failure<E>, progress: Option.Option<Progress>) => R5;
-        readonly Optimistic: (value: A, previous: AsyncData<A, E>) => R6;
-    }): R1 | R2 | R3 | R4 | R5 | R6;
-};
-export declare const match: {
-    <A, E, R1, R2, R3, R4>(matchers: {
-        readonly NoData: () => R1;
-        readonly Loading: (progress: Option.Option<Progress>) => R2;
-        readonly Success: (value: A, params: {
-            readonly isRefreshing: boolean;
-            readonly isOptimistic: boolean;
-            readonly progress: Option.Option<Progress>;
-        }) => R3;
-        readonly Failure: (cause: Cause.Cause<E>, params: {
-            readonly isRefreshing: boolean;
-            readonly progress: Option.Option<Progress>;
-        }) => R4;
-    }): (data: AsyncData<A, E>) => Unify.Unify<R1 | R2 | R3 | R4>;
-    <A, E, R1, R2, R3, R4>(data: AsyncData<A, E>, matchers: {
-        readonly NoData: () => R1;
-        readonly Loading: (progress: Option.Option<Progress>) => R2;
-        readonly Success: (value: A, params: {
-            readonly isRefreshing: boolean;
-            readonly isOptimistic: boolean;
-            readonly progress: Option.Option<Progress>;
-        }) => R3;
-        readonly Failure: (cause: Cause.Cause<E>, params: {
-            readonly isRefreshing: boolean;
-            readonly progress: Option.Option<Progress>;
-        }) => R4;
-    }): Unify.Unify<R1 | R2 | R3 | R4>;
-};
-export declare function startLoading<A, E>(data: AsyncData<A, E>, progress?: Progress): AsyncData<A, E>;
-export declare function stopLoading<A, E>(data: AsyncData<A, E>): AsyncData<A, E>;
-export declare function updateProgress<A, E>(data: AsyncData<A, E>, progress: Progress): AsyncData<A, E>;
-export interface AsyncDataSchemaClass<E, EI, ER, A, AI, AR> extends Schema.SchemaClass<AsyncData<A, E>, AsyncData.Encoded<AI, EI>, AR | ER> {
-    readonly eq: Equivalence.Equivalence<AsyncData<A, E>>;
-    readonly success: (value: A) => AsyncData<A, E>;
-    readonly failCause: (cause: Cause.Cause<E>) => AsyncData<A, E>;
-    readonly fail: (error: E) => AsyncData<A, E>;
-    readonly die: (cause: unknown) => AsyncData<A, E>;
-    readonly optimistic: (previous: AsyncData<A, E>, value: A) => AsyncData<A, E>;
-    readonly refreshing: (previous: Success<A> | Failure<E>, progress?: Progress) => AsyncData<A, E>;
-    readonly loading: (progress?: Progress) => AsyncData<A, E>;
-    readonly noData: () => AsyncData<A, E>;
-}
-export declare function AsyncData<A, AI, AR, E, EI, ER>(schemas: {
-    readonly success: Schema.Schema<A, AI, AR>;
-    readonly failure: Schema.Schema<E, EI, ER>;
-}, annotations?: Schema.Annotations.Schema<AsyncData<A, E>>): AsyncDataSchemaClass<E, EI, ER, A, AI, AR>;
-export declare function fromExit<A, E>(exit: Exit.Exit<A, E>): AsyncData<A, E>;
-export declare function fromEither<A, E>(either: Either.Either<A, E>): AsyncData<A, E>;
-export declare function fromOption<A>(option: Option.Option<A>): AsyncData<A>;
-export declare const map: {
-    <A, B>(f: (a: A) => B): <E>(data: AsyncData<A, E>) => AsyncData<B, E>;
-    <A, E, B>(data: AsyncData<A, E>, f: (a: A) => B): AsyncData<B, E>;
-};
-export declare const flatMap: {
-    <A, B, E2>(f: (a: A) => AsyncData<B, E2>): <E>(data: AsyncData<A, E>) => AsyncData<B, E | E2>;
-    <A, E, B, E2>(data: AsyncData<A, E>, f: (a: A) => AsyncData<B, E2>): AsyncData<B, E | E2>;
-};
-export declare function isNoData<A, E>(data: AsyncData<A, E>): data is NoData;
-export declare function isLoading<A, E>(data: AsyncData<A, E>): data is Loading;
-export declare function isSuccess<A, E>(data: AsyncData<A, E>): data is Success<A>;
-export declare function isFailure<A, E>(data: AsyncData<A, E>): data is Failure<E>;
-export declare function isRefreshing<A, E>(data: AsyncData<A, E>): data is Refreshing<A, E>;
-export declare function isLoadingOrRefreshing<A, E>(data: AsyncData<A, E>): data is Loading | Refreshing<A, E>;
-export declare function isOptimistic<A, E>(data: AsyncData<A, E>): data is Optimistic<A, E>;
-export declare function makeEquivalence<A, E>(eqA: Equivalence.Equivalence<A>, eqB: Equivalence.Equivalence<E>): Equivalence.Equivalence<AsyncData<A, E>>;
-export declare const equals: Equivalence.Equivalence<AsyncData<unknown, unknown>>;
-export {};