@daiso-tech/core 0.15.0 → 0.17.4

package/dist/types/event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/redis-pub-sub-event-bus-adapter.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @module EventBus
+ */
+import type { BaseEvent, IEventBusAdapter, Listener } from "../../../../event-bus/contracts/_module";
+import type { OneOrMore } from "../../../../utilities/_module";
+import type { RedisPubSubEventBusAdapterSettings } from "../../../../event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/redis-pub-sub-event-bus-adapter-settings";
+import { RedisPubSubEventBusAdapterSettingsBuilder } from "../../../../event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/redis-pub-sub-event-bus-adapter-settings";
+/**
+ * To utilize the <i>RedisPubSubEventBusAdapter</i>, you must install the <i>"ioredis"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
+ * @group Adapters
+ */
+export declare class RedisPubSubEventBusAdapter implements IEventBusAdapter {
+    /**
+     * @example
+     * ```ts
+     * import { RedisPubSubEventBusAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const cacheAdapter = new RedisPubSubEventBusAdapter(
+     *   RedisPubSubEventBusAdapter
+     *     .settings()
+     *     .setDispatcherClient(new Redis("YOUR REDIS CONNECTION"))
+     *     .setListenerClient(new Redis("YOUR REDIS CONNECTION"))
+     *     .setSerde(new SuperJsonSerde())
+     *     .setRootGroup("@global")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<RedisPubSubEventBusAdapterSettings>>(): RedisPubSubEventBusAdapterSettingsBuilder<TSettings>;
+    private readonly group;
+    private readonly baseSerde;
+    private readonly redisSerde;
+    private readonly dispatcherClient;
+    private readonly listenerClient;
+    private readonly eventEmitter;
+    /**
+     * @example
+     * ```ts
+     * import { RedisPubSubEventBusAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const dispatcherClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
+     * const listenerClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
+     * const serde = new SuperJsonSerde();
+     * const eventBusAdapter = new RedisPubSubEventBusAdapter({
+     *   dispatcherClient,
+     *   listenerClient,
+     *   serde,
+     *   rootGroup: "@global"
+     * });
+     * ```
+     */
+    constructor({ dispatcherClient, listenerClient, serde, rootGroup, }: RedisPubSubEventBusAdapterSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): IEventBusAdapter;
+    private withPrefix;
+    private redisListener;
+    addListener(eventName: string, listener: Listener<BaseEvent>): Promise<void>;
+    removeListener(eventName: string, listener: Listener<BaseEvent>): Promise<void>;
+    dispatch(eventName: string, eventData: BaseEvent): Promise<void>;
+}

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

@@ -1,2 +1,4 @@
-export * from "../../../event-bus/implementations/derivables/event-bus";
+export * from "../../../event-bus/implementations/derivables/event-bus-factory-settings";
 export * from "../../../event-bus/implementations/derivables/event-bus-factory";
+export * from "../../../event-bus/implementations/derivables/event-bus-settings";
+export * from "../../../event-bus/implementations/derivables/event-bus";

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

