@signaltree/events 7.4.1 → 7.5.0

package/dist/nestjs/event-bus.module.cjs

@@ -10,6 +10,55 @@ var idempotency = require('../core/idempotency.cjs');
 var errorClassification = require('../core/error-classification.cjs');
 
 var EventBusModule_1;
+/**
+ * Preset definitions
+ */
+const QUEUE_PRESETS = {
+  /**
+   * Full priority-based queues (default) - separate queues per priority
+   */
+  'priority-based': [{
+    name: 'events-critical',
+    priorities: ['critical'],
+    concurrency: 10
+  }, {
+    name: 'events-high',
+    priorities: ['high'],
+    concurrency: 8
+  }, {
+    name: 'events-normal',
+    priorities: ['normal'],
+    concurrency: 5
+  }, {
+    name: 'events-low',
+    priorities: ['low'],
+    concurrency: 3
+  }, {
+    name: 'events-bulk',
+    priorities: ['bulk'],
+    concurrency: 2,
+    rateLimit: {
+      max: 100,
+      duration: 1000
+    }
+  }],
+  /**
+   * Single queue for all priorities - simpler setup, uses BullMQ priority numbers
+   */
+  'single-queue': [{
+    name: 'events',
+    priorities: ['critical', 'high', 'normal', 'low', 'bulk'],
+    concurrency: 10
+  }],
+  /**
+   * Minimal setup - one queue, low concurrency, good for development
+   */
+  'minimal': [{
+    name: 'events',
+    priorities: ['critical', 'high', 'normal', 'low', 'bulk'],
+    concurrency: 3
+  }]
+};
 /**
  * Default queue configuration based on priorities
  */
@@ -124,8 +173,23 @@ exports.EventBusModule = EventBusModule_1 = class EventBusModule {
       exports: [eventBus_service.EventBusService, dlq_service.DlqService, tokens.EVENT_BUS_CONFIG, tokens.EVENT_REGISTRY, tokens.IDEMPOTENCY_STORE, tokens.ERROR_CLASSIFIER]
     };
   }
+  /**
+   * Resolve queue configuration from preset or explicit config
+   */
+  static resolveQueues(config) {
+    // Explicit queues take precedence
+    if (config.queues && config.queues.length > 0) {
+      return config.queues;
+    }
+    // Use preset if specified
+    if (config.preset) {
+      return QUEUE_PRESETS[config.preset];
+    }
+    // Default to priority-based
+    return DEFAULT_QUEUES;
+  }
   static createProviders(config) {
-    const queues = config.queues ?? DEFAULT_QUEUES;
+    const queues = EventBusModule_1.resolveQueues(config);
     const fullConfig = {
       ...config,
       queues,
@@ -150,3 +214,5 @@ exports.EventBusModule = EventBusModule_1 = class EventBusModule {
   }
 };
 exports.EventBusModule = EventBusModule_1 = tslib.__decorate([common.Module({})], exports.EventBusModule);
+
+exports.QUEUE_PRESETS = QUEUE_PRESETS;

package/dist/nestjs/event-bus.module.js

@@ -8,6 +8,55 @@ import { createInMemoryIdempotencyStore } from '../core/idempotency.js';
 import { createErrorClassifier } from '../core/error-classification.js';
 
 var EventBusModule_1;
+/**
+ * Preset definitions
+ */
+const QUEUE_PRESETS = {
+  /**
+   * Full priority-based queues (default) - separate queues per priority
+   */
+  'priority-based': [{
+    name: 'events-critical',
+    priorities: ['critical'],
+    concurrency: 10
+  }, {
+    name: 'events-high',
+    priorities: ['high'],
+    concurrency: 8
+  }, {
+    name: 'events-normal',
+    priorities: ['normal'],
+    concurrency: 5
+  }, {
+    name: 'events-low',
+    priorities: ['low'],
+    concurrency: 3
+  }, {
+    name: 'events-bulk',
+    priorities: ['bulk'],
+    concurrency: 2,
+    rateLimit: {
+      max: 100,
+      duration: 1000
+    }
+  }],
+  /**
+   * Single queue for all priorities - simpler setup, uses BullMQ priority numbers
+   */
+  'single-queue': [{
+    name: 'events',
+    priorities: ['critical', 'high', 'normal', 'low', 'bulk'],
+    concurrency: 10
+  }],
+  /**
+   * Minimal setup - one queue, low concurrency, good for development
+   */
+  'minimal': [{
+    name: 'events',
+    priorities: ['critical', 'high', 'normal', 'low', 'bulk'],
+    concurrency: 3
+  }]
+};
 /**
  * Default queue configuration based on priorities
  */
@@ -122,8 +171,23 @@ let EventBusModule = EventBusModule_1 = class EventBusModule {
       exports: [EventBusService, DlqService, EVENT_BUS_CONFIG, EVENT_REGISTRY, IDEMPOTENCY_STORE, ERROR_CLASSIFIER]
     };
   }
