import { OutOfOrderInfo, RebalanceEvent } from "./messaging.cjs";
import { Link, SpanContext } from "@opentelemetry/api";

//#region src/messaging-testing.d.ts
/**
 * Recorded producer call
 */
interface RecordedProducerCall {
  /** Destination (topic/queue) */
  destination: string;
  /** System (kafka, sqs, etc.) */
  system: string;
  /** Message payload */
  payload: unknown;
  /** Headers injected */
  headers: Record<string, string>;
  /** Timestamp of call */
  timestamp: number;
  /** Trace ID from headers */
  traceId?: string;
  /** Span ID from headers */
  spanId?: string;
}
/**
 * Recorded consumer call
 */
interface RecordedConsumerCall {
  /** Destination (topic/queue) */
  destination: string;
  /** System (kafka, sqs, etc.) */
  system: string;
  /** Consumer group */
  consumerGroup?: string;
  /** Message payload */
  payload: unknown;
  /** Headers extracted */
  headers?: Record<string, string>;
  /** Timestamp of call */
  timestamp: number;
  /** Producer links extracted */
  producerLinks: Link[];
  /** Whether message was duplicate */
  isDuplicate: boolean;
  /** Out of order info if detected */
  outOfOrderInfo: OutOfOrderInfo | null;
  /** DLQ reason if routed to DLQ */
  dlqReason?: string;
  /** Retry attempt number */
  retryAttempt?: number;
}
/**
 * Recorded rebalance event
 */
interface RecordedRebalanceEvent extends RebalanceEvent {
  /** Destination (topic) */
  destination: string;
  /** Consumer group */
  consumerGroup: string;
}
/**
 * Mock message for testing
 */
interface MockMessage<T = unknown> {
  /** Message payload */
  payload: T;
  /** Headers */
  headers?: Record<string, string>;
  /** Offset/sequence number */
  offset?: number;
  /** Partition */
  partition?: number;
  /** Key */
  key?: string;
  /** Message ID */
  messageId?: string;
  /** Timestamp */
  timestamp?: number;
}
/**
 * Producer assertion options
 */
interface ProducerAssertionOptions {
  /** Expected number of messages */
  messageCount?: number;
  /** Whether trace headers should be present */
  hasTraceHeaders?: boolean;
  /** Expected destination */
  destination?: string;
  /** Custom matcher for payload */
  payloadMatcher?: (payload: unknown) => boolean;
  /** Expected trace ID */
  traceId?: string;
}
/**
 * Consumer assertion options
 */
interface ConsumerAssertionOptions {
  /** Expected number of messages processed */
  messageCount?: number;
  /** Whether producer links should be present */
  hasProducerLinks?: boolean;
  /** Expected destination */
  destination?: string;
  /** Expected consumer group */
  consumerGroup?: string;
  /** Whether any messages were duplicates */
  hasDuplicates?: boolean;
  /** Whether any messages were out of order */
  hasOutOfOrder?: boolean;
  /** Whether any messages went to DLQ */
  hasDLQ?: boolean;
}
/**
 * Messaging test harness
 */
interface MessagingTestHarness {
  /** All recorded producer calls */
  producerCalls: RecordedProducerCall[];
  /** All recorded consumer calls */
  consumerCalls: RecordedConsumerCall[];
  /** All recorded rebalance events */
  rebalanceEvents: RecordedRebalanceEvent[];
  /**
   * Record a producer call
   */
  recordProducerCall(call: Omit<RecordedProducerCall, 'timestamp'>): void;
  /**
   * Record a consumer call
   */
  recordConsumerCall(call: Omit<RecordedConsumerCall, 'timestamp'>): void;
  /**
   * Record a rebalance event
   */
  recordRebalanceEvent(event: RecordedRebalanceEvent): void;
  /**
   * Create a mock message with trace headers
   */
  createMockMessage<T>(payload: T, options?: Partial<MockMessage<T>>): MockMessage<T>;
  /**
   * Create mock trace headers
   */
  createMockTraceHeaders(traceId?: string, spanId?: string): Record<string, string>;
  /**
   * Assert producer was called with expected options
   */
  assertProducerCalled(destination: string, options?: ProducerAssertionOptions): void;
  /**
   * Assert producer was not called
   */
  assertProducerNotCalled(destination?: string): void;
  /**
   * Assert consumer processed messages with expected options
   */
  assertConsumerProcessed(destination: string, options?: ConsumerAssertionOptions): void;
  /**
   * Assert consumer was not called
   */
  assertConsumerNotCalled(destination?: string): void;
  /**
   * Assert rebalance occurred
   */
  assertRebalanceOccurred(destination: string, type: RebalanceEvent['type'], partitionCount?: number): void;
  /**
   * Get producer calls for destination
   */
  getProducerCalls(destination?: string): RecordedProducerCall[];
  /**
   * Get consumer calls for destination
   */
  getConsumerCalls(destination?: string): RecordedConsumerCall[];
  /**
   * Get the last producer call
   */
  getLastProducerCall(destination?: string): RecordedProducerCall | undefined;
  /**
   * Get the last consumer call
   */
  getLastConsumerCall(destination?: string): RecordedConsumerCall | undefined;
  /**
   * Reset all recorded calls
   */
  reset(): void;
  /**
   * Shutdown the harness
   */
  shutdown(): void;
}
/**
 * Create a messaging test harness
 *
 * Provides utilities for recording and asserting on producer/consumer calls
 * during testing.
 *
 * @example
 * ```typescript
 * const harness = createMessagingTestHarness();
 *
 * // In your test setup
 * beforeEach(() => harness.reset());
 *
 * // In your tests
 * it('should publish order event', async () => {
 *   await orderService.createOrder({ id: '123' });
 *
 *   harness.assertProducerCalled('orders', {
 *     messageCount: 1,
 *     hasTraceHeaders: true,
 *   });
 *
 *   const lastCall = harness.getLastProducerCall('orders');
 *   expect(lastCall?.payload).toMatchObject({ orderId: '123' });
 * });
 * ```
 */
