@daiso-tech/core 0.16.0 → 0.19.0

package/dist/types/event-bus/implementations/derivables/event-bus-factory-settings.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @module EventBus
+ */
+import type { BackoffPolicy, RetryPolicy } from "../../../async/_module";
+import type { IGroupableEventBus, IEventBusAdapter } from "../../../event-bus/contracts/_module";
+import type { IFlexibleSerde } from "../../../serde/contracts/_module";
+import type { OneOrMore, TimeSpan } from "../../../utilities/_module";
+/**
+ * @group Derivables
+ */
+export type EventBusAdapters<TAdapters extends string = string> = Partial<Record<TAdapters, IEventBusAdapter>>;
+/**
+ * The <i>EventBusFactorySettings</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Derivables
+ */
+export type EventBusFactorySettings<TAdapters extends string = string> = {
+    /**
+     * You can pass one or more <i>{@link IFlexibleSerde}</i> that will be used to register all <i>{@link IGroupableEventBus}</i> related errors.
+     * @default {true}
+     */
+    serde: OneOrMore<IFlexibleSerde>;
+    /**
+     * If set to true, all <i>{@link IGroupableEventBus}</i> related errors will be registered with the specified <i>IFlexibleSerde</i> during constructor initialization.
+     * This ensures that all <i>{@link IGroupableEventBus}</i> related errors will be serialized correctly.
+     * @default {true}
+     */
+    shouldRegisterErrors?: boolean;
+    adapters: EventBusAdapters<TAdapters>;
+    defaultAdapter?: NoInfer<TAdapters>;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     */
+    eventBus?: IGroupableEventBus<any>;
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    timeout?: TimeSpan | null;
+};
+/**
+ * The <i>EventBusFactorySettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Derivables
+ */
+export declare class EventBusFactorySettingsBuilder<TSettings extends EventBusFactorySettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setShouldRegisterErrors(shouldRegisterErrors: boolean): EventBusFactorySettingsBuilder<TSettings & {
+        shouldRegisterErrors: boolean;
+    }>;
+    setSerde(serde: OneOrMore<IFlexibleSerde>): EventBusFactorySettingsBuilder<TSettings & {
+        serde: OneOrMore<IFlexibleSerde>;
+    }>;
+    setEventBus(eventBus: IGroupableEventBus<any>): EventBusFactorySettingsBuilder<TSettings & {
+        eventBus: IGroupableEventBus<any>;
+    }>;
+    setRetryAttempts(attempts: number | null): EventBusFactorySettingsBuilder<TSettings & {
+        retryAttempts: number | null;
+    }>;
+    setBackoffPolicy(policy: BackoffPolicy | null): EventBusFactorySettingsBuilder<TSettings & {
+        backoffPolicy: BackoffPolicy | null;
+    }>;
+    setRetryPolicy(policy: RetryPolicy | null): EventBusFactorySettingsBuilder<TSettings & {
+        retryPolicy: RetryPolicy | null;
+    }>;
+    setTimeout(time: TimeSpan | null): EventBusFactorySettingsBuilder<TSettings & {
+        timeout: TimeSpan | null;
+    }>;
+    setAdapter<TName extends string>(name: TName, adapter: IEventBusAdapter): EventBusFactorySettingsBuilder<TSettings & {
+        adapters: {
+            readonly [x: string]: IEventBusAdapter | undefined;
+        };
+    }>;
+    setDefaultAdapter(adapter: string): EventBusFactorySettingsBuilder<TSettings & {
+        defaultAdapter: string;
+    }>;
+    build(this: EventBusFactorySettingsBuilder<EventBusFactorySettings>): EventBusFactorySettings;
+}

package/dist/types/event-bus/implementations/derivables/event-bus-factory.d.ts

@@ -1,19 +1,8 @@
 /**
  * @module EventBus
  */