+  /**
+   * Resolve queue configuration from preset or explicit config
+   */
+  static resolveQueues(config) {
+    // Explicit queues take precedence
+    if (config.queues && config.queues.length > 0) {
+      return config.queues;
+    }
+    // Use preset if specified
+    if (config.preset) {
+      return QUEUE_PRESETS[config.preset];
+    }
+    // Default to priority-based
+    return DEFAULT_QUEUES;
+  }
   static createProviders(config) {
-    const queues = config.queues ?? DEFAULT_QUEUES;
+    const queues = EventBusModule_1.resolveQueues(config);
     const fullConfig = {
       ...config,
       queues,
@@ -149,4 +213,4 @@ let EventBusModule = EventBusModule_1 = class EventBusModule {
 };
 EventBusModule = EventBusModule_1 = __decorate([Module({})], EventBusModule);
 
-export { EventBusModule };
+export { EventBusModule, QUEUE_PRESETS };

package/dist/nestjs/event-bus.service.cjs

@@ -5,6 +5,7 @@ var common = require('@nestjs/common');
 var bullmq = require('bullmq');
 var factory = require('../core/factory.cjs');
 var registry = require('../core/registry.cjs');
+var types = require('../core/types.cjs');
 var tokens = require('./tokens.cjs');
 
 var EventBusService_1;
@@ -139,6 +140,80 @@ exports.EventBusService = EventBusService_1 = class EventBusService {
       correlationId
     };
   }
+  /**
+   * Create an event with defaults from module configuration
+   *
+   * This is a convenience method that auto-fills id, timestamp, version,
+   * correlationId, and metadata.source from the module config.
+   *
+   * @example
+   * ```typescript
+   * // Instead of constructing the full event manually:
+   * const event = this.eventBus.createEvent('TradeProposalCreated', {
+   *   tradeId: '123',
+   *   initiatorId: 'user-1',
+   *   recipientId: 'user-2',
+   * }, {
+   *   actor: { id: userId, type: 'user' },
+   *   priority: 'high',
+   * });
+   *
+   * await this.eventBus.publish(event);
+   * ```
+   */
+  createEvent(type, data, options = {}) {
+    const id = options.id ?? factory.generateEventId();
+    const correlationId = options.correlationId ?? factory.generateCorrelationId();
+    const timestamp = options.timestamp ?? new Date().toISOString();
+    const actor = options.actor ?? {
+      id: 'system',
+      type: 'system'
+    };
+    const metadata = {
+      source: this.config.source ?? 'signaltree',
+      environment: this.config.environment ?? process.env['NODE_ENV'] ?? 'development',
+      ...options.metadata
+    };
+    return {
+      id,
+      type,
+      version: options.version ?? types.DEFAULT_EVENT_VERSION,
+      timestamp,
+      correlationId,
+      causationId: options.causationId,
+      actor,
+      metadata,
+      data,
+      priority: options.priority,
+      aggregate: options.aggregate
+    };
+  }
+  /**
+   * Convenience method to create and publish an event in one call
+   *
+   * Combines createEvent() and publish() for the common case.
+   *
+   * @example
+   * ```typescript
+   * await this.eventBus.publishEvent('TradeProposalCreated', {
+   *   tradeId: '123',
+   *   initiatorId: 'user-1',
+   * }, {
+   *   actor: { id: userId, type: 'user' },
+   *   priority: 'high',
+   * });
+   * ```
+   */
+  async publishEvent(type, data, options = {}) {
+    const event = this.createEvent(type, data, options);
+    return this.publish(event, {
+      delay: options.delay,
+      queue: options.queue,
+      jobId: options.jobId,
+      jobOptions: options.jobOptions,
+      priority: options.priority
+    });
+  }
   /**
    * Publish multiple events in a batch
    */

package/dist/nestjs/event-bus.service.js

@@ -3,6 +3,7 @@ import { Injectable, Inject, Logger } from '@nestjs/common';
 import { Queue, QueueEvents } from 'bullmq';
 import { generateEventId, generateCorrelationId } from '../core/factory.js';
 import { EventRegistry } from '../core/registry.js';
+import { DEFAULT_EVENT_VERSION } from '../core/types.js';
 import { EVENT_BUS_CONFIG, EVENT_REGISTRY } from './tokens.js';
 
 var EventBusService_1;
@@ -137,6 +138,80 @@ let EventBusService = EventBusService_1 = class EventBusService {
       correlationId
     };
   }
