transport

type APIDocumentation struct {
	PackageName  string           `json:"package_name"`
	Synopsis     string           `json:"synopsis"`
	Description  string           `json:"description"`
	Interfaces   []InterfaceDoc   `json:"interfaces"`
	Types        []TypeDoc        `json:"types"`
	Functions    []FunctionDoc    `json:"functions"`
	Examples     []ExampleDoc     `json:"examples"`
	Deprecations []DeprecationDoc `json:"deprecations"`
	GeneratedAt  time.Time        `json:"generated_at"`
	Version      string           `json:"version"`
}

type AckHandler func(ctx context.Context, eventID string, success bool) error

type AckHandlerProvider interface {
	// SetAckHandler sets a callback for handling acknowledgments.
	SetAckHandler(handler AckHandler)
}

type AdvancedMockTransport struct {
	*MockTransport
	// contains filtered or unexported fields
}

type AggregatorOptions struct {
	// StopOnFirstError stops aggregation when the first error is encountered
	StopOnFirstError bool

	// MaxIssues limits the total number of issues to collect
	MaxIssues int

	// IncludeWarnings includes warning-level issues in the aggregation
	IncludeWarnings bool

	// IncludeInfo includes info-level issues in the aggregation
	IncludeInfo bool

	// DuplicateDetection enables detection and removal of duplicate issues
	DuplicateDetection bool
}

type AlertLevel string

type AllOfValidator[T any] struct {
	// contains filtered or unexported fields
}

type AnyOfValidator[T any] struct {
	// contains filtered or unexported fields
}

type AsynchronousValidator struct {
	// contains filtered or unexported fields
}

type AuthConfig struct {
	// Type specifies the authentication type
	Type string `json:"type"`

	// Token specifies the authentication token
	Token string `json:"token,omitempty"`

	// Username specifies the username for basic auth
	Username string `json:"username,omitempty"`

	// Password specifies the password for basic auth
	Password string `json:"password,omitempty"`

	// APIKey specifies the API key
	APIKey string `json:"api_key,omitempty"`

	// APISecret specifies the API secret
	APISecret string `json:"api_secret,omitempty"`

	// TokenURL specifies the token endpoint URL
	TokenURL string `json:"token_url,omitempty"`

	// RefreshURL specifies the refresh endpoint URL
	RefreshURL string `json:"refresh_url,omitempty"`

	// RefreshToken specifies the refresh token
	RefreshToken string `json:"refresh_token,omitempty"`

	// ClientID specifies the OAuth client ID
	ClientID string `json:"client_id,omitempty"`

	// ClientSecret specifies the OAuth client secret
	ClientSecret string `json:"client_secret,omitempty"`

	// Scopes specifies the OAuth scopes
	Scopes []string `json:"scopes,omitempty"`

	// ExpiresAt specifies when the token expires
	ExpiresAt time.Time `json:"expires_at,omitempty"`

	// CustomHeaders specifies custom authentication headers
	CustomHeaders map[string]string `json:"custom_headers,omitempty"`
}

type AuthProvider interface {
	// GetCredentials returns authentication credentials.
	GetCredentials(ctx context.Context) (map[string]string, error)

	// RefreshCredentials refreshes authentication credentials.
	RefreshCredentials(ctx context.Context) error

	// IsValid returns true if the credentials are valid.
	IsValid() bool

	// ExpiresAt returns when the credentials expire.
	ExpiresAt() time.Time
}

type BackpressureConfig struct {
	// Strategy defines the backpressure strategy to use
	Strategy BackpressureStrategy `yaml:"strategy" json:"strategy" default:"none"`

	// BufferSize is the size of the event buffer
	BufferSize int `yaml:"buffer_size" json:"buffer_size" default:"1024"`

	// HighWaterMark is the percentage of buffer fullness that triggers backpressure
	HighWaterMark float64 `yaml:"high_water_mark" json:"high_water_mark" default:"0.8"`

	// LowWaterMark is the percentage of buffer fullness that releases backpressure
	LowWaterMark float64 `yaml:"low_water_mark" json:"low_water_mark" default:"0.2"`

	// BlockTimeout is the maximum time to block when using block_timeout strategy
	BlockTimeout time.Duration `yaml:"block_timeout" json:"block_timeout" default:"5s"`

	// EnableMetrics enables backpressure metrics collection
	EnableMetrics bool `yaml:"enable_metrics" json:"enable_metrics" default:"true"`
}