@@ -0,0 +1,70 @@
+/**
+ * @module EventBus
+ */
+import type { BackoffPolicy, RetryPolicy } from "../../../async/_module";
+import type { IGroupableEventBus, IEventBusAdapter } from "../../../event-bus/contracts/_module";
+import type { 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> = {
+    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>.
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     */
+    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);
+    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 { INamespacedEventBus, 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>;
-    rootNamespace?: 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,23 +11,50 @@ export type EventBusFactorySettings<TAdapters extends string = string> = {
  * import Redis from "ioredis"
  *
  * const eventBusFactory = new EventBusFactory({
- *   drivers: {
- *     memory: new MemoryEventBusAdapter(),
- *     redis: new RedisEventBusAdapter({
+ *   adapters: {
+ *     memory: new MemoryEventBusAdapter({ rootGroup: "@global" }),
+ *     redis: new RedisPubSubEventBusAdapter({
  *       dispatcherClient: new Redis(),
  *       listenerClient: new Redis(),
+ *       serde: new SuperJsonSerde(),
+ *       rootGroup: "@global"
  *     }),
  *   },
- *   defaultDriver: "memory",
- *   rootNamespace: "@events"
+ *   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 rootNamespace?;
+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 adapters;
+    private readonly defaultAdapter?;
+    private readonly retryAttempts?;
+    private readonly backoffPolicy?;
+    private readonly retryPolicy?;
+    private readonly timeout?;
     constructor(settings: EventBusFactorySettings<TAdapters>);
-    use(driverName?: TAdapters | undefined): INamespacedEventBus<TEvents>;
-    withType<TOutput extends BaseEvents = TEvents>(): IEventBusFactory<TAdapters, TOutput>;
+    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,58 @@
+/**
+ * @module EventBus
+ */
+import type { BackoffPolicy, RetryPolicy } from "../../../async/_module";
+import { type IGroupableEventBus, type IEventBusAdapter } from "../../../event-bus/contracts/_module";
+import type { IBuildable, TimeSpan } from "../../../utilities/_module";
+/**
+ * @group Derivables
+ */
+export type EventBusSettings = {
+    adapter: IEventBusAdapter;
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     */
+    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);
+    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

@@ -2,60 +2,46 @@
  * @module EventBus
  */
 import { LazyPromise } from "../../../async/_module";
-import type { SelectEvent, AllEvents, BaseEvents } from "../../../event-bus/contracts/_module";
-import { type IEventBus, type INamespacedEventBus, 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 } from "../../../event-bus/contracts/_module";
 import type { OneOrMore } from "../../../utilities/_module";
-import { BaseEventBus } from "../../../event-bus/implementations/derivables/base-event-bus";
+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 type EventBusSettings = {
+export declare class EventBus<TEvents extends BaseEvent = BaseEvent> implements IGroupableEventBus<TEvents> {
     /**
-     * You can prefix all keys with a given <i>namespace</i>.
-     * This useful if you want to add multitenancy but still use the same database.
-     * @default {""}
      * @example
      * ```ts
      * import { EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
      *
-     * const memoryEventBusAdapter = new MemoryEventBusAdapter();
-     * const eventBusA = new EventBus(memoryEventBusAdapter, {
-     *   rootNamespace: "@a"
-     * });
-     * const eventBusB = new EventBus(memoryEventBusAdapter, {
-     *   rootNamespace: "@b"
-     * });
-     *
-     * (async () => {
-     *   eventBusB.addListener("add", event => {
-     *     // This will never be logged because eventBusB has different namespace
-     *     console.log("eventBusB:", event);
-     *   });
-     *
-     *   eventBusB.addListener("add", event => {
-     *     // This will be logged
-     *     console.log("eventBusB:", event);
-     *   });
-     *
-     *   await eventBusA.dispatch([
-     *     { type: "add", a: 1, b: 2 }
-     *   ]);
-     * })();
+     * const cache = new EventBus(
+     *   EventBus
+     *     .settings()
+     *     .setAdapter(new MemoryEventBusAdapter({ rootGroup: "@global" }))
+     *     .build()
+     * );
      * ```
      */
-    rootNamespace?: OneOrMore<string>;
-};
-/**
- * <i>EventBus</i> class can be derived from any <i>{@link IEventBusAdapter}</i>.
- * @group Derivables
- */
-export declare class EventBus<TEvents extends BaseEvents = BaseEvents> extends BaseEventBus<TEvents> implements INamespacedEventBus<TEvents> {
-    private readonly eventBusAdapter;
-    private readonly namespace;
-    constructor(eventBusAdapter: IEventBusAdapter, settings?: EventBusSettings);
-    withNamespace(namespace: OneOrMore<string>): IEventBus<TEvents>;
-    getNamespace(): 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>;
-    dispatch(events: OneOrMore<AllEvents<TEvents>>): LazyPromise<void>;
+    static settings<TSettings extends Partial<EventBusSettings>>(): EventBusSettingsBuilder<TSettings>;
+    private readonly adapter;
+    private readonly retryAttempts;
+    private readonly backoffPolicy;
+    private readonly retryPolicy;
+    private readonly timeout;
+    constructor(settings: EventBusSettings);
+    private createLayPromise;
+    withGroup(group: OneOrMore<string>): IEventBus<TEvents>;
+    getGroup(): string;
+    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

@@ -0,0 +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,56 @@
+/**
+ * @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>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>;
+};

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

@@ -0,0 +1,10 @@
+/**
+ * @module Serde
+ */
+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 ISerde<TSerializedValue = unknown> = ISerializer<TSerializedValue> & IDeserializer<TSerializedValue>;

package/dist/types/{serializer/contracts/serializer.errors.d.ts → serde/contracts/serde.errors.d.ts}

@@ -1,21 +1,21 @@
 /**
- * @module Serializer
+ * @module Serde
  */
 /**
  * @group Errors
  */
-export declare class SerializerError extends Error {
+export declare class SerdeError extends Error {
     constructor(message: string, cause?: unknown);
 }
 /**
  * @group Errors
  */
-export declare class SerializationError extends SerializerError {
+export declare class SerializationError extends SerdeError {
     constructor(message: string, cause?: unknown);
 }
 /**
  * @group Errors
  */
-export declare class DeserializationError extends SerializerError {
+export declare class DeserializationError extends SerdeError {
     constructor(message: string, cause?: unknown);
 }

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

@@ -0,0 +1,6 @@
+export * from "../../serde/implementations/_shared/test-utilities/_module";
+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

@@ -0,0 +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

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

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

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

package/dist/types/serde/implementations/mongodb-serde/mongodb-serde.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serde
+ */
+import { type ISerde } from "../../../serde/contracts/_module";
+/**
+ * @internal
+ */
+export declare class MongodbSerde implements ISerde<string | number> {
+    private readonly serde;
+    constructor(serde: ISerde<string>);
+    serialize<TValue>(value: TValue): string | number;
+    deserialize<TValue>(value: string | number): TValue;
+}

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,13 @@
+/**
+ * @module EventBus
+ */
+import type { IFlexibleSerde, 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>;
+}

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

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

package/dist/types/serde/implementations/redis-serde/redis-serde.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serde
+ */
+import { type ISerde } from "../../../serde/contracts/_module";
+/**
+ * @internal
+ */
+export declare class RedisSerde implements ISerde<string> {
+    private readonly serde;
+    constructor(serde: ISerde<string>);
+    serialize<TValue>(value: TValue): string;
+    deserialize<TValue>(value: string): TValue;
+}

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

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

package/dist/types/serde/implementations/sql-serde/sql-serde.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serde
+ */
+import { type ISerde } from "../../../serde/contracts/_module";
+/**
+ * @internal
+ */
+export declare class SqlSerde implements ISerde<string> {
+    private readonly serde;
+    constructor(serde: ISerde<string>);
+    serialize<TValue>(value: TValue): string;
+    deserialize<TValue>(value: string): TValue;
+}

package/dist/types/serde/implementations/super-json-serde/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../serde/implementations/super-json-serde/super-json-serde";