@fncts/base 0.0.21 → 0.0.22

package/_src/collection/compat/Record/instances.ts

@@ -1,151 +0,0 @@
-import type { Check } from "@fncts/typelevel/Check";
-
-import { CompoundError, MissingKeyError, OptionalKeyError, RequiredKeyError } from "@fncts/base/data/DecodeError";
-
-/**
- * @tsplus derive fncts.Guard<_> 15
- */
-export function deriveDictionaryGuard<A extends Record<string, any>>(
-  ...[value]: Check<Check.IsDictionary<A>> extends Check.True ? [value: Guard<A[keyof A]>] : never
-): Guard<A> {
-  return Guard((u): u is A => {
-    if (!Derive<Guard<{}>>().is(u)) {
-      return false;
-    }
-    for (const k of Object.keys(u)) {
-      if (!value.is(u[k])) {
-        return false;
-      }
-    }
-    return true;
-  });
-}
-
-/**
- * @tsplus derive fncts.Guard<_> 15
- */
-export function deriveGuard<A extends Record<string, any>>(
-  ...[key, value, requiredKeys]: Check<Check.IsRecord<A>> extends Check.True
-    ? [
-        key: Guard<keyof A>,
-        value: Guard<A[keyof A]>,
-        requiredKeys: {
-          [k in keyof A]: 0;
-        },
-      ]
-    : never
-): Guard<A> {
-  const requiredKeysSet = new Set(Object.keys(requiredKeys));
-  return Guard((record): record is A => {
-    const missing = new Set(requiredKeysSet);
-    if (!Derive<Guard<{}>>().is(record)) {
-      return false;
-    }
-    for (const k of Object.keys(record)) {
-      if (requiredKeysSet.has(k) && !value.is(record[k])) {
-        return false;
-      }
-      missing.delete(k);
-    }
-    return missing.size === 0;
-  });
-}
-
-/**
- * @tsplus derive fncts.Decoder<_> 15
- */
-export function deriveDecoder<A extends Record<string, any>>(
-  ...[keyGuard, valueDecoder, requiredKeysRecord]: [A] extends [Record<infer X, infer Y>]
-    ? Check<Check.Not<Check.IsUnion<A>> & Check.IsEqual<A, Record<X, Y>>> extends Check.True
-      ? [
-          keyGuard: Guard<X>,
-          valueDecoder: Decoder<Y>,
-          requiredKeysRecord: {
-            [k in X]: 0;
-          },
-        ]
-      : never
-    : never
-): Decoder<A> {
-  return Decoder((u) => {
-    const recordResult = Derive<Decoder<{}>>().decode(u);
-    if (recordResult.isLeft()) {
-      return recordResult;
-    }
-    const asRecord = recordResult.right;
-    const errors: Array<RequiredKeyError | OptionalKeyError> = [];
-    let errored   = false;
-    const missing = new Set(Object.keys(requiredKeysRecord));
-    const res     = {};
-    for (const k in asRecord) {
-      if (keyGuard.is(k)) {
-        const valueResult = valueDecoder.decode(asRecord[k]);
-        valueResult.match2(
-          (e) => {
-            errored = true;
-            errors.push(new (k in requiredKeysRecord ? RequiredKeyError : OptionalKeyError)(k, e));
-          },
-          (warning, a) => {
-            missing.delete(k);
-            res[k] = a;
-            if (warning.isJust()) {
-              errors.push(new (k in requiredKeysRecord ? RequiredKeyError : OptionalKeyError)(k, warning.value));
-            }
-          },
-        );
-      }
-    }
-    if (errored) {
-      return These.left(new CompoundError("record", Vector.from(errors)));
-    }
-    if (errors.length > 0) {
-      return These.both(new CompoundError("record", Vector.from(errors)), res as A);
-    }
-    if (missing.size > 0) {
-      return These.left(
-        new CompoundError(
-          "record",
-          Vector.from(missing).map((k) => new MissingKeyError(k)),
-        ),
-      );
-    }
-    return These.right(res as A);
-  }, `Record<string, ${valueDecoder.label}>`);
-}
-
-/**
- * @tsplus derive fncts.Encoder<_> 15
- */
-export function deriveDictionaryEncoder<A extends Record<string, any>>(
-  ...[value]: Check<Check.IsDictionary<A>> extends Check.True ? [value: Encoder<A[keyof A]>] : never
-): Encoder<A> {
-  return Encoder((inp) => {
-    const encoded = {};
-    for (const k of Object.keys(inp)) {
-      encoded[k] = value.encode(inp[k]);
-    }
-    return encoded;
-  });
-}
-
-/**
- * @tsplus derive fncts.Encoder<_> 15
- */
-export function deriveEncoder<A extends Record<string, any>>(
-  ...[value, requiredKeys]: Check<Check.IsRecord<A>> extends Check.True
-    ? [
-        value: Encoder<A[keyof A]>,
-        requiredKeys: {
-          [K in keyof A]: 0;
-        },
-      ]
-    : never
-): Encoder<A> {
-  return Encoder((inp) => {
-    const encoded = {};
-    for (const k of Object.keys(requiredKeys)) {
-      encoded[k] = value.encode(inp[k]);
-    }
-    return encoded;
-  });
-}