+  /**
+   * Create an event with defaults from module configuration
+   *
+   * This is a convenience method that auto-fills id, timestamp, version,
+   * correlationId, and metadata.source from the module config.
+   *
+   * @example
+   * ```typescript
+   * // Instead of constructing the full event manually:
+   * const event = this.eventBus.createEvent('TradeProposalCreated', {
+   *   tradeId: '123',
+   *   initiatorId: 'user-1',
+   *   recipientId: 'user-2',
+   * }, {
+   *   actor: { id: userId, type: 'user' },
+   *   priority: 'high',
+   * });
+   *
+   * await this.eventBus.publish(event);
+   * ```
+   */
+  createEvent(type, data, options = {}) {
+    const id = options.id ?? generateEventId();
+    const correlationId = options.correlationId ?? generateCorrelationId();
+    const timestamp = options.timestamp ?? new Date().toISOString();
+    const actor = options.actor ?? {
+      id: 'system',
+      type: 'system'
+    };
+    const metadata = {
+      source: this.config.source ?? 'signaltree',
+      environment: this.config.environment ?? process.env['NODE_ENV'] ?? 'development',
+      ...options.metadata
+    };
+    return {
+      id,
+      type,
+      version: options.version ?? DEFAULT_EVENT_VERSION,
+      timestamp,
+      correlationId,
+      causationId: options.causationId,
+      actor,
+      metadata,
+      data,
+      priority: options.priority,
+      aggregate: options.aggregate
+    };
+  }
+  /**
+   * Convenience method to create and publish an event in one call
+   *
+   * Combines createEvent() and publish() for the common case.
+   *
+   * @example
+   * ```typescript
+   * await this.eventBus.publishEvent('TradeProposalCreated', {
+   *   tradeId: '123',
+   *   initiatorId: 'user-1',
+   * }, {
+   *   actor: { id: userId, type: 'user' },
+   *   priority: 'high',
+   * });
+   * ```
+   */
+  async publishEvent(type, data, options = {}) {
+    const event = this.createEvent(type, data, options);
+    return this.publish(event, {
+      delay: options.delay,
+      queue: options.queue,
+      jobId: options.jobId,
+      jobOptions: options.jobOptions,
+      priority: options.priority
+    });
+  }
   /**
    * Publish multiple events in a batch
    */

package/dist/nestjs/index.cjs

