@daiso-tech/core 0.2.1 → 0.4.0

package/dist/types/async/delay/delay.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @module Async
+ */
+import type { TimeSpan } from "../../utilities/_module";
+import { LazyPromise } from "../../async/lazy-promise/_module";
+/**
+ * The <i>delay</i> function creates a promise that will be fulfilled after given <i>time</i> and can be aborted by providing <i>abortSignal</i>.
+ * @group Promise utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @example
+ * ```ts
+ * import { delay, TimeSpan } from "@daiso-tech/core";
+ * (async () => {
+ *   console.log("a");
+ *   await delay(TimeSpan.fromSeconds(2));
+ *   console.log("b");
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { delay, TimeSpan } from "@daiso-tech/core";
+ *
+ * const abortController = new AbortController();
+ * setTimeout(() => {
+ *  abortController.abort("My abort error");
+ * }, TimeSpan.fromSeconds(1).toMilliseconds());
+ * const promise = delay(TimeSpan.fromSeconds(2), abortController.signal);
+ *
+ * (async () => {
+ *   console.log("a");
+ *   // Will throw AbortAsyncError
+ *   await promise;
+ *   console.log("b");
+ * })();
+ * ```
+ */
+export declare function delay(time: TimeSpan, abortSignal?: AbortSignal): LazyPromise<void>;

package/dist/types/async/delay-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../async/delay-iterable/delay-iterable";

package/dist/types/async/delay-iterable/delay-iterable.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module Async
+ */
+import type { TimeSpan } from "../../utilities/_module";
+/**
+ * The <i>delayIterable</i> function adds delay to each iteration of <i>{@link AsyncIterable}</i> and the delay can be aborted by providing <i>abortSignal</i>.
+ * @group AsyncIterable utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @example
+ * ```ts
+ * import { delayIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     yield 2;
+ *     yield 3;
+ *     yield 4;
+ *     yield 5;
+ *   }
+ * }
+ *
+ * (async () => {
+ *   for await (const item of delayIterable(iterable, TimeSpan.fromSeconds(1))) {
+ *     console.log(item);
+ *   }
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { delayIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * const abortController = new AbortController();
+ * setTimeout(() => {
+ *  abortController.abort("My abort error");
+ * }, TimeSpan.fromSeconds(3).toMilliseconds());
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     yield 2;
+ *     yield 3;
+ *     yield 4;
+ *     yield 5;
+ *   }
+ * }
+ *
+ * (async () => {
+ *   // Will throw AbortAsyncError
+ *   for await (const item of delayIterable(iterable, TimeSpan.fromSeconds(1), abortController.signal)) {
+ *     console.log(item);
+ *   }
+ * })();
+ * ```
+ */
+export declare function delayIterable<TValue>(iterable: AsyncIterable<TValue>, time: TimeSpan, abortSignal?: AbortSignal): AsyncIterable<TValue>;

package/dist/types/async/lazy-promise/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../async/lazy-promise/lazy-promise";