type BackpressureHandler struct {
	// contains filtered or unexported fields
}

type BackpressureMetrics struct {
	EventsDropped      uint64        `json:"events_dropped"`
	EventsBlocked      uint64        `json:"events_blocked"`
	BlockedDuration    time.Duration `json:"blocked_duration"`
	CurrentBufferSize  int           `json:"current_buffer_size"`
	MaxBufferSize      int           `json:"max_buffer_size"`
	HighWaterMarkHits  uint64        `json:"high_water_mark_hits"`
	LowWaterMarkHits   uint64        `json:"low_water_mark_hits"`
	LastDropTime       time.Time     `json:"last_drop_time"`
	LastBlockTime      time.Time     `json:"last_block_time"`
	BackpressureActive bool          `json:"backpressure_active"`
	// contains filtered or unexported fields
}

type BackpressureStrategy string

type BaseConfig struct {
	// Transport type (e.g., "websocket", "http", "grpc")
	Type string `json:"type"`

	// Endpoint URL or address
	Endpoint string `json:"endpoint"`

	// Connection timeout
	Timeout time.Duration `json:"timeout"`

	// Custom headers
	Headers map[string]string `json:"headers,omitempty"`

	// TLS configuration for secure connections
	TLS *tls.Config `json:"-"`

	// EnableCompression enables data compression
	EnableCompression bool `json:"enable_compression"`

	// MaxMessageSize sets the maximum message size in bytes
	MaxMessageSize int64 `json:"max_message_size"`

	// ReadBufferSize sets the read buffer size
	ReadBufferSize int `json:"read_buffer_size"`

	// WriteBufferSize sets the write buffer size
	WriteBufferSize int `json:"write_buffer_size"`

	// KeepAlive configuration
	KeepAlive *KeepAliveConfig `json:"keep_alive,omitempty"`

	// Retry configuration
	Retry *RetryConfig `json:"retry,omitempty"`

	// Circuit breaker configuration
	CircuitBreaker *CircuitBreakerConfig `json:"circuit_breaker,omitempty"`

	// Authentication configuration
	Auth *AuthConfig `json:"auth,omitempty"`

	// Metrics configuration
	Metrics *MetricsConfig `json:"metrics,omitempty"`

	// Custom metadata
	Metadata map[string]any `json:"metadata,omitempty"`
}

type BatchEvent[T EventData] struct {
	// BatchID is the unique identifier for this batch
	BatchID string `json:"batch_id"`

	// Events contains the events in this batch
	Events []TypedTransportEvent[T] `json:"events"`

	// BatchSize is the number of events in this batch
	BatchSize int `json:"batch_size"`

	// MaxBatchSize is the maximum allowed batch size
	MaxBatchSize int `json:"max_batch_size"`

	// CreatedAt when the batch was created
	CreatedAt time.Time `json:"created_at"`

	// CompletedAt when the batch processing completed (nil if not completed)
	CompletedAt *time.Time `json:"completed_at,omitempty"`

	// ProcessingDuration how long the batch took to process
	ProcessingDuration time.Duration `json:"processing_duration,omitempty"`

	// Status indicates the batch status (pending, processing, completed, failed)
	Status string `json:"status"`

	// Errors contains any processing errors
	Errors []error `json:"errors,omitempty"`

	// SuccessCount number of successfully processed events
	SuccessCount int `json:"success_count"`

	// FailureCount number of failed events
	FailureCount int `json:"failure_count"`

	// Metadata contains additional batch metadata
	Metadata map[string]interface{} `json:"metadata,omitempty"`

	// ProcessorID identifies the processor that handled this batch
	ProcessorID string `json:"processor_id,omitempty"`

	// Priority indicates batch processing priority
	Priority int `json:"priority,omitempty"`

	// RetryAttempt for failed batch retries
	RetryAttempt int `json:"retry_attempt,omitempty"`

	// MaxRetries maximum number of retry attempts
	MaxRetries int `json:"max_retries,omitempty"`
}

type BatchSender interface {
	// SendBatch sends multiple events in a single batch operation.
	SendBatch(ctx context.Context, events []TransportEvent) error
}

type BatchValidator struct {
	// contains filtered or unexported fields
}

type BoolValue struct{ Value bool }