@@ -13,6 +13,7 @@ Object.defineProperty(exports, "EventBusModule", {
 	enumerable: true,
 	get: function () { return eventBus_module.EventBusModule; }
 });
+exports.QUEUE_PRESETS = eventBus_module.QUEUE_PRESETS;
 Object.defineProperty(exports, "EventBusService", {
 	enumerable: true,
 	get: function () { return eventBus_service.EventBusService; }

package/dist/nestjs/index.js

@@ -1,4 +1,4 @@
-export { EventBusModule } from './event-bus.module.js';
+export { EventBusModule, QUEUE_PRESETS } from './event-bus.module.js';
 export { EventBusService } from './event-bus.service.js';
 export { BaseSubscriber } from './base.subscriber.js';
 export { DlqService } from './dlq.service.js';

package/dist/testing/mock-event-bus.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var factory = require('../core/factory.cjs');
+var types = require('../core/types.cjs');
 
 /**
  * Mock Event Bus for testing
@@ -37,9 +38,72 @@ class MockEventBus {
       asyncDelayMs: 10,
       autoGenerateIds: true,
       throwOnError: false,
+      source: 'mock-event-bus',
+      environment: 'test',
       ...options
     };
   }
+  /**
+   * Create an event with defaults (matches EventBusService.createEvent API)
+   *
+   * @example
+   * ```typescript
+   * const event = mockBus.createEvent('TradeAccepted', {
+   *   tradeId: '123',
+   *   acceptedById: 'user-1',
+   * }, {
+   *   actor: { id: 'user-1', type: 'user' },
+   * });
+   * ```
+   */
+  createEvent(type, data, options = {}) {
+    const id = options.id ?? (this.options.autoGenerateIds ? factory.generateEventId() : 'test-event-id');
+    const correlationId = options.correlationId ?? factory.generateCorrelationId();
+    const timestamp = options.timestamp ?? new Date().toISOString();
+    const actor = options.actor ?? {
+      id: 'test-user',
+      type: 'user'
+    };
+    const metadata = {
+      source: this.options.source ?? 'mock-event-bus',
+      environment: this.options.environment ?? 'test',
+      ...options.metadata
+    };
+    return {
+      id,
+      type,
+      version: options.version ?? types.DEFAULT_EVENT_VERSION,
+      timestamp,
+      correlationId,
+      causationId: options.causationId,
+      actor,
+      metadata,
+      data,
+      priority: options.priority,
+      aggregate: options.aggregate
+    };
+  }
+  /**
+   * Convenience method to create and publish an event in one call
+   * (matches EventBusService.publishEvent API)
+   *
+   * @example
+   * ```typescript
+   * await mockBus.publishEvent('TradeAccepted', {
+   *   tradeId: '123',
+   *   acceptedById: 'user-1',
+   * }, {
+   *   actor: { id: 'user-1', type: 'user' },
+   * });
+   * ```
+   */
+  async publishEvent(type, data, options = {}) {
+    const event = this.createEvent(type, data, options);
+    return this.publish(event, {
+      queue: options.queue,
+      delay: options.delay
+    });
+  }
   /**
    * Publish an event
    */

package/dist/testing/mock-event-bus.js

@@ -1,4 +1,5 @@
-import { generateCorrelationId, generateEventId } from '../core/factory.js';
+import { generateEventId, generateCorrelationId } from '../core/factory.js';
+import { DEFAULT_EVENT_VERSION } from '../core/types.js';
 
 /**
  * Mock Event Bus for testing
@@ -35,9 +36,72 @@ class MockEventBus {
       asyncDelayMs: 10,
       autoGenerateIds: true,
       throwOnError: false,
+      source: 'mock-event-bus',
+      environment: 'test',
       ...options
     };
   }
+  /**
+   * Create an event with defaults (matches EventBusService.createEvent API)
+   *
+   * @example
+   * ```typescript
+   * const event = mockBus.createEvent('TradeAccepted', {
+   *   tradeId: '123',
+   *   acceptedById: 'user-1',
+   * }, {
+   *   actor: { id: 'user-1', type: 'user' },
+   * });
+   * ```
+   */
+  createEvent(type, data, options = {}) {
+    const id = options.id ?? (this.options.autoGenerateIds ? generateEventId() : 'test-event-id');
+    const correlationId = options.correlationId ?? generateCorrelationId();
+    const timestamp = options.timestamp ?? new Date().toISOString();
+    const actor = options.actor ?? {
+      id: 'test-user',
+      type: 'user'
+    };
+    const metadata = {
+      source: this.options.source ?? 'mock-event-bus',
+      environment: this.options.environment ?? 'test',
+      ...options.metadata
+    };
+    return {
+      id,
+      type,
+      version: options.version ?? DEFAULT_EVENT_VERSION,
+      timestamp,
+      correlationId,
+      causationId: options.causationId,
+      actor,
+      metadata,
+      data,
+      priority: options.priority,
+      aggregate: options.aggregate
+    };
+  }
+  /**
+   * Convenience method to create and publish an event in one call
+   * (matches EventBusService.publishEvent API)
+   *
+   * @example
+   * ```typescript
+   * await mockBus.publishEvent('TradeAccepted', {
+   *   tradeId: '123',
+   *   acceptedById: 'user-1',
+   * }, {
+   *   actor: { id: 'user-1', type: 'user' },
+   * });
+   * ```
+   */
+  async publishEvent(type, data, options = {}) {
+    const event = this.createEvent(type, data, options);
+    return this.publish(event, {
+      queue: options.queue,
+      delay: options.delay
+    });
+  }
   /**
    * Publish an event
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/events",
-  "version": "7.4.1",
+  "version": "7.5.0",
   "description": "Event-driven architecture infrastructure for SignalTree - event bus, subscribers, validation, and real-time sync",
   "license": "MIT",
   "type": "module",

package/src/nestjs/event-bus.module.d.ts

@@ -36,14 +36,45 @@ export interface QueueConfig {
         duration: number;
     };
 }
+/**
+ * Preset queue configurations for common use cases
+ */
+export type QueuePreset = 'priority-based' | 'single-queue' | 'minimal';
+/**
+ * Preset definitions
+ */
+export declare const QUEUE_PRESETS: Record<QueuePreset, QueueConfig[]>;
 /**
  * EventBus module configuration
  */
 export interface EventBusModuleConfig {
     /** Redis connection config */
     redis: RedisConfig;
-    /** Queue configuration (defaults to priority-based queues) */
+    /**
+     * Queue preset for quick configuration.
+     * Use this OR `queues`, not both.
+     *
+     * - 'priority-based': Separate queues per priority (recommended for production)
+     * - 'single-queue': One queue with priority numbers (simpler setup)
+     * - 'minimal': Development-friendly, low concurrency
+     *
+     * @default 'priority-based'
+     */
+    preset?: QueuePreset;
+    /** Queue configuration (defaults to priority-based queues if no preset specified) */
     queues?: QueueConfig[];
+    /**
+     * Service/module name for event metadata.source
+     * Used by createEvent() and publishEvent() convenience methods.
+     * @default 'signaltree'
+     */
+    source?: string;
+    /**
+     * Environment name for event metadata.environment
+     * Used by createEvent() and publishEvent() convenience methods.
+     * @default process.env.NODE_ENV || 'development'
+     */
+    environment?: string;
     /** Event registry configuration */
     registry?: EventRegistryConfig;
     /** Custom idempotency store (defaults to in-memory) */
@@ -113,5 +144,9 @@ export declare class EventBusModule {
      * ```
      */
     static forRootAsync(asyncConfig: EventBusModuleAsyncConfig): DynamicModule;
+    /**
+     * Resolve queue configuration from preset or explicit config
+     */
+    private static resolveQueues;
     private static createProviders;
 }

package/src/nestjs/event-bus.service.d.ts

@@ -1,7 +1,7 @@
 import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
 import { Queue } from 'bullmq';
 import { EventRegistry } from '../core/registry';
-import { BaseEvent, EventPriority } from '../core/types';
+import { BaseEvent, EventActor, EventMetadata, EventPriority, EventVersion } from '../core/types';
 import { EventBusModuleConfig } from './event-bus.module';
 /**
  * EventBus Service - Publish events to BullMQ queues
@@ -46,6 +46,32 @@ export interface PublishResult {
     /** Correlation ID */
     correlationId: string;
 }
+/**
+ * Options for creating an event via EventBusService.createEvent()
+ */
+export interface CreateEventServiceOptions {
+    /** Override event ID */
+    id?: string;
+    /** Correlation ID for request tracing */
+    correlationId?: string;
+    /** Causation ID (parent event) */
+    causationId?: string;
+    /** Actor who triggered the event */
+    actor?: EventActor;
+    /** Additional metadata */
+    metadata?: Partial<EventMetadata>;
+    /** Event priority */
+    priority?: EventPriority;
+    /** Schema version override */
+    version?: EventVersion;
+    /** Aggregate info */
+    aggregate?: {
+        type: string;
+        id: string;
+    };
+    /** Timestamp override (for testing/replay) */
+    timestamp?: string;
+}
 export declare class EventBusService implements OnModuleInit, OnModuleDestroy {
     private readonly config;
     private readonly registry;
@@ -73,6 +99,45 @@ export declare class EventBusService implements OnModuleInit, OnModuleDestroy {
      * ```
      */
     publish<T extends BaseEvent>(event: Omit<T, 'id' | 'timestamp'> & Partial<Pick<T, 'id' | 'timestamp'>>, options?: PublishOptions): Promise<PublishResult>;
+    /**
+     * Create an event with defaults from module configuration
+     *
+     * This is a convenience method that auto-fills id, timestamp, version,
+     * correlationId, and metadata.source from the module config.
+     *
+     * @example
+     * ```typescript
+     * // Instead of constructing the full event manually:
+     * const event = this.eventBus.createEvent('TradeProposalCreated', {
+     *   tradeId: '123',
+     *   initiatorId: 'user-1',
+     *   recipientId: 'user-2',
+     * }, {
+     *   actor: { id: userId, type: 'user' },
+     *   priority: 'high',
+     * });
+     *
+     * await this.eventBus.publish(event);
+     * ```
+     */
+    createEvent<TType extends string, TData>(type: TType, data: TData, options?: CreateEventServiceOptions): BaseEvent<TType, TData>;
+    /**
+     * Convenience method to create and publish an event in one call
+     *
+     * Combines createEvent() and publish() for the common case.
+     *
+     * @example
+     * ```typescript
+     * await this.eventBus.publishEvent('TradeProposalCreated', {
+     *   tradeId: '123',
+     *   initiatorId: 'user-1',
+     * }, {
+     *   actor: { id: userId, type: 'user' },
+     *   priority: 'high',
+     * });
+     * ```
+     */
+    publishEvent<TType extends string, TData>(type: TType, data: TData, options?: CreateEventServiceOptions & Pick<PublishOptions, 'delay' | 'queue' | 'jobId' | 'jobOptions'>): Promise<PublishResult>;
     /**
      * Publish multiple events in a batch
      */

package/src/nestjs/index.d.ts

@@ -4,10 +4,10 @@
  * NestJS integration for event-driven architecture.
  * Provides EventBusModule, BaseSubscriber, and DLQ handling.
  */
-export { EventBusModule } from './event-bus.module';
-export type { EventBusModuleConfig, EventBusModuleAsyncConfig, } from './event-bus.module';
+export { EventBusModule, QUEUE_PRESETS } from './event-bus.module';
+export type { EventBusModuleConfig, EventBusModuleAsyncConfig, QueueConfig, QueuePreset, RedisConfig, } from './event-bus.module';
 export { EventBusService } from './event-bus.service';
-export type { PublishOptions, PublishResult } from './event-bus.service';
+export type { PublishOptions, PublishResult, CreateEventServiceOptions } from './event-bus.service';
 export { BaseSubscriber } from './base.subscriber';
 export type { SubscriberConfig, ProcessingResult, SubscriberMetrics, } from './base.subscriber';
 export { DlqService } from './dlq.service';

package/src/testing/index.d.ts

@@ -5,7 +5,7 @@
  * Provides mocks, factories, and helpers for unit testing.
  */
 export { MockEventBus, createMockEventBus } from './mock-event-bus';
-export type { MockEventBusOptions, PublishedEvent } from './mock-event-bus';
+export type { MockEventBusOptions, PublishedEvent, MockCreateEventOptions } from './mock-event-bus';
 export { createTestEvent, createTestEventFactory } from './factories';
 export type { TestEventFactory, TestEventOptions } from './factories';
 export { EventAssertions, createEventAssertions } from './assertions';

package/src/testing/mock-event-bus.d.ts

@@ -1,4 +1,4 @@
-import { BaseEvent } from '../core/types';
+import { BaseEvent, EventActor, EventMetadata, EventPriority, EventVersion } from '../core/types';
 /**
  * Mock Event Bus - In-memory event bus for testing
  *
@@ -32,6 +32,36 @@ export interface MockEventBusOptions {
     autoGenerateIds?: boolean;
     /** Throw on publish errors */
     throwOnError?: boolean;
+    /** Source for event metadata (used by createEvent) */
+    source?: string;
+    /** Environment for event metadata (used by createEvent) */
+    environment?: string;
+}
+/**
+ * Options for creating an event via MockEventBus.createEvent()
+ */
+export interface MockCreateEventOptions {
+    /** Override event ID */
+    id?: string;
+    /** Correlation ID for request tracing */
+    correlationId?: string;
+    /** Causation ID (parent event) */
+    causationId?: string;
+    /** Actor who triggered the event */
+    actor?: EventActor;
+    /** Additional metadata */
+    metadata?: Partial<EventMetadata>;
+    /** Event priority */
+    priority?: EventPriority;
+    /** Schema version override */
+    version?: EventVersion;
+    /** Aggregate info */
+    aggregate?: {
+        type: string;
+        id: string;
+    };
+    /** Timestamp override (for testing/replay) */
+    timestamp?: string;
 }
 /**
  * Mock Event Bus for testing
@@ -62,6 +92,41 @@ export declare class MockEventBus {
     private subscriptions;
     private allSubscriptions;
     constructor(options?: MockEventBusOptions);
+    /**
+     * Create an event with defaults (matches EventBusService.createEvent API)
+     *
+     * @example
+     * ```typescript
+     * const event = mockBus.createEvent('TradeAccepted', {
+     *   tradeId: '123',
+     *   acceptedById: 'user-1',
+     * }, {
+     *   actor: { id: 'user-1', type: 'user' },
+     * });
+     * ```
+     */
+    createEvent<TType extends string, TData>(type: TType, data: TData, options?: MockCreateEventOptions): BaseEvent<TType, TData>;
+    /**
+     * Convenience method to create and publish an event in one call
+     * (matches EventBusService.publishEvent API)
+     *
+     * @example
+     * ```typescript
+     * await mockBus.publishEvent('TradeAccepted', {
+     *   tradeId: '123',
+     *   acceptedById: 'user-1',
+     * }, {
+     *   actor: { id: 'user-1', type: 'user' },
+     * });
+     * ```
+     */
+    publishEvent<TType extends string, TData>(type: TType, data: TData, options?: MockCreateEventOptions & {
+        queue?: string;
+        delay?: number;
+    }): Promise<{
+        eventId: string;
+        queue: string;
+    }>;
     /**
      * Publish an event
      */