-import type { IGroupableEventBus, IEventBusAdapter, IEventBusFactory, BaseEvents } from "../../../event-bus/contracts/_module";
-/**
- * @group Derivables
- */
-export type EventBusDrivers<TAdapters extends string = string> = Partial<Record<TAdapters, IEventBusAdapter>>;
-/**
- * @group Derivables
- */
-export type EventBusFactorySettings<TAdapters extends string = string> = {
-    drivers: EventBusDrivers<TAdapters>;
-    defaultDriver?: NoInfer<TAdapters>;
-    rootGroup?: string;
-};
+import type { IGroupableEventBus, IEventBusFactory, BaseEvent } from "../../../event-bus/contracts/_module";
+import { type EventBusFactorySettings, EventBusFactorySettingsBuilder } from "../../../event-bus/implementations/derivables/event-bus-factory-settings";
 /**
  * @group Derivables
  * @example
@@ -22,22 +11,54 @@ export type EventBusFactorySettings<TAdapters extends string = string> = {
  * import Redis from "ioredis"
  *
  * const eventBusFactory = new EventBusFactory({
- *   drivers: {
- *     memory: new MemoryEventBusAdapter(),
+ *   adapters: {
+ *     memory: new MemoryEventBusAdapter({ rootGroup: "@global" }),
  *     redis: new RedisPubSubEventBusAdapter({
  *       dispatcherClient: new Redis(),
  *       listenerClient: new Redis(),
+ *       serde: new SuperJsonSerde(),
+ *       rootGroup: "@global"
  *     }),
  *   },
- *   defaultDriver: "memory",
+ *   defaultAdapter: "memory",
  * });
  * ```
  */