type CacheStats struct {
	Hits         uint64
	Misses       uint64
	Size         int
	MaxSize      int
	Evictions    uint64
	TotalOps     uint64
	HitRate      float64
	LastHitTime  time.Time
	LastMissTime time.Time
	// contains filtered or unexported fields
}

type CachedValidator struct {
	// contains filtered or unexported fields
}

type Capabilities struct {
	// Streaming indicates if the transport supports streaming
	Streaming bool

	// Bidirectional indicates if the transport supports bidirectional communication
	Bidirectional bool

	// MaxMessageSize is the maximum message size supported (0 for unlimited)
	MaxMessageSize int64

	// ProtocolVersion is the version of the transport protocol
	ProtocolVersion string

	// Features is a map of feature names to their values
	Features map[string]interface{}
}

type ChaosTransport struct {
	*AdvancedMockTransport
	// contains filtered or unexported fields
}

type CircuitBreaker interface {
	// Execute executes an operation with circuit breaker protection.
	Execute(ctx context.Context, operation func() error) error

	// IsOpen returns true if the circuit breaker is open.
	IsOpen() bool

	// Reset resets the circuit breaker state.
	Reset()

	// GetState returns the current circuit breaker state.
	GetState() CircuitBreakerState
}

type CircuitBreakerConfig struct {
	// Enabled enables circuit breaker
	Enabled bool `json:"enabled"`

	// FailureThreshold specifies the failure threshold to open the circuit
	FailureThreshold int `json:"failure_threshold"`

	// RecoveryTimeout specifies the recovery timeout
	RecoveryTimeout time.Duration `json:"recovery_timeout"`

	// HalfOpenMaxCalls specifies the maximum calls in half-open state
	HalfOpenMaxCalls int `json:"half_open_max_calls"`

	// MinCalls specifies the minimum calls before circuit evaluation
	MinCalls int `json:"min_calls"`

	// SlidingWindowSize specifies the sliding window size
	SlidingWindowSize int `json:"sliding_window_size"`

	// FailureRateThreshold specifies the failure rate threshold (percentage)
	FailureRateThreshold float64 `json:"failure_rate_threshold"`
}

type CircuitBreakerState int

type CleanupCompletionRule struct{}

type CleanupConfig struct {
	// MaxCleanupDuration is the maximum time allowed for cleanup
	MaxCleanupDuration time.Duration

	// PhaseTimeout is the timeout for each cleanup phase
	PhaseTimeout time.Duration

	// EnableStackTrace enables stack trace capture for debugging
	EnableStackTrace bool

	// Logger for cleanup events
	Logger Logger
}

type CleanupCoordinator struct {
	// contains filtered or unexported fields
}

type CleanupGroup struct {
	ID           string
	Name         string
	Priority     int      // Lower values = higher priority
	Dependencies []string // IDs of groups that must complete first
	Operations   []CleanupOperation
	// contains filtered or unexported fields
}

type CleanupManager struct {
	// contains filtered or unexported fields
}

type CleanupManagerConfig struct {
	DefaultTTL    time.Duration
	CheckInterval time.Duration
	Logger        *zap.Logger
}

type CleanupMetrics struct {
	TotalTasks             int
	ActiveTasks            int
	TotalRuns              uint64
	TotalItemsCleaned      uint64
	TotalErrors            uint64
	LastCleanupTime        time.Time
	AverageCleanupDuration time.Duration
	TaskMetrics            map[string]*TaskMetrics
	// contains filtered or unexported fields
}

type CleanupOperation struct {
	Name        string
	Description string
	Timeout     time.Duration
	Func        func(context.Context) error

	// Options
	ContinueOnError bool // Continue with next operation even if this fails
	Retryable       bool // Can retry if fails
	MaxRetries      int  // Maximum retry attempts
}

type CleanupPhase int

type CleanupStats struct {
	TotalTracked    int64
	TotalCleaned    int64
	CleanupErrors   int64
	CleanupDuration time.Duration
	PhaseDurations  map[CleanupPhase]time.Duration
	CurrentPhase    CleanupPhase
	ResourcesLeaked []LeakedResource
}

type CleanupTask struct {
	Name        string
	TTL         time.Duration
	LastCleanup time.Time
	CleanupFunc func() (itemsCleaned int, err error)

	// Statistics - cache line padded to prevent false sharing
	TotalRuns atomic.Uint64

	TotalCleaned atomic.Uint64

	TotalErrors atomic.Uint64

	LastError     error
	LastErrorTime time.Time
	// contains filtered or unexported fields
}

