//#region src/eventa.d.ts
declare function nanoid(): string;
interface InvokeEventConstraint<_Req, _Res> {}
type EventTag<Res, Req> = string & InvokeEventConstraint<Req, Res>;
declare enum EventaType {
  Event = "event",
  MatchExpression = "matchExpression"
}
declare enum EventaFlowDirection {
  Inbound = "inbound",
  Outbound = "outbound"
}
interface DirectionalEventa<P, T = undefined> extends Eventa<P> {
  _flowDirection: EventaFlowDirection | T;
}
interface InboundEventa<T> extends DirectionalEventa<T> {
  _flowDirection: EventaFlowDirection.Inbound;
}
interface OutboundEventa<T> extends DirectionalEventa<T> {
  _flowDirection: EventaFlowDirection.Outbound;
}
declare function defineInboundEventa<T>(id?: string): InboundEventa<T>;
declare function defineOutboundEventa<T>(id?: string): OutboundEventa<T>;
interface EventaLike<_P = undefined, T extends EventaType = EventaType> {
  id: string;
  type?: T;
}
interface Eventa<P = unknown, M = unknown, IM = unknown> extends EventaLike<P, EventaType.Event> {
  body?: P;
  /**
   * Optional runtime metadata that can be attached to the eventa.
   *
   * NOTICE: for defineInvoke, and defineInvokeHandler, the metadata will be omitted
   * for smaller chunk size, this means for metadata, the data contains will not be available in the defineInvokeHandler.
   *
   * This can be used for various purposes such as logging, debugging, or providing additional context about the eventa.
   * Allowing the event handler to be able to access this metadata can enable more flexible and powerful event handling logic.
   */
  metadata?: M;
  /**
   * Optional runtime metadata that can be attached to the eventa when invoking it.
   *
   * Unlike the `metadata` field, the `invokeMetadata` is specifically designed to be used when invoking the eventa, and it
   * will be available in the defineInvokeHandler.
   *
   * This allows for a clear separation between the metadata that describes the eventa itself and the metadata that is relevant
   * to the invocation of the eventa, providing more flexibility in how metadata is used and accessed within the event
   * handling system.
   */
  invokeMetadata?: IM;
}
type InferEventaPayload<E> = E extends Eventa<infer P> ? P : never;
declare function defineEventa<P = undefined, M = undefined, IM = undefined>(id?: string, options?: {
  /**
   * Optionally inherit many properties from another parent eventa.
   */
  inheritFrom?: Eventa<P, M, IM>;
  /**
   * Optional runtime metadata that can be attached to the eventa.
   *
   * NOTICE: for defineInvoke, and defineInvokeHandler, the metadata will be omitted
   * for smaller chunk size, this means for metadata, the data contains will not be available in the defineInvokeHandler.
   *
   * This can be used for various purposes such as logging, debugging, or providing additional context about the eventa.
   * Allowing the event handler to be able to access this metadata can enable more flexible and powerful event handling logic.
   */
  metadata?: M;
  /**
   * Optional runtime metadata that can be attached to the eventa when invoking it.
   *
   * Unlike the `metadata` field, the `invokeMetadata` is specifically designed to be used when invoking the eventa, and it
   * will be available in the defineInvokeHandler.
   *
   * This allows for a clear separation between the metadata that describes the eventa itself and the metadata that is relevant
   * to the invocation of the eventa, providing more flexibility in how metadata is used and accessed within the event
   * handling system.
   */
  invokeMetadata?: IM;
}): Eventa<P, M, IM>;
interface EventaMatchExpression<P = undefined> extends EventaLike<P, EventaType.MatchExpression> {
  matcher?: (event: Eventa<P>) => boolean | Promise<boolean>;
}
declare function and<P>(...matchExpression: Array<EventaMatchExpression<P>>): EventaMatchExpression<P>;
declare function or<P>(...matchExpression: Array<EventaMatchExpression<P>>): EventaMatchExpression<P>;
/**
 * Match by is powerful utility function that allows you to create a match expression based on various criteria
 * when working with eventa (event system).
 *
 * Semantics like glob matching, RegExp, or even custom matcher function can be used to create complex match
 * expressions that can be used to filter and handle events in a flexible way.
 */
declare function matchBy<P = undefined>(glob: string, inverted?: boolean): EventaMatchExpression<P>;
declare function matchBy<P = undefined>(options: {
  ids: string[];
}, inverted?: boolean): EventaMatchExpression<P>;
declare function matchBy<P = undefined>(options: {
  eventa: Eventa<P>[];
}, inverted?: boolean): EventaMatchExpression<P>;
declare function matchBy<P = undefined>(options: {
  types: EventaType[];
}, inverted?: boolean): EventaMatchExpression<P>;
declare function matchBy<P = undefined>(regExp: RegExp, inverted?: boolean): EventaMatchExpression<P>;
declare function matchBy<P = undefined, E extends Eventa<P> = Eventa<P>>(matcher: (event: E) => boolean | Promise<boolean>): EventaMatchExpression<P>;
//#endregion
export { nanoid as _, EventaLike as a, InboundEventa as c, OutboundEventa as d, and as f, matchBy as g, defineOutboundEventa as h, EventaFlowDirection as i, InferEventaPayload as l, defineInboundEventa as m, EventTag as n, EventaMatchExpression as o, defineEventa as p, Eventa as r, EventaType as s, DirectionalEventa as t, InvokeEventConstraint as u, or as v };
//# sourceMappingURL=eventa-CCPqecvv.d.mts.map