Fix typescript definitions

src/defs.d.ts

@@ -52,7 +52,7 @@ export declare function getFinalValue<T>(o: FinalValue<T>): T;
 /**
  * Alias for {@link finalValue}
  */
-export declare const final = finalValue;
+export declare const final: typeof finalValue;
 
 /**
  * Interface for a value that has been marked as multiple values.
@@ -169,30 +169,30 @@ export declare function clearFunctionList<
  * @returns a `Many` containing the value
  * @remarks `Many` is used to return multiple values from a regular (non-generator) function.
  */
-export declare function toMany<T>(value: readonly Many<T>): Many<T>;
+export declare function toMany<T>(value:  Readonly<Many<T>>): Many<T>;
 export declare function toMany(value: typeof none): Many<never>;
-export declare function toMany<T>(value: readonly T): Many<T>;
+export declare function toMany<T>(value: Readonly<T>): Many<T>;
 /**
  * Normalize a value by unbundling it if it is a `Many`.
  * @param value the value to normalize
  * @returns the normalized value
  */
-export declare function normalizeMany(value: readonly unknown): unknown;
+export declare function normalizeMany(value:  Readonly<unknown>): unknown;
 /**
  * Combine two values into a `Many`.
  * @param a the first value
  * @param b the second value
  * @returns a `Many` containing both values
  */
 export declare function combineMany(a: typeof none, b: typeof none): Many<never>;
-export declare function combineMany<T>(a: typeof none, b: readonly Many<T>): Many<T>;
-export declare function combineMany<T>(a: readonly Many<T>, b: typeof none): Many<T>;
-export declare function combineMany<T>(a: typeof none, b: readonly T): Many<T>;
-export declare function combineMany<T>(a: readonly T, b: typeof none): Many<T>;
-export declare function combineMany<T, U>(a: readonly Many<T>, b: readonly Many<U>): Many<T | U>;
-export declare function combineMany<T, U>(a: readonly T, b: readonly Many<U>): Many<T | U>;
-export declare function combineMany<T, U>(a: readonly Many<T>, b: readonly U): Many<T | U>;
-export declare function combineMany<T, U>(a: readonly T, b: readonly U): Many<T | U>;
+export declare function combineMany<T>(a: typeof none, b:  Readonly<Many<T>>): Many<T>;
+export declare function combineMany<T>(a: Readonly<Many<T>>, b: typeof none): Many<T>;
+export declare function combineMany<T>(a: typeof none, b:  Readonly<T>): Many<T>;
+export declare function combineMany<T>(a: Readonly<T>, b: typeof none): Many<T>;
+export declare function combineMany<T, U>(a:  Readonly<Many<T>>, b:  Readonly<Many<U>>): Many<T | U>;
+export declare function combineMany<T, U>(a:  Readonly<T>, b:  Readonly<Many<U>>): Many<T | U>;
+export declare function combineMany<T, U>(a:  Readonly<Many<T>>, b:  Readonly<U>): Many<T | U>;
+export declare function combineMany<T, U>(a:  Readonly<T>, b:  Readonly<U>): Many<T | U>;
 /**
  * Combine two values into a `Many` mutably.
  * @param a the first value
@@ -201,14 +201,14 @@ export declare function combineMany<T, U>(a: readonly T, b: readonly U): Many<T
  * @remarks if `a` or `b` are `Many`, they can be modified in-place
  */
 export declare function combineManyMut(a: typeof none, b: typeof none): Many<never>;
-export declare function combineManyMut<T>(a: typeof none, b: readonly Many<T>): Many<T>;
-export declare function combineManyMut<T>(a: readonly Many<T>, b: typeof none): Many<T>;
-export declare function combineManyMut<T>(a: typeof none, b: readonly T): Many<T>;
-export declare function combineManyMut<T>(a: readonly T, b: typeof none): Many<T>;
-export declare function combineManyMut<T, U>(a: readonly Many<T>, b: readonly Many<U>): Many<T | U>;
-export declare function combineManyMut<T, U>(a: readonly T, b: readonly Many<U>): Many<T | U>;
-export declare function combineManyMut<T, U>(a: readonly Many<T>, b: readonly U): Many<T | U>;
-export declare function combineManyMut<T, U>(a: readonly T, b: readonly U): Many<T | U>;
+export declare function combineManyMut<T>(a: typeof none, b:  Readonly<Many<T>>): Many<T>;
+export declare function combineManyMut<T>(a:  Readonly<Many<T>>, b: typeof none): Many<T>;
+export declare function combineManyMut<T>(a: typeof none, b:  Readonly<T>): Many<T>;
+export declare function combineManyMut<T>(a:  Readonly<T>, b: typeof none): Many<T>;
+export declare function combineManyMut<T, U>(a:  Readonly<Many<T>>, b:  Readonly<Many<U>>): Many<T | U>;
+export declare function combineManyMut<T, U>(a:  Readonly<T>, b:  Readonly<Many<U>>): Many<T | U>;
+export declare function combineManyMut<T, U>(a:  Readonly<Many<T>>, b:  Readonly<U>): Many<T | U>;
+export declare function combineManyMut<T, U>(a:  Readonly<T>, b:  Readonly<U>): Many<T | U>;
 
 // generic utilities: unpacking types
 
@@ -236,7 +236,7 @@ export type UnpackType<T> = T extends Many<infer U>
 /**
  * Unpacking the return type of a function as a combination of {@link UnpackType} and {@link UnpackReturnType}.
  */
-export type OutputType<F extends function> = UnpackType<UnpackReturnType<F>>;
+export type OutputType<F extends (...args: readonly any[]) => unknown> = UnpackType<UnpackReturnType<F>>;
 
 // generic utilities: working with tuples
 