type CleanupTimeoutRule struct {
	// contains filtered or unexported fields
}

type CleanupTracker struct {
	// contains filtered or unexported fields
}

type CleanupValidationConfig struct {
	// EnableMemoryValidation enables memory leak detection
	EnableMemoryValidation bool

	// EnableGoroutineValidation enables goroutine leak detection
	EnableGoroutineValidation bool

	// EnableResourceValidation enables resource leak detection
	EnableResourceValidation bool

	// MemoryThreshold is the memory increase threshold to consider a leak
	MemoryThreshold int64

	// GoroutineThreshold is the goroutine increase threshold to consider a leak
	GoroutineThreshold int

	// ValidationTimeout is the timeout for validation operations
	ValidationTimeout time.Duration

	// Logger for validation events
	Logger Logger
}

type CleanupValidationError struct {
	Rule      string
	Message   string
	Severity  ErrorSeverity
	Component string
	Timestamp time.Time
	Details   map[string]interface{}
}

type CleanupValidationResult struct {
	ComponentID string
	StartTime   time.Time
	EndTime     time.Time
	Duration    time.Duration
	Success     bool
	Errors      []error

	// Memory statistics
	MemoryBefore runtime.MemStats
	MemoryAfter  runtime.MemStats
	MemoryDelta  int64

	// Goroutine statistics
	GoroutinesBefore int
	GoroutinesAfter  int
	GoroutineDelta   int

	// Resource tracking
	ResourcesTracked int
	ResourcesCleaned int
	ResourcesLeaked  int
	LeakedResources  []string

	// Cleanup phases
	PhaseResults map[CleanupPhase]PhaseResult

	// Validation results
	ValidationErrors []CleanupValidationError
	RulePassed       map[string]bool
	RuleErrors       map[string]error
}

type CleanupValidationRule interface {
	Name() string
	Description() string
	Validate(ctx context.Context, result *CleanupValidationResult) error
}

type CleanupValidator struct {
	// contains filtered or unexported fields
}

type CompositeEvent struct {
	BaseEvent SimpleTransportEvent
	Events    []TransportEvent
}

type Compressor interface {
	// Compress compresses the input data.
	Compress(data []byte) ([]byte, error)

	// Decompress decompresses the input data.
	Decompress(data []byte) ([]byte, error)

	// Algorithm returns the compression algorithm name.
	Algorithm() string

	// CompressionRatio returns the achieved compression ratio.
	CompressionRatio() float64
}

type ConcurrentTest struct {
	// contains filtered or unexported fields
}

type ConditionalEvent[T EventData] struct {
	// ConditionID identifies the condition to evaluate
	ConditionID string `json:"condition_id"`

	// Event is the wrapped event that may be processed conditionally
	Event TypedTransportEvent[T] `json:"event"`

	// Condition defines the condition to evaluate
	Condition *EventCondition `json:"condition"`

	// IsConditionMet indicates if the condition has been evaluated and met
	IsConditionMet *bool `json:"is_condition_met,omitempty"`

	// EvaluatedAt when the condition was last evaluated
	EvaluatedAt *time.Time `json:"evaluated_at,omitempty"`

	// EvaluationContext contains context used for condition evaluation
	EvaluationContext map[string]interface{} `json:"evaluation_context,omitempty"`

	// AlternativeAction defines what to do if condition is not met
	AlternativeAction string `json:"alternative_action,omitempty"`

	// MaxEvaluationAttempts limits how many times condition can be evaluated
	MaxEvaluationAttempts int `json:"max_evaluation_attempts,omitempty"`

	// EvaluationAttempts tracks how many times condition has been evaluated
	EvaluationAttempts int `json:"evaluation_attempts"`

	// TimeoutAt when the conditional event expires
	TimeoutAt *time.Time `json:"timeout_at,omitempty"`

	// Dependencies lists other conditions this condition depends on
	Dependencies []string `json:"dependencies,omitempty"`

	// Priority for condition evaluation ordering
	Priority int `json:"priority,omitempty"`

	// RetryPolicy for condition evaluation failures
	RetryPolicy *EventRetryPolicy `json:"retry_policy,omitempty"`
}