declare function createMessagingTestHarness(): MessagingTestHarness;
/**
 * Mock message broker for testing
 */
interface MockMessageBroker {
  /** Topics/queues in the broker */
  topics: Map<string, MockMessage[]>;
  /**
   * Publish a message to a topic
   */
  publish(topic: string, message: MockMessage): void;
  /**
   * Consume messages from a topic
   */
  consume(topic: string, count?: number): MockMessage[];
  /**
   * Peek at messages without consuming
   */
  peek(topic: string, count?: number): MockMessage[];
  /**
   * Get message count for topic
   */
  getMessageCount(topic: string): number;
  /**
   * Clear all messages
   */
  clear(topic?: string): void;
  /**
   * Create a topic
   */
  createTopic(topic: string): void;
  /**
   * Delete a topic
   */
  deleteTopic(topic: string): void;
  /**
   * List all topics
   */
  listTopics(): string[];
}
/**
 * Create a mock message broker for testing
 *
 * Simulates a message broker (Kafka, SQS, RabbitMQ, etc.) for unit testing.
 *
 * @example
 * ```typescript
 * const broker = createMockMessageBroker();
 *
 * // Producer publishes
 * broker.publish('orders', { payload: { orderId: '123' }, headers: {} });
 *
 * // Consumer receives
 * const messages = broker.consume('orders');
 * expect(messages).toHaveLength(1);
 * expect(messages[0].payload).toEqual({ orderId: '123' });
 * ```
 */
declare function createMockMessageBroker(): MockMessageBroker;
/**
 * Extract trace ID from traceparent header
 */
declare function extractTraceIdFromHeader(traceparent: string): string | null;
/**
 * Extract span ID from traceparent header
 */
declare function extractSpanIdFromHeader(traceparent: string): string | null;
/**
 * Create a mock span context
 */
declare function createMockSpanContext(traceId?: string, spanId?: string): SpanContext;
/**
 * Create a mock link to a producer span
 */
declare function createMockProducerLink(traceId?: string, spanId?: string): Link;
/**
 * Create a batch of mock messages
 */
declare function createMockMessageBatch<T>(payloads: T[], options?: {
  startOffset?: number;
  partition?: number;
  addTraceHeaders?: boolean;
  traceId?: string;
}): MockMessage<T>[];
/**
 * Create a rebalance scenario
 */
declare function createRebalanceScenario(topic: string, consumerGroup: string, partitions: number[]): {
  assignEvent: RecordedRebalanceEvent;
  revokeEvent: RecordedRebalanceEvent;
};
/**
 * Create an out-of-order scenario
 */
declare function createOutOfOrderScenario<T>(payloads: T[], outOfOrderIndices: number[]): MockMessage<T>[];
/**
 * Create a duplicate message scenario
 */
declare function createDuplicateScenario<T>(payloads: T[], duplicateIndices: number[]): MockMessage<T>[];
//#endregion
export { ConsumerAssertionOptions, MessagingTestHarness, MockMessage, MockMessageBroker, ProducerAssertionOptions, RecordedConsumerCall, RecordedProducerCall, RecordedRebalanceEvent, createDuplicateScenario, createMessagingTestHarness, createMockMessageBatch, createMockMessageBroker, createMockProducerLink, createMockSpanContext, createOutOfOrderScenario, createRebalanceScenario, extractSpanIdFromHeader, extractTraceIdFromHeader };
//# sourceMappingURL=messaging-testing.d.cts.map