@globalart/ddd 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,767 @@
+import { z } from "zod";
+import { Option, Result } from "oxide.ts";
+
+//#region src/event.d.ts
+declare const eventSchema: <TName extends string, TPayload extends z.ZodTypeAny, TMeta extends z.ZodTypeAny>(name: TName, payload: TPayload, meta: TMeta) => z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodLiteral<TName>;
+  operatorId: z.ZodOptional<z.ZodString>;
+  payload: TPayload;
+  timestamp: z.ZodCoercedDate<unknown>;
+  meta: TMeta;
+}, z.core.$strip>;
+interface IEvent<TPayload extends object = object, TMeta = any> {
+  id: string;
+  name: string;
+  operatorId: string;
+  payload: TPayload;
+  timestamp: Date;
+  meta: TMeta;
+}
+interface IEventJSON<TPayload extends object = object, TMeta = any> {
+  id: string;
+  name: string;
+  operatorId: string;
+  payload: TPayload;
+  timestamp: string;
+  meta: TMeta;
+}
+declare abstract class BaseEvent<TPayload extends object = object, TName extends string = string, TMeta extends any = {
+  key?: string;
+  headers?: Record<string, string>;
+}> implements IEvent<TPayload> {
+  readonly payload: TPayload;
+  readonly operatorId: string;
+  readonly meta: TMeta;
+  readonly id: string;
+  readonly timestamp: Date;
+  abstract name: TName;
+  constructor(payload: TPayload, operatorId: string, meta: TMeta, id?: string, timestamp?: Date);
+  toJSON(): IEventJSON<TPayload, TMeta>;
+}
+//#endregion
+//#region src/aggregate-root.d.ts
+declare abstract class AggregateRoot<E extends BaseEvent> {
+  #private;
+  get domainEvents(): E[];
+  set domainEvents(events: E[]);
+  addDomainEvent(event: E): void;
+  removeEvents(events: E[]): void;
+}
+//#endregion
+//#region src/command.d.ts
+type CommandProps<T> = Omit<T, 'correlationId' | 'commandId'> & Partial<Command>;
+declare abstract class Command {
+  readonly commandId: string;
+  readonly correlationId: string;
+  readonly causationId?: string;
+  constructor(props: CommandProps<unknown>);
+}
+//#endregion
+//#region src/command-bus.d.ts
+interface ICommandBus<TCommand extends Command = Command> {
+  execute<TResult>(command: TCommand): Promise<TResult>;
+}
+//#endregion
+//#region src/command-handler.d.ts
+interface ICommandHandler<TCommand extends Command, TResult> {
+  execute(command: TCommand): Promise<TResult>;
+}
+//#endregion
+//#region src/event-handler.d.ts
+interface IEventHandler<TEvent extends IEvent, TResult = void> {
+  handle(event: TEvent): Promise<TResult> | TResult;
+}
+//#endregion
+//#region src/exception.base.d.ts
+interface SerializedException {
+  message: string;
+  code: string;
+  correlationId?: string;
+  stack?: string;
+  cause?: string;
+  metadata?: unknown;
+}
+declare abstract class ExceptionBase extends Error {
+  readonly message: string;
+  readonly cause?: Error | undefined;
+  readonly metadata?: unknown | undefined;
+  abstract code: string;
+  readonly correlationId?: string;
+  /**
+   *
+   * @param message
+   * @param correlationId
+   * @param cause
+   * @param metadata
+   */
+  constructor(message: string, correlationId?: string, cause?: Error | undefined, metadata?: unknown | undefined);
+  toJSON(): SerializedException;
+}
+//#endregion
+//#region src/filter/base.filter.d.ts
+declare const baseFilter: z.ZodObject<{
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//#endregion
+//#region src/filter/conjunction.d.ts
+declare const conjunctions: z.ZodUnion<readonly [z.ZodLiteral<"$and">, z.ZodLiteral<"$or">, z.ZodLiteral<"$not">]>;
+type IConjunction = z.infer<typeof conjunctions>;
+//#endregion
+//#region src/specification.d.ts
+interface ISpecVisitor {
+  or(left: ISpecification, right: ISpecification): this;
+  not(): this;
+}
+interface ISpecification<T = any, V extends ISpecVisitor = ISpecVisitor> {
+  isSatisfiedBy(t: T): boolean;
+  mutate(t: T): Result<T, string>;
+  accept(v: V): Result<void, string>;
+}
+declare abstract class CompositeSpecification<T = any, V extends ISpecVisitor = ISpecVisitor> implements ISpecification<T, V> {
+  abstract isSatisfiedBy(t: T): boolean;
+  abstract mutate(t: T): Result<T, string>;
+  abstract accept(v: V): Result<void, string>;
+  and(s: ISpecification<T, V>): CompositeSpecification<T, V>;
+  or(s: ISpecification<T, V>): CompositeSpecification<T, V>;
+  not(): Not<T, V>;
+}
+declare class Not<T, V extends ISpecVisitor> extends CompositeSpecification<T, V> {
+  readonly spec: ISpecification<T, V>;
+  constructor(spec: ISpecification<T, V>);
+  isSatisfiedBy(t: T): boolean;
+  mutate(): Result<T, string>;
+  accept(v: V): Result<void, string>;
+}
+declare const and: <T, V extends ISpecVisitor>(...specs: CompositeSpecification<T, V>[]) => Option<CompositeSpecification<T, V>>;
+declare const andOptions: <T, V extends ISpecVisitor>(...specs: Option<CompositeSpecification<T, V>>[]) => Option<CompositeSpecification<T, V>>;
+declare const or: <T, V extends ISpecVisitor>(...specs: CompositeSpecification<T, V>[]) => Option<CompositeSpecification<T, V>>;
+//#endregion
+//#region src/value-objects/value-object.d.ts
+type Primitives = string | number | boolean | null;
+interface DomainPrimitive<T extends Primitives | Date> {
+  value: T;
+}
+type ValueObjectProps<T> = T extends Primitives | Date ? DomainPrimitive<T> : T;
+declare abstract class ValueObject<T = any> {
+  protected readonly props: ValueObjectProps<T>;
+  constructor(props: ValueObjectProps<T>);
+  equals(vo?: ValueObject<T>): boolean;
+  static isValueObject(obj: unknown): obj is ValueObject<unknown>;
+  unpack(): T;
+  private isDomainPrimitive;
+}
+//#endregion
+//#region src/filter/fields/number/number-field.type.d.ts
+declare const numberFieldValue: z.ZodUnion<[z.ZodNumber, z.ZodNull]>;
+type INumberFieldValue = z.infer<typeof numberFieldValue>;
+//#endregion
+//#region src/filter/fields/number/number-field-value.d.ts
+declare class NumberFieldValue extends FieldValueBase<INumberFieldValue> {
+  constructor(value: INumberFieldValue);
+  accept(visitor: IFieldValueVisitor): void;
+}
+//#endregion
+//#region src/filter/fields/string/string-field.type.d.ts
+declare const stringFieldValue: z.ZodNullable<z.ZodString>;
+type IStringFieldValue = z.infer<typeof stringFieldValue>;
+//#endregion
+//#region src/filter/fields/string/string-field-value.d.ts
+declare class StringFieldValue extends FieldValueBase<IStringFieldValue> {
+  constructor(value: IStringFieldValue);
+  accept(visitor: IFieldValueVisitor): void;
+}
+//#endregion
+//#region src/filter/fields/field-value.visitor.d.ts
+interface IFieldValueVisitor {
+  number(value: NumberFieldValue): void;
+  string(value: StringFieldValue): void;
+  date(value: DateFieldValue): void;
+}
+//#endregion
+//#region src/filter/fields/date/date-field.type.d.ts
+declare const dateFieldValue: z.ZodNullable<z.ZodDate>;
+type IDateFieldValue = z.infer<typeof dateFieldValue>;
+//#endregion
+//#region src/filter/fields/field.type.d.ts
+type UnpackedFieldValue = IStringFieldValue | INumberFieldValue | IDateFieldValue;
+//#endregion
+//#region src/filter/fields/field-value.base.d.ts
+declare abstract class FieldValueBase<V extends UnpackedFieldValue> extends ValueObject<V> {
+  abstract accept(visitor: IFieldValueVisitor): void;
+}
+//#endregion
+//#region src/filter/fields/date/date-field-value.d.ts
+declare class DateFieldValue extends FieldValueBase<IDateFieldValue> {
+  constructor(value: IDateFieldValue);
+  accept(visitor: IFieldValueVisitor): void;
+  static fromNullableString(str: string | null): DateFieldValue;
+}
+//#endregion
+//#region src/filter/specifications/date.specification.d.ts
+declare class DateEqual extends BaseFilterSpecification<unknown, DateFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class DateGreaterThan extends BaseFilterSpecification<unknown, DateFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class DateLessThan extends BaseFilterSpecification<unknown, DateFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class DateGreaterThanOrEqual extends BaseFilterSpecification<unknown, DateFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class DateLessThanOrEqual extends BaseFilterSpecification<unknown, DateFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class DateIsToday extends BaseFilterSpecification<unknown, DateFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class DateIsTomorrow extends BaseFilterSpecification<unknown, DateFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class DateIsYesterday extends BaseFilterSpecification<unknown, DateFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class DateBetween extends BaseFilterSpecification<unknown, DateFieldValue> {
+  field: string;
+  dateStart: Date;
+  dateEnd: Date;
+  relation?: string | undefined;
+  constructor(field: string, dateStart: Date, dateEnd: Date, relation?: string | undefined);
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+//#endregion
+//#region src/filter/specifications/number.specification.d.ts
+declare class NumberEqual extends BaseFilterSpecification<unknown, NumberFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class NumberGreaterThan extends BaseFilterSpecification<unknown, NumberFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class NumberLessThan extends BaseFilterSpecification<unknown, NumberFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class NumberGreaterThanOrEqual extends BaseFilterSpecification<unknown, NumberFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class NumberLessThanOrEqual extends BaseFilterSpecification<unknown, NumberFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class NumberEmpty extends BaseFilterSpecification<unknown, NumberFieldValue> {
+  readonly field: string;
+  constructor(field: string);
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+//#endregion
+//#region src/filter/specifications/string.specification.d.ts
+declare class StringEqual extends BaseFilterSpecification<unknown, StringFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class StringNotEqual extends BaseFilterSpecification<unknown, StringFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class StringContain extends BaseFilterSpecification<unknown, StringFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class StringStartsWith extends BaseFilterSpecification<unknown, StringFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class StringEndsWith extends BaseFilterSpecification<unknown, StringFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class StringRegex extends BaseFilterSpecification<unknown, StringFieldValue> {
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+declare class StringEmpty extends BaseFilterSpecification<unknown, StringFieldValue> {
+  constructor(field: string);
+  isSatisfiedBy(value: unknown): boolean;
+  accept(v: IFilterBaseVisitor): Result<void, string>;
+}
+//#endregion
+//#region src/filter/filter-specification-visitor.base.d.ts
+interface IFilterSpecBaseVisitor {
+  idEqual(): void;
+  idsIn(): void;
+}
+interface IFilterValueBaseVisitor {
+  stringEqual(s: StringEqual): void;
+  stringNotEqual(s: StringNotEqual): void;
+  stringContain(s: StringContain): void;
+  stringStartsWith(s: StringStartsWith): void;
+  stringEndsWith(s: StringEndsWith): void;
+  stringRegex(s: StringRegex): void;
+  stringEmpty(s: StringEmpty): void;
+  like(): void;
+  numberEqual(s: NumberEqual): void;
+  numberGreaterThan(s: NumberGreaterThan): void;
+  numberLessThan(s: NumberLessThan): void;
+  numberGreaterThanOrEqual(s: NumberGreaterThanOrEqual): void;
+  numberLessThanOrEqual(s: NumberLessThanOrEqual): void;
+  numberEmpty(s: NumberEmpty): void;
+  dateEqual(s: DateEqual): void;
+  dateGreaterThan(s: DateGreaterThan): void;
+  dateLessThan(s: DateLessThan): void;
+  dateGreaterThanOrEqual(s: DateGreaterThanOrEqual): void;
+  dateLessThanOrEqual(s: DateLessThanOrEqual): void;
+  dateIsToday(s: DateIsToday): void;
+  dateIsTomorrow(s: DateIsTomorrow): void;
+  dateIsYesterday(s: DateIsYesterday): void;
+  dateBetween(s: DateBetween): void;
+  dateRangeEqual(): void;
+  dateRangeEmpty(): void;
+  dateRangeDateEqual(): void;
+  dateRangeDateGreaterThan(): void;
+  dateRangeDateLessThan(): void;
+  dateRangeDateGreaterThanOrEqual(): void;
+  dateRangeDateLessThanOrEqual(): void;
+  boolIsTrue(): void;
+  boolIsFalse(): void;
+  jsonEmpty(): void;
+}
+type IFilterBaseVisitor = IFilterSpecBaseVisitor & IFilterValueBaseVisitor & ISpecVisitor;
+//#endregion
+//#region src/filter/filter-specification.base.d.ts
+declare abstract class BaseFilterSpecification<E = unknown, V = unknown> extends CompositeSpecification<E, IFilterBaseVisitor> {
+  readonly field: string;
+  readonly value: V;
+  readonly relation?: string | undefined;
+  constructor(field: string, value: V, relation?: string | undefined);
+  mutate(t: E): Result<E, string>;
+}
+//#endregion
+//#region src/filter/filter.d.ts
+declare const filterRoorFilter: <T extends z.ZodType>(filters: [T, ...T[]]) => z.ZodUnion<[z.ZodType<{
+  conjunction?: IConjunction;
+  children?: (z.infer<z.ZodType< /*elided*/any, unknown, z.core.$ZodTypeInternals< /*elided*/any, unknown>>> | z.infer<z.ZodUnion<[T, T, ...T[]]>>)[];
+}, unknown, z.core.$ZodTypeInternals<{
+  conjunction?: IConjunction;
+  children?: (z.infer<z.ZodType< /*elided*/any, unknown, z.core.$ZodTypeInternals< /*elided*/any, unknown>>> | z.infer<z.ZodUnion<[T, T, ...T[]]>>)[];
+}, unknown>>, z.ZodArray<z.ZodUnion<[z.ZodUnion<[T, T, ...T[]]>, z.ZodType<{
+  conjunction?: IConjunction;
+  children?: (z.infer<z.ZodType< /*elided*/any, unknown, z.core.$ZodTypeInternals< /*elided*/any, unknown>>> | z.infer<z.ZodUnion<[T, T, ...T[]]>>)[];
+}, unknown, z.core.$ZodTypeInternals<{
+  conjunction?: IConjunction;
+  children?: (z.infer<z.ZodType< /*elided*/any, unknown, z.core.$ZodTypeInternals< /*elided*/any, unknown>>> | z.infer<z.ZodUnion<[T, T, ...T[]]>>)[];
+}, unknown>>]>>]>;
+declare const filter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"number">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+  value: z.ZodNullable<z.ZodNumber>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"string">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$contains">, z.ZodLiteral<"$not_contains">, z.ZodLiteral<"$starts_with">, z.ZodLiteral<"$ends_with">, z.ZodLiteral<"$regex">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+  value: z.ZodNullable<z.ZodString>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"date">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$between">, z.ZodLiteral<"$is_today">, z.ZodLiteral<"$is_tomorrow">, z.ZodLiteral<"$is_yesterday">, z.ZodLiteral<"$is_not_today">]>;
+  value: z.ZodUnion<[z.ZodNullable<z.ZodString>, z.ZodTuple<[z.ZodString, z.ZodString], null>]>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+type IFilter = z.infer<typeof filter>;
+type IFilters = IFilter[];
+interface IGroup<Filter extends IFilter = IFilter> {
+  conjunction?: IConjunction;
+  children?: IFilterOrGroupList<Filter>;
+}
+type IFilterOrGroup<Filter extends IFilter = IFilter> = Filter | IGroup<Filter>;
+declare const filterOrGroupList: z.ZodArray<z.ZodUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"number">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+  value: z.ZodNullable<z.ZodNumber>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"string">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$contains">, z.ZodLiteral<"$not_contains">, z.ZodLiteral<"$starts_with">, z.ZodLiteral<"$ends_with">, z.ZodLiteral<"$regex">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+  value: z.ZodNullable<z.ZodString>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"date">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$between">, z.ZodLiteral<"$is_today">, z.ZodLiteral<"$is_tomorrow">, z.ZodLiteral<"$is_yesterday">, z.ZodLiteral<"$is_not_today">]>;
+  value: z.ZodUnion<[z.ZodNullable<z.ZodString>, z.ZodTuple<[z.ZodString, z.ZodString], null>]>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">, z.ZodType<IGroup<{
+  type: "number";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$is_empty" | "$is_not_empty";
+  value: number | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "string";
+  operator: "$eq" | "$neq" | "$is_empty" | "$is_not_empty" | "$contains" | "$not_contains" | "$starts_with" | "$ends_with" | "$regex";
+  value: string | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "date";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$between" | "$is_today" | "$is_tomorrow" | "$is_yesterday" | "$is_not_today";
+  value: string | [string, string] | null;
+  field: string;
+  relation?: string | undefined;
+}>, unknown, z.core.$ZodTypeInternals<IGroup<{
+  type: "number";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$is_empty" | "$is_not_empty";
+  value: number | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "string";
+  operator: "$eq" | "$neq" | "$is_empty" | "$is_not_empty" | "$contains" | "$not_contains" | "$starts_with" | "$ends_with" | "$regex";
+  value: string | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "date";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$between" | "$is_today" | "$is_tomorrow" | "$is_yesterday" | "$is_not_today";
+  value: string | [string, string] | null;
+  field: string;
+  relation?: string | undefined;
+}>, unknown>>]>>;
+type IFilterOrGroupList<Filter extends IFilter = IFilter> = IFilterOrGroup<Filter>[];
+declare const rootFilter: z.ZodUnion<[z.ZodUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"number">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+  value: z.ZodNullable<z.ZodNumber>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"string">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$contains">, z.ZodLiteral<"$not_contains">, z.ZodLiteral<"$starts_with">, z.ZodLiteral<"$ends_with">, z.ZodLiteral<"$regex">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+  value: z.ZodNullable<z.ZodString>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"date">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$between">, z.ZodLiteral<"$is_today">, z.ZodLiteral<"$is_tomorrow">, z.ZodLiteral<"$is_yesterday">, z.ZodLiteral<"$is_not_today">]>;
+  value: z.ZodUnion<[z.ZodNullable<z.ZodString>, z.ZodTuple<[z.ZodString, z.ZodString], null>]>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">, z.ZodType<IGroup<{
+  type: "number";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$is_empty" | "$is_not_empty";
+  value: number | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "string";
+  operator: "$eq" | "$neq" | "$is_empty" | "$is_not_empty" | "$contains" | "$not_contains" | "$starts_with" | "$ends_with" | "$regex";
+  value: string | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "date";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$between" | "$is_today" | "$is_tomorrow" | "$is_yesterday" | "$is_not_today";
+  value: string | [string, string] | null;
+  field: string;
+  relation?: string | undefined;
+}>, unknown, z.core.$ZodTypeInternals<IGroup<{
+  type: "number";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$is_empty" | "$is_not_empty";
+  value: number | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "string";
+  operator: "$eq" | "$neq" | "$is_empty" | "$is_not_empty" | "$contains" | "$not_contains" | "$starts_with" | "$ends_with" | "$regex";
+  value: string | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "date";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$between" | "$is_today" | "$is_tomorrow" | "$is_yesterday" | "$is_not_today";
+  value: string | [string, string] | null;
+  field: string;
+  relation?: string | undefined;
+}>, unknown>>]>, z.ZodArray<z.ZodUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"number">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+  value: z.ZodNullable<z.ZodNumber>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"string">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$contains">, z.ZodLiteral<"$not_contains">, z.ZodLiteral<"$starts_with">, z.ZodLiteral<"$ends_with">, z.ZodLiteral<"$regex">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+  value: z.ZodNullable<z.ZodString>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"date">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$between">, z.ZodLiteral<"$is_today">, z.ZodLiteral<"$is_tomorrow">, z.ZodLiteral<"$is_yesterday">, z.ZodLiteral<"$is_not_today">]>;
+  value: z.ZodUnion<[z.ZodNullable<z.ZodString>, z.ZodTuple<[z.ZodString, z.ZodString], null>]>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">, z.ZodType<IGroup<{
+  type: "number";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$is_empty" | "$is_not_empty";
+  value: number | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "string";
+  operator: "$eq" | "$neq" | "$is_empty" | "$is_not_empty" | "$contains" | "$not_contains" | "$starts_with" | "$ends_with" | "$regex";
+  value: string | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "date";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$between" | "$is_today" | "$is_tomorrow" | "$is_yesterday" | "$is_not_today";
+  value: string | [string, string] | null;
+  field: string;
+  relation?: string | undefined;
+}>, unknown, z.core.$ZodTypeInternals<IGroup<{
+  type: "number";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$is_empty" | "$is_not_empty";
+  value: number | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "string";
+  operator: "$eq" | "$neq" | "$is_empty" | "$is_not_empty" | "$contains" | "$not_contains" | "$starts_with" | "$ends_with" | "$regex";
+  value: string | null;
+  field: string;
+  relation?: string | undefined;
+} | {
+  type: "date";
+  operator: "$eq" | "$neq" | "$gt" | "$gte" | "$lt" | "$lte" | "$between" | "$is_today" | "$is_tomorrow" | "$is_yesterday" | "$is_not_today";
+  value: string | [string, string] | null;
+  field: string;
+  relation?: string | undefined;
+}>, unknown>>]>>]>;
+type IRootFilter<Filter extends IFilter = IFilter> = IFilterOrGroup<Filter> | IFilterOrGroupList<Filter>;
+declare const isGroup: (filterOrGroup: IFilterOrGroup) => filterOrGroup is IGroup;
+declare const isFilter: (filterOrGroup: IFilterOrGroup) => filterOrGroup is IFilter;
+declare const operators: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>, z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$contains">, z.ZodLiteral<"$not_contains">, z.ZodLiteral<"$starts_with">, z.ZodLiteral<"$ends_with">, z.ZodLiteral<"$regex">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>]>;
+type IOperator = z.infer<typeof operators>;
+type IFieldType = 'number';
+declare const operatorsMap: Record<IFieldType, IOperator[]>;
+declare const convertFilterSpec: (filter: IRootFilter) => Option<BaseFilterSpecification>;
+declare const isEmptyFilter: (filter: IRootFilter) => any;
+//#endregion
+//#region src/filter/fields/date/date.filter.d.ts
+declare const dateFilterOperators: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$between">, z.ZodLiteral<"$is_today">, z.ZodLiteral<"$is_tomorrow">, z.ZodLiteral<"$is_yesterday">, z.ZodLiteral<"$is_not_today">]>;
+declare const dateFilterValue: z.ZodUnion<[z.ZodNullable<z.ZodString>, z.ZodTuple<[z.ZodString, z.ZodString], null>]>;
+declare const dateFilter: z.ZodObject<{
+  type: z.ZodLiteral<"date">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$between">, z.ZodLiteral<"$is_today">, z.ZodLiteral<"$is_tomorrow">, z.ZodLiteral<"$is_yesterday">, z.ZodLiteral<"$is_not_today">]>;
+  value: z.ZodUnion<[z.ZodNullable<z.ZodString>, z.ZodTuple<[z.ZodString, z.ZodString], null>]>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type IDateFilter = z.infer<typeof dateFilter>;
+type IDateFilterValue = z.infer<typeof dateFilterValue>;
+type IDateFilterOperator = z.infer<typeof dateFilterOperators>;
+//#endregion
+//#region src/filter/fields/number/number.filter.d.ts
+declare const numberFilterOperators: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+type INumberFilterOperators = z.infer<typeof numberFilterOperators>;
+declare const numberFilterValue: z.ZodNullable<z.ZodNumber>;
+declare const numberFilter: z.ZodObject<{
+  type: z.ZodLiteral<"number">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$gt">, z.ZodLiteral<"$gte">, z.ZodLiteral<"$lt">, z.ZodLiteral<"$lte">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+  value: z.ZodNullable<z.ZodNumber>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type INumberFilter = z.infer<typeof numberFilter>;
+type INumberFilterValue = z.infer<typeof numberFilterValue>;
+//#endregion
+//#region src/filter/fields/string/string.filter.d.ts
+declare const stringFilterOperators: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$contains">, z.ZodLiteral<"$not_contains">, z.ZodLiteral<"$starts_with">, z.ZodLiteral<"$ends_with">, z.ZodLiteral<"$regex">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+declare const stringFilterValue: z.ZodNullable<z.ZodString>;
+declare const stringFilter: z.ZodObject<{
+  type: z.ZodLiteral<"string">;
+  operator: z.ZodUnion<readonly [z.ZodLiteral<"$eq">, z.ZodLiteral<"$neq">, z.ZodLiteral<"$contains">, z.ZodLiteral<"$not_contains">, z.ZodLiteral<"$starts_with">, z.ZodLiteral<"$ends_with">, z.ZodLiteral<"$regex">, z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">]>;
+  value: z.ZodNullable<z.ZodString>;
+  field: z.ZodString;
+  relation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type IStringFilter = z.infer<typeof stringFilter>;
+type IStringFilterOperator = z.infer<typeof stringFilterOperators>;
+//#endregion
+//#region src/filter/operators.d.ts
+declare const $eq: z.ZodLiteral<"$eq">;
+declare const $neq: z.ZodLiteral<"$neq">;
+declare const $contains: z.ZodLiteral<"$contains">;
+declare const $not_contains: z.ZodLiteral<"$not_contains">;
+declare const $starts_with: z.ZodLiteral<"$starts_with">;
+declare const $ends_with: z.ZodLiteral<"$ends_with">;
+declare const $regex: z.ZodLiteral<"$regex">;
+declare const $is_true: z.ZodLiteral<"$is_true">;
+declare const $is_false: z.ZodLiteral<"$is_false">;
+declare const $in: z.ZodLiteral<"$in">;
+declare const $nin: z.ZodLiteral<"$nin">;
+declare const $gt: z.ZodLiteral<"$gt">;
+declare const $lt: z.ZodLiteral<"$lt">;
+declare const $gte: z.ZodLiteral<"$gte">;
+declare const $lte: z.ZodLiteral<"$lte">;
+declare const $start_eq: z.ZodLiteral<"$start_eq">;
+declare const $start_neq: z.ZodLiteral<"$start_neq">;
+declare const $start_gt: z.ZodLiteral<"$start_gt">;
+declare const $start_lt: z.ZodLiteral<"$start_lt">;
+declare const $start_gte: z.ZodLiteral<"$start_gte">;
+declare const $start_lte: z.ZodLiteral<"$start_lte">;
+declare const $end_eq: z.ZodLiteral<"$end_eq">;
+declare const $end_neq: z.ZodLiteral<"$end_neq">;
+declare const $end_gt: z.ZodLiteral<"$end_gt">;
+declare const $end_lt: z.ZodLiteral<"$end_lt">;
+declare const $end_gte: z.ZodLiteral<"$end_gte">;
+declare const $end_lte: z.ZodLiteral<"$end_lte">;
+declare const $is_empty: z.ZodLiteral<"$is_empty">;
+declare const $is_not_empty: z.ZodLiteral<"$is_not_empty">;
+declare const $is_today: z.ZodLiteral<"$is_today">;
+declare const $is_not_today: z.ZodLiteral<"$is_not_today">;
+declare const $is_tomorrow: z.ZodLiteral<"$is_tomorrow">;
+declare const $is_yesterday: z.ZodLiteral<"$is_yesterday">;
+declare const $between: z.ZodLiteral<"$between">;
+declare const $has_file_type: z.ZodLiteral<"$has_file_type">;
+declare const $has_file_extension: z.ZodLiteral<"$has_file_extension">;
+declare const $is_root: z.ZodLiteral<"$is_root">;
+declare const $is_me: z.ZodLiteral<"$is_me">;
+declare const $is_not_me: z.ZodLiteral<"$is_not_me">;
+declare const operatorsWihtoutValue: z.ZodUnion<readonly [z.ZodLiteral<"$is_empty">, z.ZodLiteral<"$is_not_empty">, z.ZodLiteral<"$is_today">, z.ZodLiteral<"$is_not_today">, z.ZodLiteral<"$is_tomorrow">, z.ZodLiteral<"$is_yesterday">, z.ZodLiteral<"$is_root">, z.ZodLiteral<"$is_me">, z.ZodLiteral<"$is_not_me">]>;
+declare const isOperatorWithoutValue: (value: string) => boolean;
+//#endregion
+//#region src/filter/root-filter.d.ts
+declare class RootFilter<T extends IFilter = IFilter> extends ValueObject<IRootFilter<T>> {
+  get value(): IGroup<T> | IFilterOrGroupList<T> | (T extends Date | Primitives ? DomainPrimitive<T> : T);
+  get group(): IGroup<T> | {
+    conjunction: string;
+    children: IFilterOrGroupList<T>;
+  } | {
+    conjunction: string;
+    children: (T extends Date | Primitives ? DomainPrimitive<T> : T)[];
+  };
+  getSpec(): Option<BaseFilterSpecification>;
+  toJSON(): IGroup<T> | IFilterOrGroupList<T> | (T extends Date | Primitives ? DomainPrimitive<T> : T);
+}
+//#endregion
+//#region src/outbox.d.ts
+interface IOutboxService<DO extends AggregateRoot<any>> {
+  save(d: DO): Promise<void>;
+  saveMany(d: DO[]): Promise<void>;
+  sendToKafka(d: DO): Promise<void>;
+  sendToKafkaMany(d: DO[]): Promise<void>;
+}
+//#endregion
+//#region src/pagination.d.ts
+declare const paginationSchema: z.ZodObject<{
+  limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+type IPagination = z.infer<typeof paginationSchema>;
+declare const paginatedResponseSchema: z.ZodObject<{
+  limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  total: z.ZodNumber;
+}, z.core.$strip>;
+//#endregion
+//#region src/query.d.ts
+declare abstract class Query {}
+//#endregion
+//#region src/query-bus.d.ts
+interface IQueryBus<TQuery extends Query = Query> {
+  execute<TResult>(command: TQuery): Promise<TResult>;
+}
+//#endregion
+//#region src/query-handler.d.ts
+interface IQueryHandler<TQuery extends Query, TResult> {
+  execute(query: TQuery): Promise<TResult>;
+}
+//#endregion
+//#region src/sort.d.ts
+declare const sortingSchema: z.ZodRecord<z.ZodString, z.ZodEnum<{
+  ASC: "ASC";
+  DESC: "DESC";
+}>>;
+type ISorting = z.infer<typeof sortingSchema>;
+//#endregion
+//#region src/repository.d.ts
+interface IRepositoryOption {
+  pagination?: IPagination;
+  sorting?: ISorting;
+}
+interface PaginatedRepositoryMethodResult<T extends unknown> {
+  data: T[];
+  total: number;
+  limit: number;
+  offset: number;
+}
+//#endregion
+//#region src/uow.d.ts
+interface IUnitOfWork<T = any> {
+  begin(): Promise<void>;
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+  conn(): T;
+}
+//#endregion
+//#region src/utils.d.ts
+declare function convertPropsToObject(props: any): any;
+//#endregion
+//#region src/value-objects/boolean.vo.d.ts
+declare class BoolVO extends ValueObject<boolean> {
+  constructor(value: boolean);
+  get value(): boolean;
+  static True(): BoolVO;
+  static False(): BoolVO;
+}
+//#endregion
+//#region src/value-objects/date.vo.d.ts
+declare class DateVO extends ValueObject<Date> {
+  constructor(value: Date | string | number);
+  get value(): Date;
+  static now(): DateVO;
+}
+//#endregion
+//#region src/value-objects/id.vo.d.ts
+declare abstract class ID extends ValueObject<number> {
+  constructor(value: number);
+  get value(): number;
+}
+//#endregion
+//#region src/value-objects/nanoid.vo.d.ts
+declare abstract class NanoID extends ID {
+  private static ALPHABETS;
+  static createId(prefix?: string, size?: number): string;
+  get value(): number;
+}
+//#endregion
+//#region src/value-objects/string.vo.d.ts
+declare class StringVO extends ValueObject<string> {
+  constructor(value: string);
+  get value(): string;
+  static empty(): StringVO;
+}
+//#endregion
+export { $between, $contains, $end_eq, $end_gt, $end_gte, $end_lt, $end_lte, $end_neq, $ends_with, $eq, $gt, $gte, $has_file_extension, $has_file_type, $in, $is_empty, $is_false, $is_me, $is_not_empty, $is_not_me, $is_not_today, $is_root, $is_today, $is_tomorrow, $is_true, $is_yesterday, $lt, $lte, $neq, $nin, $not_contains, $regex, $start_eq, $start_gt, $start_gte, $start_lt, $start_lte, $start_neq, $starts_with, AggregateRoot, BaseEvent, BaseFilterSpecification, BoolVO, Command, CommandProps, CompositeSpecification, DateBetween, DateEqual, DateFieldValue, DateGreaterThan, DateGreaterThanOrEqual, DateIsToday, DateIsTomorrow, DateIsYesterday, DateLessThan, DateLessThanOrEqual, DateVO, DomainPrimitive, ExceptionBase, FieldValueBase, ICommandBus, ICommandHandler, IConjunction, ID, IDateFieldValue, IDateFilter, IDateFilterOperator, IDateFilterValue, IEvent, IEventHandler, IEventJSON, IFieldValueVisitor, IFilter, IFilterBaseVisitor, IFilterOrGroup, IFilterOrGroupList, IFilters, IGroup, INumberFieldValue, INumberFilter, INumberFilterOperators, INumberFilterValue, IOperator, IOutboxService, IPagination, IQueryBus, IQueryHandler, IRepositoryOption, IRootFilter, ISorting, ISpecVisitor, ISpecification, IStringFieldValue, IStringFilter, IStringFilterOperator, IUnitOfWork, NanoID, NumberEmpty, NumberEqual, NumberFieldValue, NumberGreaterThan, NumberGreaterThanOrEqual, NumberLessThan, NumberLessThanOrEqual, PaginatedRepositoryMethodResult, Primitives, Query, RootFilter, SerializedException, StringContain, StringEmpty, StringEndsWith, StringEqual, StringFieldValue, StringNotEqual, StringRegex, StringStartsWith, StringVO, UnpackedFieldValue, ValueObject, and, andOptions, baseFilter, conjunctions, convertFilterSpec, convertPropsToObject, dateFieldValue, dateFilter, dateFilterOperators, dateFilterValue, eventSchema, filterOrGroupList, filterRoorFilter, isEmptyFilter, isFilter, isGroup, isOperatorWithoutValue, numberFieldValue, numberFilter, numberFilterOperators, numberFilterValue, operators, operatorsMap, operatorsWihtoutValue, or, paginatedResponseSchema, paginationSchema, rootFilter, sortingSchema, stringFieldValue, stringFilter, stringFilterOperators, stringFilterValue };
+//# sourceMappingURL=index.d.ts.map