type ConditionalRule struct {
	Name        string
	Condition   func(interface{}) bool
	Validator   TypedValidator[any]
	Description string
}

type ConditionalValidator struct {
	// contains filtered or unexported fields
}

type Config interface {
	ConfigValidation
	ConfigMetadata
	ConfigTimeouts
	ConfigHeaders
}

type ConfigBuilder struct {
	// contains filtered or unexported fields
}

type ConfigError = LegacyConfigurationError

type ConfigHeaders interface {
	// GetHeaders returns custom headers for the transport.
	GetHeaders() map[string]string
}

type ConfigImpact string

type ConfigMetadata interface {
	// GetType returns the transport type (e.g., "websocket", "http", "grpc").
	GetType() string

	// GetEndpoint returns the endpoint URL or address.
	GetEndpoint() string

	// IsSecure returns true if the transport uses secure connections.
	IsSecure() bool
}

type ConfigProvider interface {
	// Config returns the transport's configuration.
	Config() Config
}

type ConfigTimeouts interface {
	// GetTimeout returns the connection timeout.
	GetTimeout() time.Duration
}

type ConfigValidation interface {
	// Validate validates the configuration.
	Validate() error

	// Clone creates a deep copy of the configuration.
	Clone() Config
}

type ConfigurationError[T ErrorValue] struct {
	Field   string
	Value   T
	Message string
}

type ConfigurationEventData struct {
	// Configuration change details
	Key       string `json:"key" validate:"required"`
	OldValue  string `json:"old_value,omitempty"`
	NewValue  string `json:"new_value" validate:"required"`
	ValueType string `json:"value_type" validate:"required"`

	// Change metadata
	ChangedBy string `json:"changed_by,omitempty"`
	Reason    string `json:"reason,omitempty"`
	Source    string `json:"source,omitempty"`
	Namespace string `json:"namespace,omitempty"`

	// Validation and rollback
	Validated   bool         `json:"validated"`
	Applied     bool         `json:"applied"`
	CanRollback bool         `json:"can_rollback"`
	Impact      ConfigImpact `json:"impact"`
}

type ConnectionCallback func(state ConnectionState, err error)

type ConnectionCapabilities struct {
	// Maximum message size supported
	MaxMessageSize int64 `json:"max_message_size,omitempty"`

	// Protocol version
	ProtocolVersion string `json:"protocol_version,omitempty"`

	// Custom extension capabilities for backward compatibility
	Extensions map[string]string `json:"extensions,omitempty"`
}

type ConnectionError struct {
	Endpoint string
	Cause    error
}

type ConnectionEventData struct {
	// Status indicates the connection status (connected, disconnected, reconnecting, etc.)
	Status string `json:"status"`

	// RemoteAddress is the address of the remote endpoint
	RemoteAddress string `json:"remote_address,omitempty"`

	// LocalAddress is the local address used for the connection
	LocalAddress string `json:"local_address,omitempty"`

	// Protocol is the protocol used (http, websocket, grpc, etc.)
	Protocol string `json:"protocol,omitempty"`

	// Version is the protocol version
	Version string `json:"version,omitempty"`

	// Capabilities are the negotiated capabilities
	Capabilities ConnectionCapabilities `json:"capabilities,omitempty"`

	// Error contains error information if the connection failed
	Error string `json:"error,omitempty"`

	// AttemptNumber for reconnection events
	AttemptNumber int `json:"attempt_number,omitempty"`
}

type ConnectionEventOption func(*ConnectionEventData)

type ConnectionFactory interface {
	CreateConnection(ctx context.Context) (net.Conn, error)
	ValidateConnection(conn net.Conn) bool
	CloseConnection(conn net.Conn) error
}

type ConnectionHandler func(state ConnectionState, err error)

type ConnectionPool struct {
	// contains filtered or unexported fields
}

type ConnectionPoolConfig struct {
	// Pool sizing
	InitialSize int // Initial number of connections
	MaxSize     int // Maximum number of connections
	MinIdleSize int // Minimum number of idle connections
	MaxIdleSize int // Maximum number of idle connections

	// Connection management
	MaxIdleTime    time.Duration // Maximum time a connection can be idle
	MaxLifetime    time.Duration // Maximum lifetime of a connection
	AcquireTimeout time.Duration // Timeout for acquiring a connection

	// Health checking
	HealthCheckInterval time.Duration // Interval for health checks
	HealthCheckTimeout  time.Duration // Timeout for health checks

	// Network settings
	DialTimeout     time.Duration // Timeout for dialing new connections
	KeepAlive       time.Duration // TCP keep-alive interval
	MaxConnLifetime time.Duration // Maximum connection lifetime

	// Validation
	ValidateOnAcquire bool // Validate connection when acquired
	ValidateOnReturn  bool // Validate connection when returned
}