package/_src/collection/compat/Record.ts

@@ -1,3 +0,0 @@
-// codegen:start { preset: barrel, include: Record/*.ts }
-export * from "./Record/instances.js";
-// codegen:end

package/_src/collection/immutable/Conc/derivations.ts

@@ -1,41 +0,0 @@
-import type { Check } from "@fncts/typelevel/Check";
-
-/**
- * @tsplus derive fncts.Guard[fncts.Conc]<_> 10
- */
-export function deriveGuard<A extends Conc<any>>(
-  ...[elem]: [A] extends [Conc<infer _A>] ? [elem: Guard<_A>] : never
-): Guard<A> {
-  return Guard((u): u is A => {
-    if (Conc.is(u)) {
-      return u.every(elem.is);
-    }
-    return false;
-  });
-}
-
-/**
- * @tsplus derive fncts.Decoder[fncts.Conc]<_> 10
- */
-export function deriveDecoder<A extends Conc<any>>(
-  ...[array, elem]: [A] extends [Conc<infer _A>]
-    ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True
-      ? [array: Decoder<Array<_A>>, elem: Decoder<_A>]
-      : never
-    : never
-): Decoder<A> {
-  return Decoder((u) => array.decode(u).map((a) => Conc.from(a) as A), `Conc<${elem.label}>`);
-}
-
-/**
- * @tsplus derive fncts.Encoder[fncts.Conc]<_> 10
- */
-export function deriveEncoder<A extends Conc<any>>(
-  ...[element]: [A] extends [Conc<infer _A>]
-    ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True
-      ? [element: Encoder<_A>]
-      : never
-    : never
-): Encoder<A> {
-  return Encoder((inp) => Array.from(inp).map((a) => element.encode(a)));
-}

package/_src/collection/immutable/ImmutableArray/derivations.ts

@@ -1,41 +0,0 @@
-import type { Check } from "@fncts/typelevel/Check";
-
-/**
- * @tsplus derive fncts.Guard[fncts.ImmutableArray]<_> 10
- */
-export function deriveGuard<A extends ImmutableArray<any>>(
-  ...[element]: [A] extends [ImmutableArray<infer A>] ? [element: Guard<A>] : never
-): Guard<A> {
-  return Guard((u): u is A => {
-    if (ImmutableArray.is(u)) {
-      return u._array.every(element.is);
-    }
-    return false;
-  });
-}
-
-/**
- * @tsplus derive fncts.Decoder[fncts.ImmutableArray]<_> 10
- */
-export function deriveDecoder<A extends ImmutableArray<any>>(
-  ...[array, elem]: [A] extends [ImmutableArray<infer _A>]
-    ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True
-      ? [array: Decoder<Array<_A>>, elem: Decoder<_A>]
-      : never
-    : never
-): Decoder<A> {
-  return Decoder((u) => array.decode(u).map((as) => new ImmutableArray(as) as A), `ImmutableArray<${elem.label}>`);
-}
-
-/**
- * @tsplus derive fncts.Encoder[fncts.ImmutableArray]<_> 10
- */
-export function deriveEncoder<A extends ImmutableArray<any>>(
-  ...[element]: [A] extends [ImmutableArray<infer _A>]
-    ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True
-      ? [element: Encoder<_A>]
-      : never
-    : never
-): Encoder<A> {
-  return Encoder((inp) => inp._array.map((a) => element.encode(a)));
-}

package/_src/collection/immutable/ImmutableNonEmptyArray/derivations.ts