-export declare class EventBusFactory<TAdapters extends string = string, TEvents extends BaseEvents = BaseEvents> implements IEventBusFactory<TAdapters, TEvents> {
-    private readonly drivers;
-    private readonly defaultDriver?;
-    private readonly lazyPromiseSettings?;
+export declare class EventBusFactory<TAdapters extends string = string> implements IEventBusFactory<TAdapters> {
+    /**
+     * @example
+     * ```ts
+     * import { EventBusFactory, SuperJsonSerde. MemoryEventBusAdapter, RedisPubSubEventBusAdapter, EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const cacheFactory = new EventBusFactory(
+     *   EventBusFactory
+     *     .settings()
+     *     .setAdapter("memory", new MemoryEventBusAdapter({
+     *       rootGroup: "@global"
+     *     }))
+     *     .setAdapter("redis", new RedisPubSubEventBusAdapter({
+     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION"),
+     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION")
+     *       serde: new SuperJsonSerde(),
+     *       rootGroup: "@global"
+     *     }))
+     *     .setDefaultAdapter("memory")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TAdapters extends string, TSettings extends EventBusFactorySettings<TAdapters>>(): EventBusFactorySettingsBuilder<TSettings>;
+    private readonly eventBuses;
+    private readonly serde;
+    private readonly adapters;
+    private readonly defaultAdapter?;
+    private readonly retryAttempts?;
+    private readonly backoffPolicy?;
+    private readonly retryPolicy?;
+    private readonly timeout?;
+    private readonly shouldRegisterErrors?;
     constructor(settings: EventBusFactorySettings<TAdapters>);
-    use(driverName?: TAdapters | undefined): IGroupableEventBus<TEvents>;
-    withType<TOutput extends BaseEvents = TEvents>(): IEventBusFactory<TAdapters, TOutput>;
+    private initCaches;
+    use<TEvents extends BaseEvent = BaseEvent>(adapterName?: TAdapters | undefined): IGroupableEventBus<TEvents>;
 }

package/dist/types/event-bus/implementations/derivables/event-bus-settings.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @module EventBus
+ */
+import type { BackoffPolicy, RetryPolicy } from "../../../async/_module";
+import { type IGroupableEventBus, type IEventBusAdapter } from "../../../event-bus/contracts/_module";
+import type { IFlexibleSerde } from "../../../serde/contracts/_module";
+import type { IBuildable, OneOrMore, TimeSpan } from "../../../utilities/_module";
+/**
+ * @group Derivables
+ */
+export type EventBusSettings = {
+    /**
+     * You can pass one or more <i>{@link IFlexibleSerde}</i> that will be used to register all <i>{@link IGroupableEventBus}</i> related errors.
+     * @default {true}
+     */
+    serde: OneOrMore<IFlexibleSerde>;
+    /**
+     * If set to true, all <i>{@link IGroupableEventBus}</i> related errors will be registered with the specified <i>IFlexibleSerde</i> during constructor initialization.
+     * This ensures that all <i>{@link IGroupableEventBus}</i> related errors will be serialized correctly.
+     * @default {true}
+     */
+    shouldRegisterErrors?: boolean;
+    adapter: IEventBusAdapter;
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    timeout?: TimeSpan | null;
+};
+/**
+ * The <i>EventBusSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Derivables
+ */
+export declare class EventBusSettingsBuilder<TSettings extends Partial<EventBusSettings>> implements IBuildable<EventBusSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setShouldRegisterErrors(shouldRegisterErrors: boolean): EventBusSettingsBuilder<TSettings & {
+        shouldRegisterErrors: boolean;
+    }>;
+    setSerde(serde: OneOrMore<IFlexibleSerde>): EventBusSettingsBuilder<TSettings & {
+        serde: OneOrMore<IFlexibleSerde>;
+    }>;
+    setAdapter(adapter: IEventBusAdapter): EventBusSettingsBuilder<TSettings & {
+        adapter: IEventBusAdapter;
+    }>;
+    setEventBus(eventBus: IGroupableEventBus<any>): EventBusSettingsBuilder<TSettings & {
+        eventBus: IGroupableEventBus<any>;
+    }>;
+    setDefultTtl(time: TimeSpan): EventBusSettingsBuilder<TSettings & {
+        defaultTtl: TimeSpan;
+    }>;
+    setRetryAttempts(attempts: number | null): EventBusSettingsBuilder<TSettings & {
+        retryAttempts: number | null;
+    }>;
+    setBackoffPolicy(policy: BackoffPolicy | null): EventBusSettingsBuilder<TSettings & {
+        backoffPolicy: BackoffPolicy | null;
+    }>;
+    setRetryPolicy(policy: RetryPolicy | null): EventBusSettingsBuilder<TSettings & {
+        retryPolicy: RetryPolicy | null;
+    }>;
+    setTimeout(time: TimeSpan | null): EventBusSettingsBuilder<TSettings & {
+        timeout: TimeSpan | null;
+    }>;
+    build(this: EventBusSettingsBuilder<EventBusSettings>): EventBusSettings;
+}

package/dist/types/event-bus/implementations/derivables/event-bus.d.ts

@@ -1,35 +1,59 @@
 /**
  * @module EventBus
  */
-import type { LazyPromiseSettings } from "../../../async/_module";
 import { LazyPromise } from "../../../async/_module";
-import type { SelectEvent, AllEvents, BaseEvents, Unsubscribe } from "../../../event-bus/contracts/_module";
-import { type IEventBus, type IGroupableEventBus, type IEventBusAdapter, type Listener } from "../../../event-bus/contracts/_module";
+import type { EventClass, EventInstance, Unsubscribe } from "../../../event-bus/contracts/_module";
+import { type IEventBus, type IGroupableEventBus, type Listener, type BaseEvent, RemoveListenerEventBusError, AddListenerEventBusError, UnexpectedEventBusError, EventBusError } from "../../../event-bus/contracts/_module";
 import type { OneOrMore } from "../../../utilities/_module";
-/**
- * @group Derivables
- */
-export type EventBusSettings = {
-    lazyPromiseSettings?: LazyPromiseSettings;
-};
+import type { EventBusSettings } from "../../../event-bus/implementations/derivables/event-bus-settings";
+import { EventBusSettingsBuilder } from "../../../event-bus/implementations/derivables/event-bus-settings";
 /**
  * <i>EventBus</i> class can be derived from any <i>{@link IEventBusAdapter}</i>.
  * @group Derivables
  */
-export declare class EventBus<TEvents extends BaseEvents = BaseEvents> implements IGroupableEventBus<TEvents> {
-    private readonly eventBusAdapter;
-    private readonly lazyPromiseSettings?;
-    constructor(eventBusAdapter: IEventBusAdapter, settings?: EventBusSettings);
+export declare class EventBus<TEvents extends BaseEvent = BaseEvent> implements IGroupableEventBus<TEvents> {
+    static readonly errors: {
+        readonly Error: typeof EventBusError;
+        readonly Unexpected: typeof UnexpectedEventBusError;
+        readonly RemoveListener: typeof RemoveListenerEventBusError;
+        readonly AddListener: typeof AddListenerEventBusError;
+    };
+    /**
+     * @example
+     * ```ts
+     * import { EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     *
+     * const cache = new EventBus(
+     *   EventBus
+     *     .settings()
+     *     .setAdapter(new MemoryEventBusAdapter({ rootGroup: "@global" }))
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<EventBusSettings>>(): EventBusSettingsBuilder<TSettings>;
+    private readonly serde;
+    private readonly adapter;
+    private readonly retryAttempts;
+    private readonly backoffPolicy;
+    private readonly retryPolicy;
+    private readonly timeout;
+    private readonly shouldRegisterErrors;
+    constructor(settings: EventBusSettings);
+    /**
+     * Registers all event bus related error within the given <i>IFlexibleSerde</i> contract.
+     */
+    private registerErrors;
     private createLayPromise;
     withGroup(group: OneOrMore<string>): IEventBus<TEvents>;
     getGroup(): string;
-    addListener<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
-    removeListener<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
-    dispatchMany(events: AllEvents<TEvents>[]): LazyPromise<void>;
-    dispatch(event: AllEvents<TEvents>): LazyPromise<void>;
-    addListenerMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
-    removeListenerMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
-    listenOnce<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
-    subscribe<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<Unsubscribe>;
-    subscribeMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<Unsubscribe>;
+    addListener<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListener<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    addListenerMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListenerMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    listenOnce<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    subscribe<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    dispatchMany(events: TEvents[]): LazyPromise<void>;
+    dispatch(event: TEvents): LazyPromise<void>;
 }

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

@@ -1,2 +1,6 @@
+export * from "../../serde/contracts/deserializer.contract";
+export * from "../../serde/contracts/flexible-serde.contract";
 export * from "../../serde/contracts/serde.contract";
 export * from "../../serde/contracts/serde.errors";
+export * from "../../serde/contracts/serializable.contract";
+export * from "../../serde/contracts/serializer.contract";

package/dist/types/serde/contracts/deserializer.contract.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serde
+ */
+/**
+ * The <i>IDeserializer</i> contract defines a standard way to deserialize plain data, excluding support for custom classes.
+ * @group Contracts
+ */
+export type IDeserializer<TSerializedValue = unknown> = {
+    /**
+     * @throws {DeserializationError} {@link DeserializationError}
+     */
+    deserialize<TValue>(serializedValue: TSerializedValue): TValue;
+};

package/dist/types/serde/contracts/flexible-serde.contract.d.ts

@@ -0,0 +1,120 @@
+/**
+ * @module Serde
+ */
+import type { ISerializable } from "../../serde/contracts/serializable.contract";
+import type { ISerde } from "../../serde/contracts/serde.contract";
+/**
+ * The <i>SerializableClass</i> contract defines standard way to make a class instance serializable and deserializable.
+ * @group Contracts
+ */
+export type SerializableClass<TSerializedValue> = {
+    new (...arguments_: any[]): ISerializable<TSerializedValue>;
+    deserialize(serializedValue: TSerializedValue): ISerializable<TSerializedValue>;
+};
+/**
+ * The <i>SerializableClass</i> contract defines standard way to make a error class instance serializable and deserializable.
+ * @group Contracts
+ */
+export type ErrorClass = new (...args: any[]) => Error;
+/**
+ * @group Contracts
+ */
+export type ISerdeTransformer<TDeserializedValue, TSerializedValue> = {
+    name: string;
+    isApplicable(value: unknown): value is TDeserializedValue;
+    deserialize(serializedValue: TSerializedValue): TDeserializedValue;
+    serialize(deserializedValue: TDeserializedValue): TSerializedValue;
+};
+/**
+ * The <i>IFlexibleSerde</i> contract defines a standard way to serialize and deserialize both plain data and custom classes.
+ * @group Contracts
+ */
+export type IFlexibleSerde<TSerializedValue = unknown> = ISerde<TSerializedValue> & {
+    /**
+     * The <i>registerClass</i> method is used for registering custom class for serialization and deserialization.
+     * The <i>class_</i> parameter must be of type <i>{@link SerializableClass}</i>.
+     * @example
+     * ```ts
+     * import type { IFlexibleSerde } from "@daiso-tech/core";
+     *
+     * type SerializedUser = {
+     *   name: string;
+     *   age: number;
+     * };
+     *
+     * class User implements ISerializable<SerializedUser> {
+     *   static deserialize(serializedUser: SerializedUser): User {
+     *     return new User(serializedUser.name, serializedUser.age);
+     *   }
+     *
+     *   constructor(public readonly name: string, public readonly age: number) {}
+     *
+     *   getInfo(): string {
+     *     return `name: ${this.name}, age: ${this.age}`;
+     *   }
+     * }
+     *
+     * function main(serde: IFlexibleSerde) {
+     *   // You must register the class before trying to serialize or deserialize it.
+     *   serde.registerClass(User);
+     *
+     *   const user = serde.deserialize(serde.serialize(new User("Jacob", 50)));
+     *
+     *   console.log(user.getInfo());
+     *   // "name: Jacob, age: 50"
+     * }
+     * ```
+     */
+    registerClass<TSerializedClassInstance>(class_: SerializableClass<TSerializedClassInstance>): IFlexibleSerde<TSerializedValue>;
+    /**
+     * The <i>registerCustom</i> method is used for registering custom values for serialization and deserialization.
+     * @example
+     * ```ts
+     * import type { IFlexibleSerde, ISerdeTransformer } from "@daiso-tech/core";
+     *
+     * type SerializedUser = {
+     *   name: string;
+     *   age: number;
+     * };
+     *
+     * class User implements ISerializable<SerializedUser> {
+     *   static deserialize(serializedUser: SerializedUser): User {
+     *     return new User(serializedUser.name, serializedUser.age);
+     *   }
+     *
+     *   constructor(public readonly name: string, public readonly age: number) {}
+     *
+     *   getInfo(): string {
+     *     return `name: ${this.name}, age: ${this.age}`;
+     *   }
+     * }
+     *
+     * const transformer: ISerdeTransformer<User, SerializedUser> = {
+     *   name: User.name,
+     *   isApplicable(value): value is User {
+     *     return (
+     *       value instanceof User &&
+     *       value.constructor.name === User.name
+     *     );
+     *   },
+     *   deserialize(serializedValue) {
+     *     return User.deserialize(serializedValue);
+     *   },
+     *   serialize(deserializedValue) {
+     *     return deserializedValue.serialize();
+     *   }
+     * }
+     *
+     * function main(serde: IFlexibleSerde) {
+     *   // You must register the transformer is it will get applied.
+     *   serde.registerCustom(transformer);
+     *
+     *   const user = serde.deserialize(serde.serialize(new User("Jacob", 50)));
+     *
+     *   console.log(user.getInfo());
+     *   // "name: Jacob, age: 50"
+     * }
+     * ```
+     */
+    registerCustom<TCustomSerialized, TCustomDeserialized>(transformer: ISerdeTransformer<TCustomSerialized, TCustomDeserialized>): IFlexibleSerde<TSerializedValue>;
+};

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

@@ -1,41 +1,10 @@
 /**
- * @group Contracts
- */
-export type ISerializer<TSerializedValue = unknown> = {
-    /**
-     * @throws {SerializationError} {@link SerializationError}
-     */
-    serialize<TValue>(value: TValue): TSerializedValue;
-};
-/**
- * @group Contracts
- */
-export type IDeserde<TSerializedValue = unknown> = {
-    /**
-     * @throws {DeserializationError} {@link DeserializationError}
-     */
-    deserialize<TValue>(serializedValue: TSerializedValue): TValue;
-};
-/**
- * @group Contracts
- */
-export type ISerde<TSerializedValue = unknown> = ISerializer<TSerializedValue> & IDeserde<TSerializedValue>;
-/**
- * @group Contracts
- */
-export type ISerializable<TSerializedValue> = {
-    serialize(): TSerializedValue;
-};
-/**
- * @group Contracts
+ * @module Serde
  */
-export type SerializableClass<TSerializedValue> = {
-    new (...arguments_: any[]): ISerializable<TSerializedValue>;
-    deserialize(serializedValue: TSerializedValue): ISerializable<TSerializedValue>;
-};
+import type { ISerializer } from "../../serde/contracts/serializer.contract";
+import type { IDeserializer } from "../../serde/contracts/deserializer.contract";
 /**
+ * The <i>ISerde</i> contract defines a standard way to serialize and deserialize plain data, excluding support for custom classes.
  * @group Contracts
  */
-export type IFlexibleSerde<TSerializedValue = unknown> = ISerde<TSerializedValue> & {
-    registerClass<TSerializedValue>(class_: SerializableClass<TSerializedValue>): void;
-};
+export type ISerde<TSerializedValue = unknown> = ISerializer<TSerializedValue> & IDeserializer<TSerializedValue>;

package/dist/types/serde/contracts/serializable.contract.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module Serde
+ */
+/**
+ * The <i>ISerializable</i> contract defines standard way to make a class instance serializable.
+ * @group Contracts
+ */
+export type ISerializable<TSerializedValue> = {
+    serialize(): TSerializedValue;
+};

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

@@ -0,0 +1,10 @@
+/**
+ * The <i>ISerializer</i> contract defines a standard way to serialize plain data, excluding support for custom classes.
+ * @group Contracts
+ */
+export type ISerializer<TSerializedValue = unknown> = {
+    /**
+     * @throws {SerializationError} {@link SerializationError}
+     */
+    serialize<TValue>(value: TValue): TSerializedValue;
+};

package/dist/types/serde/implementations/_module.d.ts

@@ -3,3 +3,4 @@ export * from "../../serde/implementations/mongodb-serde/_module";
 export * from "../../serde/implementations/redis-serde/_module";
 export * from "../../serde/implementations/sql-serde/_module";
 export * from "../../serde/implementations/super-json-serde/_module";
+export * from "../../serde/implementations/no-op-serde/_module";

package/dist/types/serde/implementations/_shared/test-utilities/_module.d.ts

@@ -1 +1,2 @@
 export * from "../../../../serde/implementations/_shared/test-utilities/serde.test-suite";
+export * from "../../../../serde/implementations/_shared/test-utilities/flexible-serde.test-suite";

package/dist/types/serde/implementations/_shared/test-utilities/flexible-serde.test-suite.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module Serde
+ */
+import { type TestAPI, type ExpectStatic } from "vitest";
+import type { IFlexibleSerde } from "../../../../serde/contracts/_module";
+/**
+ * @group Utilities
+ */
+export type FlexibleSerdeSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    createAdapter: () => IFlexibleSerde;
+};
+/**
+ * @group Utilities
+ */
+export declare function flexibleSerdeTestSuite(settings: FlexibleSerdeSuiteSettings): void;

package/dist/types/serde/implementations/_shared/test-utilities/serde.test-suite.d.ts

@@ -2,15 +2,14 @@
  * @module Serde
  */
 import { type TestAPI, type ExpectStatic } from "vitest";
-import { type ISerde } from "../../../../serde/contracts/_module";
-import { type Promisable } from "../../../../utilities/_module";
+import type { ISerde } from "../../../../serde/contracts/_module";
 /**
  * @group Utilities
  */
 export type SerdeSuiteSettings = {
     expect: ExpectStatic;
     test: TestAPI;
-    createAdapter: () => Promisable<ISerde>;
+    createAdapter: () => ISerde;
 };
 /**
  * @group Utilities

package/dist/types/serde/implementations/no-op-serde/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../serde/implementations/no-op-serde/no-op-serde";

package/dist/types/serde/implementations/no-op-serde/no-op-serde.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module EventBus
+ */
+import type { IFlexibleSerde, ISerdeTransformer, SerializableClass } from "../../../serde/contracts/_module";
+/**
+ * This <i>NoOpSerde</i> will do nothing and is used for easily mocking {@link IFlexibleSerde} or {@link ISerde} for testing.
+ * @group Adapters
+ */
+export declare class NoOpSerde<TSerializedValue> implements IFlexibleSerde<TSerializedValue> {
+    serialize<TValue>(value: TValue): TSerializedValue;
+    deserialize<TValue>(serializedValue: TSerializedValue): TValue;
+    registerClass<TSerializedClassInstance>(_class: SerializableClass<TSerializedClassInstance>): IFlexibleSerde<TSerializedValue>;
+    registerCustom<TCustomSerialized, TCustomDeserialized>(_transformer: ISerdeTransformer<TCustomSerialized, TCustomDeserialized>): IFlexibleSerde<TSerializedValue>;
+}