package/dist/types/async/lazy-promise/lazy-promise.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @module Async
+ */
+/**
+ * The <i>LazyPromise</i> class is used for creating lazy <i>{@link PromiseLike}<i> object that will only execute when awaited or when then method is called.
+ * @group Promise utilities
+ * @example
+ * ```ts
+ * (async () => {
+ *   const promise = new LazyPromise(async () => {
+ *     console.log("I am lazy");
+ *   });
+ *   // "I am lazy" will only logged when awaited or then method i called.
+ *   await promise;
+ * })();
+ * ```
+ */
+export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
+    private readonly asyncFn;
+    private promise;
+    constructor(asyncFn: () => PromiseLike<TValue>);
+    then<TResult1 = TValue, TResult2 = never>(onfulfilled?: ((value: TValue) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+/**
+ * The <i>deferLazyPromise</i> function will execute <i>{@link LazyPromise}</i> without awaiting it.
+ * @group Promise utilities
+ */
+export declare function deferLazyPromise<TValue>(promise: LazyPromise<TValue>): void;

package/dist/types/async/retry/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../async/retry/retry";

package/dist/types/async/retry/retry.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @module Async
+ */
+import type { BackoffPolicy } from "../../async/backof-policies/_module";
+import { LazyPromise } from "../../async/lazy-promise/_module";
+import { TimeSpan } from "../../utilities/_module";
+export type RetryPolicy = (error: unknown) => boolean;
+/**
+ * @group Promise utilities
+ */
+export type RetrySettings = {
+    /**
+     * @default {4}
+     */
+    maxAttempts?: number;
+    backoffPolicy?: BackoffPolicy;
+    retryPolicy?: RetryPolicy;
+    /**
+     * @default 60_000 milliseconds
+     */
+    retryTimeout?: TimeSpan;
+    abortSignal?: AbortSignal;
+};
+/**
+ * The <i>retry</i> function will retry a async function if it throws an error until given <i>settings.maxAttempts</i>.
+ * You can add timeout for each retry by passing <i>settings.retryTimeout</i> and <i>settings.abortSignal</i> for aborting it on your own.
+ * You can also customize the retry policy by passing <i>settings.retryPolicy</i> and custom backof policy by passing <i>settings.backoffPolicy</i>.
+ * @group Promise utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ * @throws {RetryAsyncError} {@link RetryAsyncError}
+ * @example
+ * ```ts
+ * import { retry, TimeSpan, exponentialBackoffPolicy } from "@daiso-tech/core";
+ *
+ * (async () => {
+ *   // Will throw RetryAsyncError after failing 4:th attempt
+ *   await retry(async () => {
+ *     throw new Error("My error mesasge");
+ *   }, {
+ *     // You can choose the max retry attempts
+ *     maxAttempts: 4,
+ *     // You can provide a custom backoff policy
+ *     backoffPolicy: exponentialBackoffPolicy(),
+ *     // You can choose what error to retry, this function will retry all errors thrown
+ *     retryPolicy: () => true,
+ *     // You can provide a timeout for each retry
+ *     retryTimeout: TimeSpan.fromMilliseconds(60_000),
+ *   });
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { retry, TimeSpan } from "@daiso-tech/core";
+ *
+ * (async () => {
+ *   const abortController = new AbortController();
+ *   abortController.abort("My abort message");
+ *
+ *   // Will be aborted by throwing AbortAsyncError
+ *   await retry(async () => {
+ *     throw new Error("My error message");
+ *   }, {
+ *     abortSignal: abortController.signal
+ *   });
+ * })();
+ * ```
+ * @example with custom retry policy
+ * ```ts
+ * import { retry, TimeSpan } from "@daiso-tech/core";
+ *
+ * class ErrorA extends Error {};
+ * class ErrorB extends Error {};
+ *
+ * (async () => {
+ *   // Will not retry and ErrorB will be thrown
+ *   await retry(async () => {
+ *     throw new ErrorB("My error message");
+ *   }, {
+ *     retryPolicy: error => error instanceof ErrorA
+ *   });
+ * })();
+ * ```
+ */
+export declare function retry<TValue = void>(asyncFn: () => PromiseLike<TValue>, settings?: RetrySettings): LazyPromise<TValue>;

package/dist/types/async/retry-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../async/retry-iterable/retry-iterable";

package/dist/types/async/retry-iterable/retry-iterable.d.ts

@@ -0,0 +1,86 @@
+import type { RetrySettings } from "../../async/retry/_module";
+/**
+ * The <i>retryIterable</i> function will retry each iteration of {@link AsyncIterable} if it throws an error until given <i>settings.maxAttempts</i>.
+ * You can add timeout for each retry by passing <i>settings.retryTimeout</i> and <i>settings.abortSignal</i> for aborting it on your own.
+ * You can also customize the retry policy by passing <i>settings.retryPolicy</i> and custom backof policy by passing <i>settings.backoffPolicy</i>.
+ * @group AsyncIterable utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @throws {RetryAsyncError} {@link RetryAsyncError}
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ * @example
+ * ```ts
+ * import { retryIterable, TimeSpan, exponentialBackoffPolicy } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     throw new Error("My error mesasge");
+ *   }
+ * }
+ *
+ * (async () => {
+ *   // Will throw RetryAsyncError after failing 4:th attempt
+ *   for await (const item of retryIterable(iterable, {
+ *     // You can choose the max retry attempts
+ *     maxAttempts: 4,
+ *     // You can provide a custom backoff policy
+ *     backoffPolicy: exponentialBackoffPolicy(),
+ *     // You can choose what error to retry, this function will retry all errors thrown
+ *     retryPolicy: () => true,
+ *     // You can provide a timeout for each retry
+ *     retryTimeout: TimeSpan.fromMilliseconds(60_000),
+ *   })) {
+ *     console.log(item)
+ *   }
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { retryIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     throw new Error("My error mesasge");
+ *   }
+ * }
+ *
+ * (async () => {
+ *   const abortController = new AbortController();
+ *   abortController.abort("My abort message");
+ *
+ *   // Will be aborted by throwing AbortAsyncError
+ *   for await (const item of retry(iterable, {
+ *     abortSignal: abortController.signal
+ *   })) {
+ *     console.log(item)
+ *   }
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { retryIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * class ErrorA extends Error {};
+ * class ErrorB extends Error {};
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     throw new ErrorB("My error mesasge");
+ *   }
+ * }
+ *
+ *
+ * (async () => {
+ *   // Will not retry and ErrorB will be thrown
+ *   for await (const item of retry(iterable, {
+ *     retryPolicy: error => error instanceof ErrorA
+ *   })) {
+ *     console.log(item)
+ *   }
+ * })();
+ * ```
+ */
+export declare function retryIterable<TValue>(iterable: AsyncIterable<TValue>, settings?: RetrySettings): AsyncIterable<TValue>;

package/dist/types/async/timeout/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../async/timeout/timeout";

package/dist/types/async/timeout/timeout.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @module Async
+ */
+import { LazyPromise } from "../../async/lazy-promise/_module";
+import type { TimeSpan } from "../../utilities/_module";
+/**
+ * The <i>timeout</i> function makes a <i>{@link PromiseLike}</i> object abort after a given <i>time</i> and you can also abort it on your own by passing <i>abortSignal</i>.
+ * @group Promise utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ * @example
+ * ```ts
+ * import { timeout, delay, TimeSpan } from "@daiso-tech/core";
+ *
+ * (async () => {
+ *   // Will throw an AbortAsyncError
+ *   await timeout(async () => {
+ *     await delay(TimeSpan.fromSeconds(10));
+ *   }, TimeSpan.fromSeconds(5));
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { timeout, delay, TimeSpan } from "@daiso-tech/core";
+ *
+ * const abortController = new AbortController();
+ * setTimeout(() => {
+ *   abortController.abort("My abort error");
+ * }, TimeSpan.fromSeconds(1));
+ *
+ * (async () => {
+ *   // Will abort after 1 second by throwing AbortAsyncError
+ *   await timeout(async () => {
+ *     await delay(TimeSpan.fromSeconds(10));
+ *   }, TimeSpan.fromSeconds(5), abortController.signal);
+ * })();
+ * ```
+ */
+export declare function timeout<TValue>(asyncFn: () => PromiseLike<TValue>, time: TimeSpan, abortSignal?: AbortSignal): LazyPromise<TValue>;

package/dist/types/async/timeout-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../async/timeout-iterable/timeout-iterable";

package/dist/types/async/timeout-iterable/timeout-iterable.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @module Async
+ */
+import type { TimeSpan } from "../../utilities/_module";
+/**
+ * The <i>timeoutIterable</i> function makes a <i>{@link AsyncIterable}</i> abort after a given <i>time</i> and you can also abort it on your own by passing <i>abortSignal</i>.
+ * @group AsyncIterable utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @example
+ * ```ts
+ * import { timeoutIterable, delayIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = delayIterable({
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     yield 2;
+ *     yield 3;
+ *     yield 4;
+ *     yield 5;
+ *     yield 6;
+ *     yield 7;
+ *     yield 8;
+ *   }
+ * }, TimeSpan.fromSeconds(1));
+ *
+ * (async () => {
+ *   // Will throw an AbortAsyncError
+ *   for (const item of timeoutIterable(iterable, TimeSpan.fromSeconds(5))) {
+ *     console.log(item);
+ *   }
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { timeoutIterable, delay, TimeSpan } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = delayIterable({
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     yield 2;
+ *     yield 3;
+ *     yield 4;
+ *     yield 5;
+ *     yield 6;
+ *     yield 7;
+ *     yield 8;
+ *   }
+ * }, TimeSpan.fromSeconds(1));
+ *
+ * const abortController = new AbortController();
+ * setTimeout(() => {
+ *  abortController.abort("My abort message");
+ * }, TimeSpan.fromSeconds(3));
+ *
+ * (async () => {
+ *   // Will abort after 3 second by throwing AbortAsyncError
+ *   for (const item of timeoutIterable(iterable, TimeSpan.fromSeconds(5), abortController.signal)) {
+ *     console.log(item);
+ *   }
+ * })();
+ * ```
+ */
+export declare function timeoutIterable<TValue>(iterable: AsyncIterable<TValue>, time: TimeSpan, abortSignal?: AbortSignal): AsyncIterable<TValue>;

package/dist/types/collection/_shared.d.ts

@@ -1,5 +1,5 @@
 /**
- * @module Collections
+ * @module Collection
  */
 /**
  * The <i>range</i> function return a <i>{@link Iterable}</i> of numbers, starting from <i>from</i>,increments by 1 and stops at <i>to</i>.

package/dist/types/collection/async-iterable-collection/_shared/async-cross-join-iterable.d.ts

@@ -1,4 +1,5 @@
-import { CrossJoinResult, type IAsyncCollection } from "../../../contracts/collection/_module";
+import type { CrossJoinResult } from "../../../contracts/collection/_module";
+import { type IAsyncCollection } from "../../../contracts/collection/_module";
 import { type AsyncIterableValue } from "../../../_shared/types";
 /**
  * @internal

package/dist/types/collection/async-iterable-collection/_shared/async-group-by-iterable.d.ts

@@ -7,6 +7,6 @@ export declare class AsyncGroupByIterable<TInput, TOutput = TInput> implements A
     private collection;
     private selectFn;
     private makeCollection;
-    constructor(collection: IAsyncCollection<TInput>, selectFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>, makeCollection: <TInput>(iterable: AsyncIterableValue<TInput>) => IAsyncCollection<TInput>);
+    constructor(collection: IAsyncCollection<TInput>, selectFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput> | undefined, makeCollection: <TInput>(iterable: AsyncIterableValue<TInput>) => IAsyncCollection<TInput>);
     [Symbol.asyncIterator](): AsyncIterator<RecordItem<TOutput, IAsyncCollection<TInput>>>;
 }

package/dist/types/collection/async-iterable-collection/async-iterable-collection.d.ts

@@ -1,5 +1,5 @@
 /**
- * @module Collections
+ * @module Collection
  */
 import { type AsyncCollapse, type AsyncPredicate, type AsyncForEach, type AsyncMap, type AsyncModifier, type AsyncTap, type AsyncTransform, type Comparator, type IAsyncCollection, type ChangendItem, type AsyncReduce, type CrossJoinResult } from "../../contracts/collection/_module";
 import { type AsyncIterableValue, type AsyncLazyable, type EnsureType } from "../../_shared/types";
@@ -72,7 +72,7 @@ export declare class AsyncIterableCollection<TInput> implements IAsyncCollection
     insertAfter<TExtended = TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>, iterable: AsyncIterableValue<TInput | TExtended>): IAsyncCollection<TInput | TExtended>;
     crossJoin<TExtended>(iterable: AsyncIterableValue<TExtended>): IAsyncCollection<CrossJoinResult<TInput, TExtended>>;
     zip<TExtended>(iterable: AsyncIterableValue<TExtended>): IAsyncCollection<RecordItem<TInput, TExtended>>;
-    sort(comparator?: Comparator<TInput> | undefined): IAsyncCollection<TInput>;
+    sort(comparator?: Comparator<TInput>): IAsyncCollection<TInput>;
     reverse(chunkSize?: number): IAsyncCollection<TInput>;
     shuffle(mathRandom?: () => number): IAsyncCollection<TInput>;
     first<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): Promise<TOutput | null>;