@@ -1,57 +0,0 @@
-import type { Check } from "@fncts/typelevel/Check";
-
-import { CompoundError, EmptyError } from "@fncts/base/data/DecodeError";
-
-/**
- * @tsplus derive fncts.Guard[fncts.ImmutableNonEmptyArray]<_> 10
- */
-export function deriveGuard<A extends ImmutableNonEmptyArray<any>>(
-  ...[elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? [elem: Guard<_A>] : never
-): Guard<A> {
-  return Guard((u): u is A => {
-    if (ImmutableNonEmptyArray.is(u)) {
-      return u.every(elem.is);
-    }
-    return false;
-  });
-}
-
-/**
- * @tsplus derive fncts.Decoder[fncts.ImmutableNonEmptyArray]<_> 10
- */
-export function deriveDecoder<A extends ImmutableNonEmptyArray<any>>(
-  ...[array, elem]: [A] extends [ImmutableNonEmptyArray<infer _A>]
-    ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True
-      ? [array: Decoder<Array<_A>>, elem: Decoder<_A>]
-      : never
-    : never
-): Decoder<A> {
-  return Decoder(
-    (u) =>
-      array.decode(u).match2(These.left, (warn, as) => {
-        if (as.isNonEmpty()) {
-          return These.right(new ImmutableNonEmptyArray(as) as A);
-        } else {
-          const err = new EmptyError(as);
-          return warn.match(
-            () => These.left(err),
-            (err0) => These.left(new CompoundError(`ImmutableNonEmptyArray<${elem.label}>`, Vector(err0, err))),
-          );
-        }
-      }),
-    `ImmutableNonEmptyArray<${elem.label}>`,
-  );
-}
-
-/**
- * @tsplus derive fncts.Encoder[fncts.ImmutableNonEmptyArray]<_> 10
- */
-export function deriveEncoder<A extends ImmutableNonEmptyArray<any>>(
-  ...[element]: [A] extends [ImmutableNonEmptyArray<infer _A>]
-    ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True
-      ? [element: Encoder<_A>]
-      : never
-    : never
-): Encoder<A> {
-  return Encoder((inp) => inp._array.map((a) => element.encode(a)));
-}

package/_src/data/Branded/derivations.ts

@@ -1,58 +0,0 @@
-import type { Brand, Validation } from "@fncts/base/data/Branded/definition";
-import type { Check } from "@fncts/typelevel/Check";
-
-import { BrandedError, CompoundError } from "@fncts/base/data/DecodeError";
-import { Decoder } from "@fncts/base/data/Decoder/definition";
-
-/**
- * @tsplus derive fncts.Guard<_> 10
- */
-export function deriveGuard<A extends Brand.Valid<any, any>>(
-  ...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True
-    ? [
-        base: Guard<Brand.Unbranded<A>>,
-        brands: {
-          [K in keyof A[Brand.valid] & string]: Validation<A[Brand.valid][K], K>;
-        },
-      ]
-    : never
-): Guard<A> {
-  const validations = Object.values(brands) as ReadonlyArray<Validation<A, any>>;
-  return Guard((u): u is A => base.is(u) && validations.every((brand) => brand.validate(u)));
-}
-
-/**
- * @tsplus derive fncts.Decoder<_> 10
- */
-export function deriveDecoder<A extends Brand.Valid<any, any>>(
-  ...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True
-    ? [
-        base: Decoder<Brand.Unbranded<A>>,
-        brands: {
-          [K in keyof A[Brand.valid] & string]: Validation<A[Brand.valid][K], K>;
-        },
-      ]
-    : never
-): Decoder<A> {
-  const label = "Brand<" + Object.keys(brands).join(" & ") + ">";
-  return Decoder(
-    (u) =>
-      base.decode(u).match2(These.left, (warning, value) => {
-        const failedBrands: Array<string> = [];
-        for (const brand in brands) {
-          if (!brands[brand]!.validate(value as any)) {
-            failedBrands.push(brand);
-          }
-        }
-        if (failedBrands.length > 0) {
-          const error = new BrandedError(label, Vector.from(failedBrands));
-          return warning.match(
-            () => These.left(error),
-            (warning) => These.left(new CompoundError(label, Vector(warning, error))),
-          );
-        }
-        return These.rightOrBoth(warning, value);
-      }),
-    label,
-  );
-}

package/_src/typeclass/Guard/api.ts

@@ -1,37 +0,0 @@
-import type { Check } from "@fncts/typelevel/Check";
-import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
-
-import { Guard } from "@fncts/base/typeclass/Guard/definition";
-import { AssertionError } from "@fncts/base/util/assert";
-import { isObject } from "@fncts/base/util/predicates";
-/**
- * @tsplus pipeable fncts.Guard __call
- */
-export function is(u: unknown) {
-  // @ts-expect-error
-  return <A>(self: Guard<A>): u is A => {
-    return self.is(u);
-  };
-}
-/**
- * @tsplus pipeable fncts.Guard refine
- * @tsplus operator fncts.Guard &&
- */
-export function refine<A, B extends A>(refinement: Refinement<A, B>): (self: Guard<A>) => Guard<B>;
-export function refine<A>(predicate: Predicate<A>): (self: Guard<A>) => Guard<A>;
-export function refine<A>(predicate: Predicate<A>) {
-  return (self: Guard<A>): Guard<A> => {
-    return Guard(self.is && predicate);
-  };
-}
-/**
- * @tsplus pipeable fncts.Guard assert
- */
-export function assert(u: unknown) {
-  // @ts-expect-error
-  return <A>(self: Guard<A>): asserts u is A => {
-    if (!self.is(u)) {
-      throw new AssertionError("Guard failed check failed");
-    }
-  };
-}

package/_src/typeclass/Guard/derivations.ts

@@ -1,80 +0,0 @@
-import type { Check } from "@fncts/typelevel/Check";
-import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
-/**
- * @tsplus derive fncts.Guard lazy
- */
-export function deriveLazy<A>(f: (_: Guard<A>) => Guard<A>): Guard<A> {
-  let cached: Guard<A> | undefined;
-  const guard: Guard<A> = Guard((u: unknown): u is A => {
-    if (!cached) {
-      cached = f(guard);
-    }
-    return cached.is(u);
-  });
-  return guard;
-}
-/**
- * @tsplus derive fncts.Guard<_> 20
- */
-export function deriveLiteral<A extends string | number | boolean>(
-  ...[value]: Check<Check.IsLiteral<A> & Check.Not<Check.IsUnion<A>>> extends Check.True ? [value: A] : never
-): Guard<A> {
-  return Guard((u): u is A => u === value);
-}
-/**
- * @tsplus derive fncts.Guard<_> 20
- */
-export function deriveStruct<A extends Record<string, any>>(
-  ...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True
-    ? [
-        ...[
-          requiredFields: {
-            [k in RequiredKeys<A>]: Guard<A[k]>;
-          },
-        ],
-        ...([OptionalKeys<A>] extends [never]
-          ? []
-          : [
-              optionalFields: {
-                [k in OptionalKeys<A>]: Guard<NonNullable<A[k]>>;
-              },
-            ]),
-      ]
-    : never
-): Guard<A> {
-  return Guard((u): u is A => {
-    if (!isObject(u)) {
-      return false;
-    }
-    for (const key in requiredFields) {
-      if (!(key in u) || !(requiredFields[key] as Guard<any>).is(u[key])) {
-        return false;
-      }
-    }
-    if (optionalFields) {
-      for (const key in optionalFields) {
-        if (key in u && typeof u[key] !== "undefined" && !(optionalFields[key] as Guard<any>).is(u[key])) {
-          return false;
-        }
-      }
-    }
-    return true;
-  });
-}
-/**
- * @tsplus derive fncts.Guard<|> 30
- */
-export function deriveUnion<A extends unknown[]>(
-  ...members: {
-    [K in keyof A]: Guard<A[K]>;
-  }
-): Guard<A[number]> {
-  return Guard((u): u is A[number] => {
-    for (const member of members) {
-      if (member.is(u)) {
-        return true;
-      }
-    }
-    return false;
-  });
-}

package/_src/typeclass/Guard.ts

@@ -1,4 +0,0 @@
-// codegen:start { preset: barrel, include: ./Guard/*.ts, exclude: ./Guard/derivations.ts }
-export * from "./Guard/api.js";
-export * from "./Guard/definition.js";
-// codegen:end

package/_src/typeclass/Ord/api/contramap.ts

@@ -1,12 +0,0 @@
-import type { Ord } from "@fncts/base/typeclass/Ord/definition";
-/**
- * @tsplus pipeable fncts.Ord contramap
- */
-export function contramap<A, B>(f: (b: B) => A) {
-  return (self: Ord<A>): Ord<B> => {
-    return {
-      compare: (x, y) => self.compare(f(x), f(y)),
-      equals: (x, y) => self.equals(f(x), f(y)),
-    };
-  };
-}

package/_src/typeclass/Ord/api/max.ts

@@ -1,8 +0,0 @@
-import type { Ord } from "@fncts/base/typeclass/Ord/definition";
-/**
- * @tsplus static fncts.OrdOps max
- * @tsplus getter fncts.Ord max
- */
-export function max_<A>(O: Ord<A>): (x: A, y: A) => A {
-  return (x, y) => (x === y || O.compare(x, y) > -1 ? x : y);
-}

package/_src/typeclass/Ord/api/min.ts

@@ -1,8 +0,0 @@
-import type { Ord } from "@fncts/base/typeclass/Ord/definition";
-/**
- * @tsplus static fncts.OrdOps min
- * @tsplus getter fncts.Ord min
- */
-export function min_<A>(O: Ord<A>): (x: A, y: A) => A {
-  return (x, y) => (x === y || O.compare(x, y) < 1 ? x : y);
-}

package/collection/compat/Array/derivations.d.ts

@@ -1,35 +0,0 @@
-import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder/definition";
-import { These } from "@fncts/base/data/These";
-import { Encoder } from "@fncts/base/data/Encoder/definition";
-import type { Check } from "@fncts/typelevel/Check";
-/**
- * @tsplus derive fncts.Guard[fncts.Array]<_> 10
- * @tsplus location "@fncts/base/collection/compat/Array/derivations"
- */
-export declare function deriveGuard<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Guard<_A>] : never : never): Guard<A>;
-/**
- * @tsplus derive fncts.Guard[fncts.ReadonlyArray]<_> 10
- * @tsplus location "@fncts/base/collection/compat/Array/derivations"
- */
-export declare const deriveReadonlyArrayGuard: <A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Guard<_A>] : never : never) => Guard<A>;
-/**
- * @tsplus derive fncts.Decoder[fncts.Array]<_> 10
- * @tsplus location "@fncts/base/collection/compat/Array/derivations"
- */
-export declare function deriveDecoder<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Decoder<_A>] : never : never): Decoder<A>;
-/**
- * @tsplus derive fncts.Decoder[fncts.ReadonlyArray]<_> 10
- * @tsplus location "@fncts/base/collection/compat/Array/derivations"
- */
-export declare function deriveReadonlyArrayDecoder<A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Decoder<_A>] : never : never): Decoder<A>;
-/**
- * @tsplus derive fncts.Encoder[fncts.Array]<_> 10
- * @tsplus location "@fncts/base/collection/compat/Array/derivations"
- */
-export declare function deriveEncoder<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;
-/**
- * @tsplus derive fncts.Encoder[fncts.ReadonlyArray]<_> 10
- * @tsplus location "@fncts/base/collection/compat/Array/derivations"
- */
-export declare function deriveReadonlyArrayEncoder<A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;