type ConnectionState int

type Connector = TransportConnection

type ContextBestPractices struct{}

type ContextConfig struct {
	// DefaultTimeout is the default timeout for operations without explicit timeouts
	DefaultTimeout time.Duration

	// ConnectTimeout is the timeout for establishing connections
	ConnectTimeout time.Duration

	// SendTimeout is the timeout for send operations
	SendTimeout time.Duration

	// ReceiveTimeout is the timeout for receive operations
	ReceiveTimeout time.Duration

	// ShutdownTimeout is the timeout for graceful shutdown
	ShutdownTimeout time.Duration

	// RetryTimeout is the timeout for retry operations
	RetryTimeout time.Duration
}

type ContextualEvent[T EventData] struct {
	// ContextID identifies the context
	ContextID string `json:"context_id"`

	// Event is the wrapped event
	Event TypedTransportEvent[T] `json:"event"`

	// Context contains rich contextual information
	Context *EventContext `json:"context"`

	// CorrelationID for event correlation across systems
	CorrelationID string `json:"correlation_id,omitempty"`

	// CausationID identifies the event that caused this one
	CausationID string `json:"causation_id,omitempty"`

	// TraceID for distributed tracing
	TraceID string `json:"trace_id,omitempty"`

	// SpanID for distributed tracing
	SpanID string `json:"span_id,omitempty"`

	// BusinessContext contains business-specific context
	BusinessContext map[string]interface{} `json:"business_context,omitempty"`

	// TechnicalContext contains technical context
	TechnicalContext map[string]interface{} `json:"technical_context,omitempty"`

	// UserContext contains user-specific context
	UserContext *UserContext `json:"user_context,omitempty"`

	// RequestContext contains request-specific context
	RequestContext *RequestContext `json:"request_context,omitempty"`

	// EnvironmentContext contains environment information
	EnvironmentContext *EnvironmentContext `json:"environment_context,omitempty"`

	// SecurityContext contains security-related context
	SecurityContext *SecurityContext `json:"security_context,omitempty"`

	// Tags for event categorization and filtering
	Tags map[string]string `json:"tags,omitempty"`

	// Annotations for additional metadata
	Annotations map[string]string `json:"annotations,omitempty"`
}

type CoordinatorConfig struct {
	// MaxParallelCleanups limits concurrent cleanup operations
	MaxParallelCleanups int

	// GroupTimeout is the timeout for each cleanup group
	GroupTimeout time.Duration

	// EnableDeadlockDetection enables deadlock detection
	EnableDeadlockDetection bool

	// Logger for coordinator events
	Logger Logger
}

type CoordinatorState int32

type CoordinatorStatus struct {
	State        CoordinatorState
	Groups       map[string]GroupStatus
	Sequence     []string
	TrackerStats CleanupStats
}

type CrossFieldRule struct {
	Name        string
	Fields      []string
	Validator   func(values map[string]interface{}) error
	Description string
}

type CrossFieldValidator struct {
	// contains filtered or unexported fields
}

type DataEventData struct {
	// Content is the actual data payload
	Content []byte `json:"content"`

	// ContentType indicates the MIME type or format of the content
	ContentType string `json:"content_type,omitempty"`

	// Encoding indicates the encoding used (utf-8, base64, etc.)
	Encoding string `json:"encoding,omitempty"`

	// Size is the size of the content in bytes
	Size int64 `json:"size"`

	// Checksum for data integrity verification
	Checksum string `json:"checksum,omitempty"`

	// Compressed indicates if the content is compressed
	Compressed bool `json:"compressed,omitempty"`

	// StreamID if this data belongs to a specific stream
	StreamID string `json:"stream_id,omitempty"`

	// SequenceNumber for ordered delivery
	SequenceNumber uint64 `json:"sequence_number,omitempty"`
}

type DataEventOption func(*DataEventData)

type DataFormatRule struct {
	// contains filtered or unexported fields
}