src/gen.d.ts

@@ -1,6 +1,6 @@
 import type {Arg0, Ret, AsFlatList, Fn} from './defs';
 
-export = gen;
+export default gen;
 
 /**
  * Returns a type, which was expected from a list item.

src/index.d.ts

@@ -35,8 +35,6 @@ import {
 import gen from './gen';
 import asStream from './asStream';
 
-export = chain;
-
 /**
  * Represents a typed duplex stream as a pair of readable and writable streams.
  */
@@ -238,7 +236,7 @@ declare function dataSource<F>(
  * @remarks This is the main function of this library.
  */
 declare function chain<L extends readonly unknown[]>(
-  ...fns: ChainList<Arg0<L>, L>,
+  fns: ChainList<Arg0<L>, L>,
   options?: ChainOptions
 ): ChainOutput<Arg0<L>, Ret<L>>;
 
@@ -247,36 +245,35 @@ declare function chainUnchecked<W = any, R = any>(
   options?: ChainOptions
 ): ChainOutput<W, R>;
 
-declare namespace chain {
-  export {
-    none,
-    stop,
-    Stop,
-    finalSymbol,
-    finalValue,
-    final,
-    isFinalValue,
-    getFinalValue,
-    manySymbol,
-    many,
-    isMany,
-    getManyValues,
-    getFunctionList,
-    flushSymbol,
-    flushable,
-    isFlushable,
-    fListSymbol,
-    isFunctionList,
-    setFunctionList,
-    clearFunctionList,
-    toMany,
-    normalizeMany,
-    combineMany,
-    combineManyMut,
-    chain,
-    chainUnchecked,
-    gen,
-    asStream,
-    dataSource
-  };
-}
+export default chain;
+export {
+  none,
+  stop,
+  Stop,
+  finalSymbol,
+  finalValue,
+  final,
+  isFinalValue,
+  getFinalValue,
+  manySymbol,
+  many,
+  isMany,
+  getManyValues,
+  getFunctionList,
+  flushSymbol,
+  flushable,
+  isFlushable,
+  fListSymbol,
+  isFunctionList,
+  setFunctionList,
+  clearFunctionList,
+  toMany,
+  normalizeMany,
+  combineMany,
+  combineManyMut,
+  chain,
+  chainUnchecked,
+  gen,
+  asStream,
+  dataSource
+};

src/typed-streams.d.ts

@@ -6,40 +6,28 @@ import {Duplex, Readable, Transform, Writable} from 'node:stream';
  * Technical class to add input/output types to duplex streams.
  */
 export declare class TypedDuplex<W = any, R = W> extends Duplex {
-  __streamTypeR(): R {
-    return null as R;
-  }
-  __streamTypeW(): W {
-    return null as W;
-  }
+  __streamTypeR(): R
+  __streamTypeW(): W
 }
 
 /**
  * Technical class to add output type to readable streams.
  */
 export declare class TypedReadable<R = any> extends Readable {
-  __streamTypeR(): R {
-    return null as R;
-  }
+  __streamTypeR(): R
 }
 
 /**
  * Technical class to add input/output types to transform streams.
  */
 export declare class TypedTransform<W = any, R = W> extends Transform {
-  __streamTypeR(): R {
-    return null as R;
-  }
-  __streamTypeW(): W {
-    return null as W;
-  }
+  __streamTypeR(): R
+  __streamTypeW(): W
 }
 
 /**
  * Technical class to add input type to writable streams.
  */
 export declare class TypedWritable<W = any> extends Writable {
-  __streamTypeW(): W {
-    return null as W;
-  }
+  __streamTypeW(): W
 }

src/utils/readableFrom.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 
-import {Readable, ReadableOptions} from 'node:stream';
+import {ReadableOptions} from 'node:stream';
 import {TypedReadable} from '../typed-streams';
 
 export = readableFrom;

src/utils/reduceStream.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 
-import {Writable, WritableOptions} from 'stream';
+import {WritableOptions} from 'stream';
 import {TypedWritable} from '../typed-streams';
 
 export = reduceStream;

src/utils/take.d.ts

@@ -10,5 +10,5 @@ export = take;
  */
 declare function take<T = any>(
   n: number,
-  finalValue?: typeof none | typeof stop = none
+  finalValue?: typeof none | typeof stop
 ): (value: T) => T | typeof finalValue;

src/utils/takeWhile.d.ts

@@ -1,4 +1,4 @@
-import {none, stop} from './defs';
+import {none, stop} from '../defs';
 
 export = takeWhile;
 
@@ -10,9 +10,9 @@ export = takeWhile;
  */
 declare function takeWhile<T>(
   fn: (value: T) => boolean,
-  finalValue?: typeof none | typeof stop = none
+  finalValue?: typeof none | typeof stop
 ): (value: unknown) => T | typeof finalValue;
 declare function takeWhile<T>(
   fn: (value: T) => Promise<boolean>,
-  finalValue?: typeof none | typeof stop = none
+  finalValue?: typeof none | typeof stop
 ): (value: unknown) => Promise<T | typeof finalValue>;

src/utils/takeWithSkip.d.ts

@@ -13,5 +13,5 @@ export = takeWithSkip;
 declare function takeWithSkip<T = any>(
   n: number,
   skip?: number,
-  finalValue?: typeof none | typeof stop = none
+  finalValue?: typeof none | typeof stop
 ): (value: T) => T | typeof finalValue;

tsconfig.json

@@ -104,6 +104,6 @@
 
     /* Completeness */
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+    "skipLibCheck": false                                 /* Skip type checking all .d.ts files. */
   }
 }