package/collection/compat/Record/instances.d.ts

@@ -1,46 +0,0 @@
-import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder/definition";
-import { Encoder } from "@fncts/base/data/Encoder/definition";
-import type { Check } from "@fncts/typelevel/Check";
-/**
- * @tsplus derive fncts.Guard<_> 15
- * @tsplus location "@fncts/base/collection/compat/Record/instances"
- */
-export declare function deriveDictionaryGuard<A extends Record<string, any>>(...[value]: Check<Check.IsDictionary<A>> extends Check.True ? [value: Guard<A[keyof A]>] : never): Guard<A>;
-/**
- * @tsplus derive fncts.Guard<_> 15
- * @tsplus location "@fncts/base/collection/compat/Record/instances"
- */
-export declare function deriveGuard<A extends Record<string, any>>(...[key, value, requiredKeys]: Check<Check.IsRecord<A>> extends Check.True ? [
-    key: Guard<keyof A>,
-    value: Guard<A[keyof A]>,
-    requiredKeys: {
-        [k in keyof A]: 0;
-    }
-] : never): Guard<A>;
-/**
- * @tsplus derive fncts.Decoder<_> 15
- * @tsplus location "@fncts/base/collection/compat/Record/instances"
- */
-export declare function deriveDecoder<A extends Record<string, any>>(...[keyGuard, valueDecoder, requiredKeysRecord]: [A] extends [Record<infer X, infer Y>] ? Check<Check.Not<Check.IsUnion<A>> & Check.IsEqual<A, Record<X, Y>>> extends Check.True ? [
-    keyGuard: Guard<X>,
-    valueDecoder: Decoder<Y>,
-    requiredKeysRecord: {
-        [k in X]: 0;
-    }
-] : never : never): Decoder<A>;
-/**
- * @tsplus derive fncts.Encoder<_> 15
- * @tsplus location "@fncts/base/collection/compat/Record/instances"
- */
-export declare function deriveDictionaryEncoder<A extends Record<string, any>>(...[value]: Check<Check.IsDictionary<A>> extends Check.True ? [value: Encoder<A[keyof A]>] : never): Encoder<A>;
-/**
- * @tsplus derive fncts.Encoder<_> 15
- * @tsplus location "@fncts/base/collection/compat/Record/instances"
- */
-export declare function deriveEncoder<A extends Record<string, any>>(...[value, requiredKeys]: Check<Check.IsRecord<A>> extends Check.True ? [
-    value: Encoder<A[keyof A]>,
-    requiredKeys: {
-        [K in keyof A]: 0;
-    }
-] : never): Encoder<A>;

