@nice2dev/ui-tools 1.0.10

package/dist/message-queue.d.ts

@@ -0,0 +1,1006 @@
+/**
+ * @file message-queue.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-13.4 — Message Queue Tools
+ *
+ * Types for message queue management: Kafka, RabbitMQ, ActiveMQ, Pulsar,
+ * AWS SQS, Azure Service Bus, schema registry, and message replay.
+ */
+/** Message queue type */
+export type MessageQueueType = 'kafka' | 'rabbitmq' | 'activemq' | 'pulsar' | 'sqs' | 'service-bus' | 'nats' | 'redis' | 'google-pubsub';
+/** Connection status */
+export type MQConnectionStatus = 'connected' | 'disconnected' | 'connecting' | 'error';
+/** Message format */
+export type MessageFormat = 'json' | 'avro' | 'protobuf' | 'string' | 'bytes' | 'xml';
+/** Kafka cluster */
+export interface KafkaCluster {
+    id: string;
+    name: string;
+    bootstrapServers: string[];
+    status: MQConnectionStatus;
+    version?: string;
+    controllerId?: number;
+    brokers: KafkaBroker[];
+    topics: KafkaTopic[];
+    consumerGroups: KafkaConsumerGroup[];
+    schemaRegistry?: SchemaRegistryConnection;
+    connect?: KafkaConnectCluster;
+    security?: KafkaSecurityConfig;
+    metrics?: KafkaClusterMetrics;
+}
+/** Kafka broker */
+export interface KafkaBroker {
+    id: number;
+    host: string;
+    port: number;
+    rack?: string;
+    isController: boolean;
+    status: 'online' | 'offline';
+    listeners: KafkaListener[];
+    config?: Record<string, string>;
+    metrics?: KafkaBrokerMetrics;
+}
+/** Kafka listener */
+export interface KafkaListener {
+    name: string;
+    host: string;
+    port: number;
+    protocol: 'PLAINTEXT' | 'SSL' | 'SASL_PLAINTEXT' | 'SASL_SSL';
+}
+/** Kafka security config */
+export interface KafkaSecurityConfig {
+    protocol: 'PLAINTEXT' | 'SSL' | 'SASL_PLAINTEXT' | 'SASL_SSL';
+    sasl?: KafkaSaslConfig;
+    ssl?: KafkaSslConfig;
+}
+/** Kafka SASL config */
+export interface KafkaSaslConfig {
+    mechanism: 'PLAIN' | 'SCRAM-SHA-256' | 'SCRAM-SHA-512' | 'OAUTHBEARER' | 'GSSAPI';
+    username?: string;
+    password?: string;
+    oauthConfig?: OAuthConfig;
+}
+/** OAuth config */
+export interface OAuthConfig {
+    tokenEndpoint: string;
+    clientId: string;
+    clientSecret?: string;
+    scope?: string;
+}
+/** Kafka SSL config */
+export interface KafkaSslConfig {
+    truststore?: TrustStoreConfig;
+    keystore?: KeyStoreConfig;
+    endpointIdentification?: boolean;
+}
+/** Trust store config */
+export interface TrustStoreConfig {
+    location: string;
+    password?: string;
+    type?: 'JKS' | 'PKCS12' | 'PEM';
+}
+/** Key store config */
+export interface KeyStoreConfig {
+    location: string;
+    password?: string;
+    keyPassword?: string;
+    type?: 'JKS' | 'PKCS12' | 'PEM';
+}
+/** Kafka topic */
+export interface KafkaTopic {
+    name: string;
+    partitions: KafkaPartition[];
+    replicationFactor: number;
+    config: TopicConfig;
+    internal: boolean;
+    compacted: boolean;
+    messageCount?: number;
+    sizeBytes?: number;
+    createdAt?: Date;
+}
+/** Topic configuration */
+export interface TopicConfig {
+    'cleanup.policy'?: 'delete' | 'compact' | 'delete,compact';
+    'retention.ms'?: number;
+    'retention.bytes'?: number;
+    'segment.bytes'?: number;
+    'segment.ms'?: number;
+    'compression.type'?: 'none' | 'gzip' | 'snappy' | 'lz4' | 'zstd';
+    'max.message.bytes'?: number;
+    'min.insync.replicas'?: number;
+    'message.timestamp.type'?: 'CreateTime' | 'LogAppendTime';
+    [key: string]: unknown;
+}
+/** Topic creation request */
+export interface TopicCreateRequest {
+    name: string;
+    partitions: number;
+    replicationFactor: number;
+    config?: Partial<TopicConfig>;
+}
+/** Kafka partition */
+export interface KafkaPartition {
+    id: number;
+    leader: number;
+    replicas: number[];
+    isr: number[];
+    offsets: PartitionOffsets;
+    preferredLeader?: number;
+    underReplicated?: boolean;
+}
+/** Partition offsets */
+export interface PartitionOffsets {
+    earliest: number;
+    latest: number;
+    logSize: number;
+}
+/** Kafka message */
+export interface KafkaMessage {
+    topic: string;
+    partition: number;
+    offset: number;
+    timestamp: Date;
+    timestampType: 'CreateTime' | 'LogAppendTime';
+    key?: string | Buffer;
+    value?: string | Buffer;
+    headers?: KafkaHeader[];
+    serializedKeySize: number;
+    serializedValueSize: number;
+    leader?: number;
+    schema?: MessageSchema;
+    deserialized?: DeserializedMessage;
+}
+/** Kafka header */
+export interface KafkaHeader {
+    key: string;
+    value: string | Buffer;
+}
+/** Message schema info */
+export interface MessageSchema {
+    type: 'avro' | 'protobuf' | 'json';
+    id?: number;
+    subject?: string;
+    version?: number;
+}
+/** Deserialized message */
+export interface DeserializedMessage {
+    key?: unknown;
+    value?: unknown;
+    keyFormat?: MessageFormat;
+    valueFormat?: MessageFormat;
+    error?: string;
+}
+/** Message search query */
+export interface MessageSearchQuery {
+    topic: string;
+    partitions?: number[];
+    startOffset?: number | 'earliest' | 'latest';
+    endOffset?: number;
+    startTime?: Date;
+    endTime?: Date;
+    limit?: number;
+    keyFilter?: string;
+    valueFilter?: string;
+    headerFilters?: Record<string, string>;
+    keyFormat?: MessageFormat;
+    valueFormat?: MessageFormat;
+    keySchema?: number;
+    valueSchema?: number;
+}
+/** Message search result */
+export interface MessageSearchResult {
+    messages: KafkaMessage[];
+    hasMore: boolean;
+    nextOffset?: number;
+    scanned: number;
+    matched: number;
+}
+/** Produce message request */
+export interface ProduceMessageRequest {
+    topic: string;
+    partition?: number;
+    key?: string | Buffer;
+    value: string | Buffer;
+    headers?: KafkaHeader[];
+    keyFormat?: MessageFormat;
+    valueFormat?: MessageFormat;
+    keySchema?: number;
+    valueSchema?: number;
+    timestamp?: Date;
+}
+/** Produce result */
+export interface ProduceResult {
+    topic: string;
+    partition: number;
+    offset: number;
+    timestamp?: Date;
+    error?: string;
+}
+/** Batch produce request */
+export interface BatchProduceRequest {
+    messages: ProduceMessageRequest[];
+    acks?: 'none' | 'leader' | 'all';
+    timeout?: number;
+    transactional?: boolean;
+}
+/** Batch produce result */
+export interface BatchProduceResult {
+    successful: ProduceResult[];
+    failed: ProduceError[];
+    totalSent: number;
+    totalFailed: number;
+}
+/** Produce error */
+export interface ProduceError {
+    message: ProduceMessageRequest;
+    error: string;
+    code?: string;
+}
+/** Kafka consumer group */
+export interface KafkaConsumerGroup {
+    groupId: string;
+    state: ConsumerGroupState;
+    protocolType: string;
+    protocol?: string;
+    coordinator: number;
+    members: ConsumerGroupMember[];
+    offsets: ConsumerGroupOffset[];
+    lag: ConsumerGroupLag;
+}
+/** Consumer group state */
+export type ConsumerGroupState = 'Unknown' | 'PreparingRebalance' | 'CompletingRebalance' | 'Stable' | 'Dead' | 'Empty';
+/** Consumer group member */
+export interface ConsumerGroupMember {
+    memberId: string;
+    clientId: string;
+    clientHost: string;
+    instanceId?: string;
+    assignment: TopicPartition[];
+}
+/** Topic partition */
+export interface TopicPartition {
+    topic: string;
+    partition: number;
+}
+/** Consumer group offset */
+export interface ConsumerGroupOffset {
+    topic: string;
+    partition: number;
+    currentOffset: number;
+    logEndOffset: number;
+    lag: number;
+    metadata?: string;
+}
+/** Consumer group lag */
+export interface ConsumerGroupLag {
+    totalLag: number;
+    byTopic: Record<string, number>;
+    byPartition: Record<string, Record<number, number>>;
+}
+/** Reset offsets request */
+export interface ResetOffsetsRequest {
+    groupId: string;
+    topics?: string[];
+    partitions?: TopicPartition[];
+    strategy: 'earliest' | 'latest' | 'to-offset' | 'to-datetime' | 'shift-by';
+    offset?: number;
+    datetime?: Date;
+    shift?: number;
+    execute?: boolean;
+}
+/** Reset offsets result */
+export interface ResetOffsetsResult {
+    success: boolean;
+    offsets: ConsumerGroupOffset[];
+    preview?: ConsumerGroupOffset[];
+}
+/** Schema registry connection */
+export interface SchemaRegistryConnection {
+    id: string;
+    name: string;
+    url: string;
+    status: MQConnectionStatus;
+    auth?: SchemaRegistryAuth;
+    compatibility?: CompatibilityLevel;
+    subjects: SchemaSubject[];
+}
+/** Schema registry auth */
+export interface SchemaRegistryAuth {
+    type: 'basic' | 'bearer' | 'ssl';
+    username?: string;
+    password?: string;
+    token?: string;
+    ssl?: KafkaSslConfig;
+}
+/** Compatibility level */
+export type CompatibilityLevel = 'NONE' | 'BACKWARD' | 'BACKWARD_TRANSITIVE' | 'FORWARD' | 'FORWARD_TRANSITIVE' | 'FULL' | 'FULL_TRANSITIVE';
+/** Schema subject */
+export interface SchemaSubject {
+    name: string;
+    versions: number[];
+    latestVersion: number;
+    compatibility?: CompatibilityLevel;
+    schemaType: 'AVRO' | 'PROTOBUF' | 'JSON';
+}
+/** Schema version */
+export interface SchemaVersion {
+    subject: string;
+    version: number;
+    id: number;
+    schemaType: 'AVRO' | 'PROTOBUF' | 'JSON';
+    schema: string;
+    references?: SchemaReference[];
+}
+/** Schema reference */
+export interface SchemaReference {
+    name: string;
+    subject: string;
+    version: number;
+}
+/** Register schema request */
+export interface RegisterSchemaRequest {
+    subject: string;
+    schemaType: 'AVRO' | 'PROTOBUF' | 'JSON';
+    schema: string;
+    references?: SchemaReference[];
+    normalize?: boolean;
+}
+/** Register schema result */
+export interface RegisterSchemaResult {
+    id: number;
+}
+/** Compatibility check result */
+export interface CompatibilityCheckResult {
+    isCompatible: boolean;
+    messages?: string[];
+}
+/** Kafka Connect cluster */
+export interface KafkaConnectCluster {
+    id: string;
+    name: string;
+    url: string;
+    status: MQConnectionStatus;
+    version?: string;
+    connectors: KafkaConnector[];
+    plugins: ConnectorPlugin[];
+}
+/** Kafka connector */
+export interface KafkaConnector {
+    name: string;
+    type: 'source' | 'sink';
+    status: ConnectorStatus;
+    config: Record<string, string>;
+    tasks: ConnectorTask[];
+    topics?: string[];
+}
+/** Connector status */
+export interface ConnectorStatus {
+    state: 'RUNNING' | 'PAUSED' | 'FAILED' | 'UNASSIGNED' | 'DESTROYED';
+    workerId: string;
+    trace?: string;
+}
+/** Connector task */
+export interface ConnectorTask {
+    id: number;
+    state: 'RUNNING' | 'PAUSED' | 'FAILED' | 'UNASSIGNED';
+    workerId: string;
+    trace?: string;
+}
+/** Connector plugin */
+export interface ConnectorPlugin {
+    class: string;
+    type: 'source' | 'sink' | 'converter' | 'header_converter' | 'transformation' | 'predicate';
+    version: string;
+}
+/** Connector configuration */
+export interface ConnectorConfig {
+    name: string;
+    'connector.class': string;
+    'tasks.max': string;
+    [key: string]: string;
+}
+/** Create connector request */
+export interface CreateConnectorRequest {
+    name: string;
+    config: ConnectorConfig;
+}
+/** RabbitMQ cluster */
+export interface RabbitMQCluster {
+    id: string;
+    name: string;
+    url: string;
+    status: MQConnectionStatus;
+    version?: string;
+    nodes: RabbitMQNode[];
+    vhosts: RabbitMQVhost[];
+    overview?: RabbitMQOverview;
+}
+/** RabbitMQ node */
+export interface RabbitMQNode {
+    name: string;
+    type: 'disc' | 'ram';
+    running: boolean;
+    memoryUsed: number;
+    memoryLimit: number;
+    diskFree: number;
+    diskLimit: number;
+    fdUsed: number;
+    fdTotal: number;
+    socketUsed: number;
+    socketTotal: number;
+    procUsed: number;
+    procTotal: number;
+    uptime?: number;
+    rates?: RabbitMQRates;
+}
+/** RabbitMQ rates */
+export interface RabbitMQRates {
+    publishRate: number;
+    deliverRate: number;
+    ackRate: number;
+    redeliverRate: number;
+}
+/** RabbitMQ vhost */
+export interface RabbitMQVhost {
+    name: string;
+    description?: string;
+    tracing: boolean;
+    messages: number;
+    messagesReady: number;
+    messagesUnacknowledged: number;
+    queues: RabbitMQQueue[];
+    exchanges: RabbitMQExchange[];
+    bindings: RabbitMQBinding[];
+}
+/** RabbitMQ overview */
+export interface RabbitMQOverview {
+    clusterName: string;
+    managementVersion: string;
+    rabbitMQVersion: string;
+    erlangVersion: string;
+    messageStats: RabbitMQMessageStats;
+    queueTotals: RabbitMQQueueTotals;
+    objectTotals: RabbitMQObjectTotals;
+}
+/** RabbitMQ message stats */
+export interface RabbitMQMessageStats {
+    publish: number;
+    publishDetails?: RateDetails;
+    confirm: number;
+    confirmDetails?: RateDetails;
+    deliver: number;
+    deliverDetails?: RateDetails;
+    deliverNoAck: number;
+    deliverGet: number;
+    ack: number;
+    ackDetails?: RateDetails;
+    redeliver: number;
+}
+/** Rate details */
+export interface RateDetails {
+    rate: number;
+    samples?: RateSample[];
+}
+/** Rate sample */
+export interface RateSample {
+    sample: number;
+    timestamp: number;
+}
+/** RabbitMQ queue totals */
+export interface RabbitMQQueueTotals {
+    messages: number;
+    messagesReady: number;
+    messagesUnacknowledged: number;
+}
+/** RabbitMQ object totals */
+export interface RabbitMQObjectTotals {
+    queues: number;
+    exchanges: number;
+    connections: number;
+    channels: number;
+    consumers: number;
+}
+/** RabbitMQ queue */
+export interface RabbitMQQueue {
+    name: string;
+    vhost: string;
+    type: 'classic' | 'quorum' | 'stream';
+    durable: boolean;
+    autoDelete: boolean;
+    exclusive: boolean;
+    arguments?: QueueArguments;
+    state: 'running' | 'idle' | 'flow' | 'down';
+    node?: string;
+    policy?: string;
+    messages: number;
+    messagesReady: number;
+    messagesUnacknowledged: number;
+    consumers: number;
+    memory?: number;
+    messageStats?: RabbitMQMessageStats;
+}
+/** Queue arguments */
+export interface QueueArguments {
+    'x-message-ttl'?: number;
+    'x-expires'?: number;
+    'x-max-length'?: number;
+    'x-max-length-bytes'?: number;
+    'x-overflow'?: 'drop-head' | 'reject-publish' | 'reject-publish-dlx';
+    'x-dead-letter-exchange'?: string;
+    'x-dead-letter-routing-key'?: string;
+    'x-max-priority'?: number;
+    'x-queue-mode'?: 'default' | 'lazy';
+    'x-queue-type'?: 'classic' | 'quorum' | 'stream';
+    [key: string]: unknown;
+}
+/** RabbitMQ exchange */
+export interface RabbitMQExchange {
+    name: string;
+    vhost: string;
+    type: ExchangeType;
+    durable: boolean;
+    autoDelete: boolean;
+    internal: boolean;
+    arguments?: Record<string, unknown>;
+    policy?: string;
+    messageStatsIn?: RabbitMQMessageStats;
+    messageStatsOut?: RabbitMQMessageStats;
+}
+/** Exchange type */
+export type ExchangeType = 'direct' | 'fanout' | 'topic' | 'headers' | 'x-delayed-message' | 'x-consistent-hash';
+/** RabbitMQ binding */
+export interface RabbitMQBinding {
+    source: string;
+    vhost: string;
+    destination: string;
+    destinationType: 'queue' | 'exchange';
+    routingKey: string;
+    arguments?: Record<string, unknown>;
+    propertiesKey: string;
+}
+/** Publish message request (RabbitMQ) */
+export interface RabbitMQPublishRequest {
+    exchange: string;
+    routingKey: string;
+    payload: string | Buffer;
+    properties?: RabbitMQMessageProperties;
+    payloadEncoding?: 'string' | 'base64';
+}
+/** RabbitMQ message properties */
+export interface RabbitMQMessageProperties {
+    contentType?: string;
+    contentEncoding?: string;
+    headers?: Record<string, unknown>;
+    deliveryMode?: 1 | 2;
+    priority?: number;
+    correlationId?: string;
+    replyTo?: string;
+    expiration?: string;
+    messageId?: string;
+    timestamp?: number;
+    type?: string;
+    userId?: string;
+    appId?: string;
+}
+/** Get messages request */
+export interface RabbitMQGetMessagesRequest {
+    queue: string;
+    vhost?: string;
+    count: number;
+    ackMode: 'ack_requeue_true' | 'ack_requeue_false' | 'reject_requeue_true' | 'reject_requeue_false';
+    encoding?: 'auto' | 'base64';
+    truncate?: number;
+}
+/** RabbitMQ message */
+export interface RabbitMQMessage {
+    payloadBytes: number;
+    redelivered: boolean;
+    exchange: string;
+    routingKey: string;
+    messageCount: number;
+    properties: RabbitMQMessageProperties;
+    payload: string;
+    payloadEncoding: string;
+}
+/** ActiveMQ connection */
+export interface ActiveMQConnection {
+    id: string;
+    name: string;
+    url: string;
+    status: MQConnectionStatus;
+    version?: string;
+    broker: ActiveMQBroker;
+    queues: ActiveMQDestination[];
+    topics: ActiveMQDestination[];
+}
+/** ActiveMQ broker */
+export interface ActiveMQBroker {
+    brokerId: string;
+    brokerName: string;
+    uptime: number;
+    storePercentUsage: number;
+    memoryPercentUsage: number;
+    tempPercentUsage: number;
+}
+/** ActiveMQ destination */
+export interface ActiveMQDestination {
+    name: string;
+    type: 'queue' | 'topic';
+    enqueueCount: number;
+    dequeueCount: number;
+    dispatchCount: number;
+    expiredCount: number;
+    inflightCount: number;
+    consumerCount: number;
+    producerCount: number;
+    queueSize: number;
+    memoryPercentUsage: number;
+}
+/** Apache Pulsar cluster */
+export interface PulsarCluster {
+    id: string;
+    name: string;
+    serviceUrl: string;
+    webServiceUrl: string;
+    status: MQConnectionStatus;
+    tenants: PulsarTenant[];
+    brokers: PulsarBroker[];
+}
+/** Pulsar tenant */
+export interface PulsarTenant {
+    name: string;
+    adminRoles: string[];
+    allowedClusters: string[];
+    namespaces: PulsarNamespace[];
+}
+/** Pulsar namespace */
+export interface PulsarNamespace {
+    name: string;
+    tenant: string;
+    topics: PulsarTopic[];
+    policies?: PulsarNamespacePolicies;
+}
+/** Pulsar namespace policies */
+export interface PulsarNamespacePolicies {
+    retentionPolicies?: RetentionPolicies;
+    backlogQuota?: BacklogQuota;
+    messageTTLInSeconds?: number;
+    deduplicationEnabled?: boolean;
+    replicationClusters?: string[];
+}
+/** Retention policies */
+export interface RetentionPolicies {
+    retentionTimeInMinutes: number;
+    retentionSizeInMB: number;
+}
+/** Backlog quota */
+export interface BacklogQuota {
+    limit: number;
+    limitTime: number;
+    policy: 'producer_request_hold' | 'producer_exception' | 'consumer_backlog_eviction';
+}
+/** Pulsar topic */
+export interface PulsarTopic {
+    name: string;
+    namespace: string;
+    tenant: string;
+    persistent: boolean;
+    partitioned: boolean;
+    partitions?: number;
+    stats?: PulsarTopicStats;
+}
+/** Pulsar topic stats */
+export interface PulsarTopicStats {
+    msgRateIn: number;
+    msgRateOut: number;
+    msgThroughputIn: number;
+    msgThroughputOut: number;
+    averageMsgSize: number;
+    storageSize: number;
+    publishers: PulsarPublisher[];
+    subscriptions: Record<string, PulsarSubscription>;
+}
+/** Pulsar publisher */
+export interface PulsarPublisher {
+    producerId: number;
+    producerName: string;
+    address: string;
+    msgRateIn: number;
+    msgThroughputIn: number;
+    averageMsgSize: number;
+}
+/** Pulsar subscription */
+export interface PulsarSubscription {
+    name: string;
+    type: 'Exclusive' | 'Shared' | 'Failover' | 'Key_Shared';
+    consumers: PulsarConsumer[];
+    msgRateOut: number;
+    msgThroughputOut: number;
+    msgBacklog: number;
+    msgRateExpired: number;
+    unackedMessages: number;
+}
+/** Pulsar consumer */
+export interface PulsarConsumer {
+    consumerName: string;
+    address: string;
+    msgRateOut: number;
+    msgThroughputOut: number;
+    unackedMessages: number;
+    blockedConsumerOnUnackedMsgs: boolean;
+}
+/** Pulsar broker */
+export interface PulsarBroker {
+    serviceUrl: string;
+    webServiceUrl: string;
+}
+/** AWS SQS queue */
+export interface SQSQueue {
+    queueUrl: string;
+    queueArn: string;
+    queueName: string;
+    type: 'standard' | 'fifo';
+    attributes: SQSQueueAttributes;
+    deadLetterQueue?: string;
+    redrivePolicies?: SQSRedrivePolicy;
+}
+/** SQS queue attributes */
+export interface SQSQueueAttributes {
+    approximateNumberOfMessages: number;
+    approximateNumberOfMessagesNotVisible: number;
+    approximateNumberOfMessagesDelayed: number;
+    createdTimestamp: number;
+    lastModifiedTimestamp: number;
+    visibilityTimeout: number;
+    maximumMessageSize: number;
+    messageRetentionPeriod: number;
+    delaySeconds: number;
+    receiveMessageWaitTimeSeconds: number;
+    contentBasedDeduplication?: boolean;
+    fifoQueue?: boolean;
+    deduplicationScope?: 'messageGroup' | 'queue';
+    fifoThroughputLimit?: 'perQueue' | 'perMessageGroupId';
+}
+/** SQS redrive policy */
+export interface SQSRedrivePolicy {
+    deadLetterTargetArn: string;
+    maxReceiveCount: number;
+}
+/** SQS message */
+export interface SQSMessage {
+    messageId: string;
+    receiptHandle: string;
+    md5OfBody: string;
+    body: string;
+    attributes?: SQSMessageAttributes;
+    messageAttributes?: Record<string, SQSMessageAttributeValue>;
+    md5OfMessageAttributes?: string;
+}
+/** SQS message attributes */
+export interface SQSMessageAttributes {
+    SenderId?: string;
+    SentTimestamp?: string;
+    ApproximateReceiveCount?: string;
+    ApproximateFirstReceiveTimestamp?: string;
+    SequenceNumber?: string;
+    MessageGroupId?: string;
+    MessageDeduplicationId?: string;
+}
+/** SQS message attribute value */
+export interface SQSMessageAttributeValue {
+    DataType: string;
+    StringValue?: string;
+    BinaryValue?: Buffer;
+}
+/** Azure Service Bus namespace */
+export interface ServiceBusNamespace {
+    id: string;
+    name: string;
+    connectionString: string;
+    status: MQConnectionStatus;
+    sku: 'Basic' | 'Standard' | 'Premium';
+    queues: ServiceBusQueue[];
+    topics: ServiceBusTopic[];
+}
+/** Service Bus queue */
+export interface ServiceBusQueue {
+    name: string;
+    status: 'Active' | 'Disabled' | 'ReceiveDisabled' | 'SendDisabled';
+    messageCount: number;
+    activeMessageCount: number;
+    deadLetterMessageCount: number;
+    scheduledMessageCount: number;
+    transferMessageCount: number;
+    transferDeadLetterMessageCount: number;
+    sizeInBytes: number;
+    maxSizeInMegabytes: number;
+    lockDuration: string;
+    maxDeliveryCount: number;
+    requiresSession: boolean;
+    enablePartitioning: boolean;
+    enableBatchedOperations: boolean;
+    deadLetteringOnMessageExpiration: boolean;
+    defaultMessageTimeToLive: string;
+    duplicateDetectionHistoryTimeWindow?: string;
+    autoDeleteOnIdle?: string;
+    forwardTo?: string;
+    forwardDeadLetteredMessagesTo?: string;
+}
+/** Service Bus topic */
+export interface ServiceBusTopic {
+    name: string;
+    status: 'Active' | 'Disabled' | 'ReceiveDisabled' | 'SendDisabled';
+    subscriptionCount: number;
+    maxSizeInMegabytes: number;
+    sizeInBytes: number;
+    enablePartitioning: boolean;
+    enableBatchedOperations: boolean;
+    defaultMessageTimeToLive: string;
+    duplicateDetectionHistoryTimeWindow?: string;
+    supportOrdering: boolean;
+    autoDeleteOnIdle?: string;
+    subscriptions: ServiceBusSubscription[];
+}
+/** Service Bus subscription */
+export interface ServiceBusSubscription {
+    name: string;
+    topicName: string;
+    status: 'Active' | 'Disabled' | 'ReceiveDisabled' | 'SendDisabled';
+    messageCount: number;
+    activeMessageCount: number;
+    deadLetterMessageCount: number;
+    maxDeliveryCount: number;
+    lockDuration: string;
+    enableBatchedOperations: boolean;
+    deadLetteringOnMessageExpiration: boolean;
+    defaultMessageTimeToLive: string;
+    autoDeleteOnIdle?: string;
+    forwardTo?: string;
+    forwardDeadLetteredMessagesTo?: string;
+    rules: ServiceBusRule[];
+}
+/** Service Bus rule */
+export interface ServiceBusRule {
+    name: string;
+    filter: SqlFilter | CorrelationFilter;
+    action?: SqlAction;
+}
+/** SQL filter */
+export interface SqlFilter {
+    type: 'sql';
+    sqlExpression: string;
+    parameters?: Record<string, unknown>;
+}
+/** Correlation filter */
+export interface CorrelationFilter {
+    type: 'correlation';
+    correlationId?: string;
+    messageId?: string;
+    to?: string;
+    replyTo?: string;
+    subject?: string;
+    sessionId?: string;
+    replyToSessionId?: string;
+    contentType?: string;
+    properties?: Record<string, unknown>;
+}
+/** SQL action */
+export interface SqlAction {
+    sqlExpression: string;
+    parameters?: Record<string, unknown>;
+}
+/** Message replay configuration */
+export interface MessageReplayConfig {
+    source: ReplaySource;
+    destination: ReplayDestination;
+    filter?: ReplayFilter;
+    transform?: ReplayTransform;
+    options: ReplayOptions;
+}
+/** Replay source */
+export interface ReplaySource {
+    type: MessageQueueType;
+    connectionId: string;
+    topic?: string;
+    queue?: string;
+    partition?: number;
+    startOffset?: number | 'earliest';
+    endOffset?: number | 'latest';
+    startTime?: Date;
+    endTime?: Date;
+}
+/** Replay destination */
+export interface ReplayDestination {
+    type: MessageQueueType | 'same';
+    connectionId?: string;
+    topic?: string;
+    queue?: string;
+    partition?: number;
+}
+/** Replay filter */
+export interface ReplayFilter {
+    keyPattern?: string;
+    valuePattern?: string;
+    headerFilters?: Record<string, string>;
+    expression?: string;
+}
+/** Replay transform */
+export interface ReplayTransform {
+    keyTransform?: string;
+    valueTransform?: string;
+    headerTransform?: Record<string, string>;
+}
+/** Replay options */
+export interface ReplayOptions {
+    batchSize?: number;
+    delayMs?: number;
+    dryRun?: boolean;
+    preserveTimestamp?: boolean;
+    preservePartition?: boolean;
+    stopOnError?: boolean;
+    maxMessages?: number;
+}
+/** Replay execution */
+export interface ReplayExecution {
+    id: string;
+    config: MessageReplayConfig;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    progress: ReplayProgress;
+    startTime: Date;
+    endTime?: Date;
+    error?: string;
+}
+/** Replay progress */
+export interface ReplayProgress {
+    totalMessages: number;
+    processedMessages: number;
+    failedMessages: number;
+    skippedMessages: number;
+    currentOffset?: number;
+    estimatedTimeRemaining?: number;
+}
+/** Kafka cluster metrics */
+export interface KafkaClusterMetrics {
+    activeControllerCount: number;
+    offlinePartitionsCount: number;
+    underReplicatedPartitions: number;
+    totalTopics: number;
+    totalPartitions: number;
+    totalReplicas: number;
+    inSyncReplicas: number;
+    messagesInPerSec: MetricValue;
+    bytesInPerSec: MetricValue;
+    bytesOutPerSec: MetricValue;
+    requestsPerSec: MetricValue;
+    produceLatency: MetricValue;
+    fetchConsumerLatency: MetricValue;
+}
+/** Kafka broker metrics */
+export interface KafkaBrokerMetrics {
+    messagesInPerSec: MetricValue;
+    bytesInPerSec: MetricValue;
+    bytesOutPerSec: MetricValue;
+    requestsPerSec: MetricValue;
+    failedProduceRequestsPerSec: MetricValue;
+    failedFetchRequestsPerSec: MetricValue;
+    produceLatencyMs: MetricValue;
+    fetchConsumerLatencyMs: MetricValue;
+    networkProcessorAvgIdlePercent: number;
+    requestHandlerAvgIdlePercent: number;
+    leaderCount: number;
+    partitionCount: number;
+    underReplicatedPartitions: number;
+}
+/** Metric value */
+export interface MetricValue {
+    current: number;
+    mean?: number;
+    min?: number;
+    max?: number;
+    percentile50?: number;
+    percentile95?: number;
+    percentile99?: number;
+    count?: number;
+    rate?: number;
+}
+//# sourceMappingURL=message-queue.d.ts.map