package/dist/types/collection/iterable-collection/_shared/cross-join-iterable.d.ts

@@ -1,4 +1,4 @@
-import { CrossJoinResult, ICollection } from "../../../contracts/collection/_module";
+import type { CrossJoinResult, ICollection } from "../../../contracts/collection/_module";
 export declare class CrossJoinIterable<TInput, TExtended = TInput> implements Iterable<CrossJoinResult<TInput, TExtended>> {
     private collection;
     private iterable;

package/dist/types/collection/iterable-collection/_shared/group-by-iterable.d.ts

@@ -7,6 +7,6 @@ export declare class GroupByIterable<TInput, TOutput = TInput> implements Iterab
     private collection;
     private selectFn;
     private makeCollection;
-    constructor(collection: ICollection<TInput>, selectFn: Map<TInput, ICollection<TInput>, TOutput>, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
+    constructor(collection: ICollection<TInput>, selectFn: Map<TInput, ICollection<TInput>, TOutput> | undefined, makeCollection: <TInput>(iterable: Iterable<TInput>) => ICollection<TInput>);
     [Symbol.iterator](): Iterator<RecordItem<TOutput, ICollection<TInput>>>;
 }

package/dist/types/collection/iterable-collection/iterable-collection.d.ts

@@ -1,5 +1,5 @@
 /**
- * @module Collections
+ * @module Collection
  */
 import { type Collapse, type Comparator, type Predicate, type ForEach, type ICollection, type Map, type Modifier, type Tap, type Transform, type ChangendItem, type Reduce, type CrossJoinResult } from "../../contracts/collection/_module";
 import { type Lazyable, type EnsureType } from "../../_shared/types";

package/dist/types/collection/list-collection/list-collection.d.ts

@@ -1,5 +1,5 @@
 /**
- * @module Collections
+ * @module Collection
  */
 import { type Collapse, type Comparator, type Predicate, type ICollection, type Map, type Modifier, type Tap, type Transform, type ChangendItem, type Reduce, type ForEach, type CrossJoinResult } from "../../contracts/collection/_module";
 import { type EnsureType, type Lazyable } from "../../_shared/types";

package/dist/types/contracts/_module.d.ts

@@ -1 +1,3 @@
 export * from "../contracts/collection/_module";
+export * from "../contracts/serializer/_module";
+export * from "../contracts/storage/_module";

package/dist/types/contracts/collection/_module.d.ts

@@ -1,6 +1,3 @@
-/**
- * @module Collections
- */
 export * from "../../contracts/collection/_shared";
 export * from "../../contracts/collection/collection.contract";
 export * from "../../contracts/collection/async-collection.contract";

package/dist/types/contracts/collection/_shared.d.ts

@@ -1,5 +1,5 @@
 /**
- * @module Collections
+ * @module Collection
  */
 /**
  * @group Errors

package/dist/types/contracts/collection/async-collection.contract.d.ts

@@ -1,8 +1,8 @@
 /**
- * @module Collections
+ * @module Collection
  */
-import { type AsyncPredicate, type AsyncForEach, type AsyncMap, type AsyncModifier, type AsyncTap, type AsyncTransform, type Comparator, type ChangendItem, AsyncReduce, CrossJoinResult } from "../../contracts/collection/_shared";
-import { type RecordItem, type AsyncLazyable, type EnsureType, type AsyncIterableValue } from "../../_shared/types";
+import type { AsyncReduce, CrossJoinResult, AsyncPredicate, AsyncForEach, AsyncMap, AsyncModifier, AsyncTap, AsyncTransform, Comparator, ChangendItem } from "../../contracts/collection/_shared";
+import type { RecordItem, AsyncLazyable, EnsureType, AsyncIterableValue } from "../../_shared/types";
 export type AsyncCollapse<TValue> = TValue extends Array<infer TItem> | Iterable<infer TItem> | IAsyncCollection<infer TItem> ? TItem : TValue;
 /**
  * <i>IAsyncCollection</i> is immutable. The <i>throwOnIndexOverflow</i> parameter in the <i>IAsyncCollection</i> methods is used for preventing the index to overflow by throwing an error.

package/dist/types/contracts/collection/collection.contract.d.ts

@@ -1,8 +1,8 @@
 /**
- * @module Collections
+ * @module Collection
  */
-import { type Comparator, type Predicate, type ForEach, type Map, type Modifier, type Tap, type Transform, type ChangendItem, type Reduce, type CrossJoinResult } from "../../contracts/collection/_shared";
-import { type Lazyable, type RecordItem, type EnsureType } from "../../_shared/types";
+import type { Comparator, Predicate, ForEach, Map, Modifier, Tap, Transform, ChangendItem, Reduce, CrossJoinResult } from "../../contracts/collection/_shared";
+import type { Lazyable, RecordItem, EnsureType } from "../../_shared/types";
 export type Collapse<TValue> = TValue extends Array<infer TItem> | Iterable<infer TItem> | ICollection<infer TItem> ? TItem : TValue;
 /**
  * <i>ICollection</i> is immutable.

package/dist/types/contracts/serializer/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../contracts/serializer/serializer.contract";

package/dist/types/contracts/serializer/serializer.contract.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @module Serializer
+ */
+/**
+ * @group Errors
+ */
+export declare class SerializerError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class SerializationError extends SerializerError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class DeserializationError extends SerializerError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Contracts
+ * @throws {SerializerError} {@link SerializerError}
+ * @throws {SerializationError} {@link SerializationError}
+ * @throws {DeserializationError} {@link DeserializationError}
+ */
+export type ISerializer<TSerialized = unknown> = {
+    /**
+     * @throws {SerializationError} {@link SerializationError}
+     */
+    serialize<TValue>(value: TValue): Promise<TSerialized>;
+    /**
+     * @throws {DeserializationError} {@link DeserializationError}
+     */
+    deserialize<TValue>(value: TSerialized): Promise<TValue>;
+};

package/dist/types/contracts/storage/_module.d.ts

@@ -0,0 +1,3 @@
+export * from "../../contracts/storage/_shared";
+export * from "../../contracts/storage/storage.contract";
+export * from "../../contracts/storage/storage-adapter.contract";

package/dist/types/contracts/storage/_shared.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module Storage
+ */
+/**
+ * @group Errors
+ */
+export declare class StorageError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class UnexpectedStorageError extends StorageError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class TypeStorageError extends StorageError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class KeyNotFoundStorageError extends StorageError {
+    constructor(message: string, cause?: unknown);
+}