package/collection/compat/Record.d.ts

@@ -1 +0,0 @@
-export * from "./Record/instances.js";

package/collection/immutable/Conc/derivations.d.ts

@@ -1,20 +0,0 @@
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder/definition";
-import { Encoder } from "@fncts/base/data/Encoder/definition";
-import type { Check } from "@fncts/typelevel/Check";
-/**
- * @tsplus derive fncts.Guard[fncts.Conc]<_> 10
- * @tsplus location "@fncts/base/collection/immutable/Conc/derivations"
- */
-export declare function deriveGuard<A extends Conc<any>>(...[elem]: [A] extends [Conc<infer _A>] ? [elem: Guard<_A>] : never): Guard<A>;
-/**
- * @tsplus derive fncts.Decoder[fncts.Conc]<_> 10
- * @tsplus location "@fncts/base/collection/immutable/Conc/derivations"
- */
-export declare function deriveDecoder<A extends Conc<any>>(...[array, elem]: [A] extends [Conc<infer _A>] ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;
-/**
- * @tsplus derive fncts.Encoder[fncts.Conc]<_> 10
- * @tsplus location "@fncts/base/collection/immutable/Conc/derivations"
- */
-export declare function deriveEncoder<A extends Conc<any>>(...[element]: [A] extends [Conc<infer _A>] ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;

package/collection/immutable/ImmutableArray/derivations.d.ts

@@ -1,20 +0,0 @@
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder/definition";
-import { Encoder } from "@fncts/base/data/Encoder/definition";
-import type { Check } from "@fncts/typelevel/Check";
-/**
- * @tsplus derive fncts.Guard[fncts.ImmutableArray]<_> 10
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/derivations"
- */
-export declare function deriveGuard<A extends ImmutableArray<any>>(...[element]: [A] extends [ImmutableArray<infer A>] ? [element: Guard<A>] : never): Guard<A>;
-/**
- * @tsplus derive fncts.Decoder[fncts.ImmutableArray]<_> 10
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/derivations"
- */
-export declare function deriveDecoder<A extends ImmutableArray<any>>(...[array, elem]: [A] extends [ImmutableArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;
-/**
- * @tsplus derive fncts.Encoder[fncts.ImmutableArray]<_> 10
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/derivations"
- */
-export declare function deriveEncoder<A extends ImmutableArray<any>>(...[element]: [A] extends [ImmutableArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;

package/collection/immutable/ImmutableNonEmptyArray/derivations.d.ts

@@ -1,20 +0,0 @@
-import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
-import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder/definition";
-import { Encoder } from "@fncts/base/data/Encoder/definition";
-import type { Check } from "@fncts/typelevel/Check";
-/**
- * @tsplus derive fncts.Guard[fncts.ImmutableNonEmptyArray]<_> 10
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/derivations"
- */
-export declare function deriveGuard<A extends ImmutableNonEmptyArray<any>>(...[elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? [elem: Guard<_A>] : never): Guard<A>;
-/**
- * @tsplus derive fncts.Decoder[fncts.ImmutableNonEmptyArray]<_> 10
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/derivations"
- */
-export declare function deriveDecoder<A extends ImmutableNonEmptyArray<any>>(...[array, elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;
-/**
- * @tsplus derive fncts.Encoder[fncts.ImmutableNonEmptyArray]<_> 10
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/derivations"
- */
-export declare function deriveEncoder<A extends ImmutableNonEmptyArray<any>>(...[element]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;