nats

type AckPolicy = natspkg.AckPolicy

type AutopsyConfig = dlq.AutopsyConfig

type BackpressureConfig struct {
	Mode                     BackpressureMode
	MaxAckPending            int
	PendingMsgLimit          int
	PendingMsgBuffer         int
	QueueDepthSampleInterval time.Duration
}

type BackpressureMode uint8

type BehaviorAnomalyEvent struct {
	Stream       string
	Durable      string
	Normal       BehaviorSnapshot
	Current      BehaviorSnapshot
	SustainedFor time.Duration
}

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

type BehaviorFingerprintConfig struct {
	OnAnomaly func(BehaviorAnomalyEvent)
	// ReportKV, when set, publishes Normal/Current snapshots for nats-consol.
	ReportKV KeyValueKeys
	// ReportBucket defaults to DefaultBehaviorFingerprintKVBucket.
	ReportBucket string
	// PollInterval is how often the rolling window is evaluated (default 5s).
	PollInterval time.Duration
	// Window is the sample window used for current rate/latency (default 60s).
	Window time.Duration
	// Warmup is how long to learn baselines before detecting (default 5m).
	Warmup time.Duration
	// MinSamples required before detection (default 50).
	MinSamples int
	// LatencyFactor fires when current processing >= factor × baseline (default 3).
	LatencyFactor float64
	// RateTolerance is the ± fraction of baseline rate treated as "same throughput" (default 0.3).
	RateTolerance float64
	// SustainFor is how long the anomaly condition must hold before firing (default 30s).
	SustainFor time.Duration
	// CircuitStop stops the watcher after the first anomaly.
	CircuitStop bool
}

type BehaviorFingerprintKVPayload struct {
	UpdatedAt      time.Time                     `json:"updatedAt"`
	Stream         string                        `json:"stream"`
	Durable        string                        `json:"durable"`
	Normal         BehaviorFingerprintKVSnapshot `json:"normal"`
	Current        BehaviorFingerprintKVSnapshot `json:"current"`
	SustainedForMs int64                         `json:"sustainedForMs,omitempty"`
	Anomaly        bool                          `json:"anomaly"`
}

type BehaviorFingerprintKVSnapshot struct {
	MsgPerMin    float64 `json:"msgPerMin"`
	ProcessingMs float64 `json:"processingMs"`
}

type BehaviorSnapshot struct {
	MsgPerMin  float64
	Processing time.Duration
}

type Client interface {
	Consumer() Consumer
	Publisher() Publisher
	Requester() Requester
	Responder() Responder
	Connector() Connector
	Streams() StreamManager
	Consumers() ConsumerManager
	KV() KeyValueManager
	KVKeys() KeyValueKeys
	Objects() ObjectStoreManager
	Monitoring() Monitoring
	Replay() Replay
	// PublishRaw publishes bytes with optional headers and returns the JetStream ack.
	PublishRaw(ctx context.Context, subject string, data []byte, headers map[string]string) (*PubAck, error)
	SetupWorker(ctx context.Context, setup WorkerSetup, handler MsgHandler) (Subscription, error)
	SuperviseQueueSubscribeBound(ctx context.Context, stream, durable, queue, subject string, handler MsgHandler, cfg SupervisorConfig) (SupervisedSubscription, error)
	SuperviseSubscribeBound(ctx context.Context, stream, durable, subject string, handler MsgHandler, cfg SupervisorConfig) (SupervisedSubscription, error)
	SupervisePullProcess(ctx context.Context, stream, durable string, handler MsgHandler, cfg SupervisorConfig, opts ...ProcessOpt) error
	WatchSoftLiveness(ctx context.Context, sub Subscription, cfg SoftLivenessConfig) (*SoftLiveness, error)
	WatchBehaviorFingerprint(ctx context.Context, sub Subscription, cfg BehaviorFingerprintConfig) (*BehaviorFingerprint, error)
	// WithShadow wraps handlers and records shadow_* metrics when metrics are enabled.
	WithShadow(cfg ShadowConfig, primary, shadowHandler MsgHandler) MsgHandler
}

type Config struct {
	PublisherConfig PublisherConfig
	RequesterConfig RequesterConfig
	ResponderConfig ResponderConfig
	Metrics         MetricsConfig
	RuntimeConsumer RuntimeConsumerConfig
	// Stream is an optional topology template for callers; NewClient does not
	// create or update it. Provision streams via nats CLI / platform ops, or
	// explicitly with Streams().CreateOrUpdateStream / SetupWorker.
	Stream       StreamConfig
	Conn         Connection
	Backpressure BackpressureConfig
}

type Connection struct {
	// CustomReconnectDelay overrides the built-in capped exponential delay.
	CustomReconnectDelay func(attempts int) time.Duration

	// Optional hooks run after the library's internal connection handlers.
	OnDisconnect func(*natspkg.Conn, error)
	OnReconnect  func(*natspkg.Conn)
	OnClosed     func(*natspkg.Conn)

	Address  string
	User     string
	Password string
	Seed     string
	Secret   string
	// CredentialsFile is a NATS .creds / chained credentials file (operator JWT model).
	// Mutually exclusive with Seed, User/Password, and Secret.
	CredentialsFile string
	MetricPrefix    string

	ClientName string
	// TLS configures secure connections (mTLS / CA verification).
	TLS ConnectionTLS

	ReconnectWait      time.Duration
	MaxReconnect       int
	ConnectTimeout     time.Duration
	DrainTimeout       time.Duration
	PingInterval       time.Duration
	MaxPingsOut        int
	FlusherTimeout     time.Duration
	ReconnectJitter    time.Duration
	ReconnectJitterTLS time.Duration

	// ReconnectBufSize is the outbound buffer while reconnecting.
	// 0 leaves the nats.go library default (8 MiB); -1 disables buffering.
	ReconnectBufSize int

	HealthCheckInterval  time.Duration
	InitialRetryAttempts int
	InitialRetryWait     time.Duration
	InitialRetryBackoff  float64
	RetryOnFailedConnect bool
	AllowReconnect       bool
	AllowMetrics         bool
	// DontRandomize keeps server order when Address is a comma-separated list.
	DontRandomize bool
}

type ConnectionStatus struct {
	LastDisconnect time.Time
	LastError      error
	ServerURL      string
	ReconnectCount int64
	Connected      bool
	InLameDuck     bool
}

type ConnectionTLS struct {
	// Config is used as-is when non-nil (takes precedence over PEM fields).
	Config *tls.Config
	// ServerName overrides the hostname used for certificate verification.
	ServerName string
	// CA is a PEM-encoded CA certificate pool.
	CA []byte
	// Cert and Key are a PEM-encoded client certificate pair (mTLS).
	Cert []byte
	Key  []byte
	// InsecureSkipVerify disables server certificate verification (dev only).
	InsecureSkipVerify bool
}

type Connector interface {
	IsConnected() bool
	Shutdown() error
	HealthCheck(ctx context.Context) error
	ConnectionStatus() ConnectionStatus
	WaitConnected(ctx context.Context) error
	Conn() *natspkg.Conn
	JetStream() natspkg.JetStreamContext
	AccountInfo(ctx context.Context) (*natspkg.AccountInfo, error)
}

type Consumer interface {
	Subscribe(ctx context.Context, subject string, handler MsgHandler, opts ...natspkg.SubOpt) (Subscription, error)
	QueueSubscribe(ctx context.Context, queue, subject string, handler MsgHandler, opts ...natspkg.SubOpt) (Subscription, error)
	SubscribeBound(ctx context.Context, stream, durable, subject string, handler MsgHandler) (Subscription, error)
	QueueSubscribeBound(ctx context.Context, stream, durable, queue, subject string, handler MsgHandler) (Subscription, error)
	Pull(stream, durable string) (PullConsumer, error)
}

type ConsumerConfig = RuntimeConsumerConfig

type ConsumerManager interface {
	CreateOrUpdateConsumer(ctx context.Context, stream string, cfg DurableConsumerConfig) (*natspkg.ConsumerInfo, error)
	AddConsumer(ctx context.Context, stream string, cfg *natspkg.ConsumerConfig) (*natspkg.ConsumerInfo, error)
	UpdateConsumer(ctx context.Context, stream string, cfg *natspkg.ConsumerConfig) (*natspkg.ConsumerInfo, error)
	DeleteConsumer(ctx context.Context, stream, durable string) error
	ConsumerInfo(ctx context.Context, stream, durable string) (*natspkg.ConsumerInfo, error)
	ConsumerNames(ctx context.Context, stream string) ([]string, error)
	ListConsumers(ctx context.Context, stream string) ([]*natspkg.ConsumerInfo, error)
	ListConsumersPage(ctx context.Context, stream string, offset, limit int) ([]*natspkg.ConsumerInfo, int, error)
	PauseConsumer(ctx context.Context, stream, durable string, pauseUntil time.Time) error
	ResumeConsumer(ctx context.Context, stream, durable string) error
}

type DLQConfig struct {
	Publisher Publisher
	// Recorder receives an IncidentDLQ event after a successful route (optional).
	Recorder *FlightRecorder
	// Subject is the dead-letter publish subject (e.g. "orders.dlq").
	Subject string
	// Reason is stored in HeaderDLQReason when auto-routing on MaxDeliver.
	Reason string
	// Autopsy adds forensic headers (error, payload hash, optional stack).
	Autopsy AutopsyConfig
	// MaxDeliver routes to DLQ when metadata.NumDelivered >= MaxDeliver (0 disables auto route).
	MaxDeliver uint64
}

type DeliverPolicy = natspkg.DeliverPolicy

type DiscardPolicy = natspkg.DiscardPolicy

type DurableConsumerConfig struct {
	OptStartTime      *time.Time
	Metadata          map[string]string
	Durable           string
	FilterSubject     string
	FilterSubjects    []string
	DeliverPolicy     DeliverPolicy
	ReplayPolicy      ReplayPolicy
	AckPolicy         AckPolicy
	MaxDeliver        int
	AckWait           time.Duration
	MaxAckPending     int
	RateLimit         uint64
	Heartbeat         time.Duration
	InactiveThreshold time.Duration
	Replicas          int
	MaxWaiting        int
	OptStartSeq       uint64
	FlowControl       bool
	MemStorage        bool
	// HasAckPolicy marks AckPolicy as intentionally set so AckNone (zero) is preserved.
	HasAckPolicy bool
	// HasDeliverPolicy marks DeliverPolicy as intentionally set (including DeliverAll).
	HasDeliverPolicy bool
	// HasReplayPolicy marks ReplayPolicy as intentionally set (including ReplayInstant).
	HasReplayPolicy bool
}

type FetchOpt func(*fetchConfig)

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

type IncidentEvent struct {
	Time       time.Time    `json:"time"`
	Detail     string       `json:"detail,omitempty"`
	Subject    string       `json:"subject,omitempty"`
	Stream     string       `json:"stream,omitempty"`
	Consumer   string       `json:"consumer,omitempty"`
	Reason     string       `json:"reason,omitempty"`
	Err        string       `json:"err,omitempty"`
	Sequence   uint64       `json:"sequence,omitempty"`
	NumPending uint64       `json:"num_pending,omitempty"`
	Attempt    int          `json:"attempt,omitempty"`
	Kind       IncidentKind `json:"kind"`
}

type IncidentKind uint8

type KVBucketStatus struct {
	Bucket  string
	Values  uint64
	History int64
}

type KVEntry struct {
	Created  time.Time
	Bucket   string
	Key      string
	Value    []byte
	Revision uint64
}

type KeyValueConfig struct {
	Bucket      string
	Description string
	TTL         time.Duration
	MaxBytes    int64
	Storage     StorageType
	Replicas    int
	History     uint8 // defaults to 1 when zero
	Compression bool
}

type KeyValueKeys interface {
	ListKeys(ctx context.Context, bucket string, offset, limit int) ([]string, int, error)
	Get(ctx context.Context, bucket, key string) (*KVEntry, error)
	Put(ctx context.Context, bucket, key string, value []byte) (*KVEntry, error)
	DeleteKey(ctx context.Context, bucket, key string) error
	History(ctx context.Context, bucket, key string) ([]KVEntry, error)
}

type KeyValueManager interface {
	CreateOrUpdate(ctx context.Context, cfg KeyValueConfig) (natspkg.KeyValue, error)
	CreateRaw(ctx context.Context, cfg *natspkg.KeyValueConfig) (KVBucketStatus, error)
	Open(ctx context.Context, bucket string) (natspkg.KeyValue, error)
	Delete(ctx context.Context, bucket string) error
	ListBuckets(ctx context.Context) ([]KVBucketStatus, error)
	BucketInfo(ctx context.Context, bucket string) (KVBucketStatus, error)
}

type Message struct {
	Data   any
	Header map[string][]string
	// Expect applies optimistic concurrency PubOpts (ExpectedStream / LastSeq / LastMsgId).
	Expect      *PublishExpectation
	MessageType MessageType
}

type MessageType int

type MetricsConfig struct {
	Prefix           string
	TrackedStreams   []string
	TrackedConsumers []TrackedConsumer
	CollectInterval  time.Duration
	AllowMetrics     bool
	AllowTracing     bool
	// Lite registers only publish/consume/ack counters (skips JetStream gauges and RTT).
	Lite bool
	// FixedCardinality records hot-path metrics without per-subject attributes.
	FixedCardinality bool
}

type Monitoring interface {
	// Fetch GETs baseURL+path. baseURL is the per-cluster monitoring root
	// (e.g. http://127.0.0.1:8222); path is typically "/jsz" or "/varz".
	Fetch(ctx context.Context, baseURL, path string) ([]byte, error)
}

type MsgHandler func(context.Context, *natspkg.Msg) error

type MsgRangeOpt func(*msgRangeConfig)

type ObjectBucketStatus struct {
	Bucket      string
	Description string
	Size        uint64
}

type ObjectEntry struct {
	Modified time.Time
	Bucket   string
	Name     string
	Data     []byte
	Size     uint64
}

type ObjectStoreConfig struct {
	Bucket      string
	Description string
	TTL         time.Duration
	MaxBytes    int64
	Storage     StorageType
	Replicas    int
}

type ObjectStoreManager interface {
	ListBuckets(ctx context.Context) ([]ObjectBucketStatus, error)
	Create(ctx context.Context, cfg ObjectStoreConfig) (ObjectBucketStatus, error)
	CreateRaw(ctx context.Context, cfg *natspkg.ObjectStoreConfig) (ObjectBucketStatus, error)
	BucketInfo(ctx context.Context, bucket string) (ObjectBucketStatus, error)
	Delete(ctx context.Context, bucket string) error
	ListObjects(ctx context.Context, bucket string, offset, limit int) ([]string, int, error)
	Get(ctx context.Context, bucket, name string) (*ObjectEntry, error)
	Put(ctx context.Context, bucket, name string, data []byte) (*ObjectEntry, error)
	DeleteObject(ctx context.Context, bucket, name string) error
}

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

type ProcessOpt func(*processConfig)

type PubAck = natspkg.PubAck

type PubAckFuture = natspkg.PubAckFuture

type PublishExpectation struct {
	LastSeq           *uint64
	LastSeqPerSubject *uint64
	Stream            string
	LastMsgID         string
}

type Publisher interface {
	PublishMessage(ctx context.Context, subject string, msg Message) error
	PublishProto(ctx context.Context, subject string, payload proto.Message) error
	PublishJSON(ctx context.Context, subject string, data any) error
	PublishMsgPack(ctx context.Context, subject string, data any) error
	PublishBytes(ctx context.Context, subject string, data []byte) error
	PublishBytesWithMsgID(ctx context.Context, subject, id string, data []byte) error
	PublishWithMsgID(ctx context.Context, subject, id string, msg Message) error
	PublishAsync(ctx context.Context, subject string, msg Message) (PubAckFuture, error)
	PublishAsyncBytes(ctx context.Context, subject string, data []byte) (PubAckFuture, error)
	PublishAsyncComplete(ctx context.Context) error
}

type PublisherConfig struct {
	MetricPrefix string
	AllowMetrics bool
	AllowTracing bool
	// SkipSubjectValidation skips per-publish subject validation for trusted static subjects.
	SkipSubjectValidation bool
	// MaxAsyncPending caps in-flight PublishAsync requests (0 = defaultMaxAsyncPending, -1 = unlimited).
	MaxAsyncPending int
}

type PullConsumer interface {
	Fetch(ctx context.Context, batch int, opts ...FetchOpt) ([]*natspkg.Msg, error)
	FetchNoWait(batch int) ([]*natspkg.Msg, error)
	Process(ctx context.Context, handler MsgHandler, opts ...ProcessOpt) error
}

type PurgeOpt func(*natspkg.StreamPurgeRequest)

type Replay interface {
	// ResetConsumer seeks an existing durable to a new deliver position while
	// preserving ack limits, filters, and other consumer settings when present.
	ResetConsumer(ctx context.Context, stream, durable string, opts ...ReplayOpt) (ReplayConsumerResult, error)
	// CreateReplayConsumer creates a side-car durable for backfill. The live
	// sourceDurable is left untouched. When WithReplayDurable is omitted, a
	// unique name is generated from sourceDurable.
	CreateReplayConsumer(ctx context.Context, stream, sourceDurable string, opts ...ReplayOpt) (ReplayConsumerResult, error)
	GetMsg(ctx context.Context, stream string, seq uint64) (*StoredMessage, error)
	GetLastMsgForSubject(ctx context.Context, stream, subject string) (*StoredMessage, error)
	GetNextMsgAfter(ctx context.Context, stream string, seq uint64) (*StoredMessage, error)
	GetMsgRange(ctx context.Context, stream string, startSeq, endSeq uint64, opts ...MsgRangeOpt) ([]*StoredMessage, bool, error)
	GetMsgRangeByTime(ctx context.Context, stream string, start, end time.Time, opts ...MsgRangeOpt) ([]*StoredMessage, bool, error)
	FindFirstSeqAtOrAfter(ctx context.Context, stream string, t time.Time) (uint64, error)
	FindLastSeqAtOrBefore(ctx context.Context, stream string, t time.Time) (uint64, error)
}

type ReplayConfig struct {
	OptStartTime   *time.Time
	UntilTime      *time.Time
	Durable        string // target durable for CreateReplayConsumer; ignored by ResetConsumer
	FilterSubject  string
	FilterSubjects []string
	DeliverPolicy  DeliverPolicy
	ReplayPolicy   ReplayPolicy
	OptStartSeq    uint64
	UntilSeq       uint64
	Limit          int
	// contains filtered or unexported fields
}

type ReplayConsumerResult struct {
	StartTime *time.Time
	UntilTime *time.Time
	Durable   string
	StartSeq  uint64
	UntilSeq  uint64
	Limit     int
}

type ReplayOpt func(*ReplayConfig)

type ReplayPolicy = natspkg.ReplayPolicy

type Requester interface {
	RequestBytes(ctx context.Context, subject string, data []byte) (*natspkg.Msg, error)
	RequestMessage(ctx context.Context, subject string, msg Message) (*natspkg.Msg, error)

	RequestJSON(ctx context.Context, subject string, req any) (*natspkg.Msg, error)
	RequestJSONInto(ctx context.Context, subject string, req, resp any) error

	RequestMsgPack(ctx context.Context, subject string, req any) (*natspkg.Msg, error)
	RequestMsgPackInto(ctx context.Context, subject string, req, resp any) error

	RequestProto(ctx context.Context, subject string, req proto.Message) (*natspkg.Msg, error)
	RequestProtoInto(ctx context.Context, subject string, req, resp proto.Message) error
}

type RequesterConfig struct {
	MetricPrefix string
	// Timeout is used when ctx has no deadline (0 = defaultRequestTimeout).
	Timeout      time.Duration
	AllowMetrics bool
	AllowTracing bool
	// SkipSubjectValidation skips per-request subject validation for trusted static subjects.
	SkipSubjectValidation bool
}

type Responder interface {
	Subscribe(ctx context.Context, subject string, handler MsgHandler) (Subscription, error)
	QueueSubscribe(ctx context.Context, queue, subject string, handler MsgHandler) (Subscription, error)
}

type ResponderConfig struct {
	MetricPrefix string
	AllowMetrics bool
	AllowTracing bool
}

type RetentionPolicy = natspkg.RetentionPolicy

type RuntimeConsumerConfig struct {
	MetricPrefix     string
	PendingMsgLimit  int
	PendingMsgBuffer int
	WorkerPoolSize   int
	WorkerBufferSize int
	AckWait          time.Duration
	// IdleHeartbeat enables JetStream idle heartbeats on non-queue push
	// subscriptions (and defaults pull Process heartbeats). 0 disables.
	// Queue groups do not support idle heartbeat (nats.go limitation).
	IdleHeartbeat     time.Duration
	WorkerPoolEnabled bool
	// FlowControl enables JetStream flow control on non-queue push when
	// IdleHeartbeat > 0. Pair with IdleHeartbeat (recommended by nats.go).
	FlowControl  bool
	AllowMetrics bool
	AllowTracing bool
}

type ShadowConfig struct {
	// Compare returns true when primary and shadow outcomes match.
	// If nil, outcomes match when both succeed or both fail (nil-ness only).
	Compare func(primaryErr, shadowErr error) bool
	// Recorder receives IncidentShadow events on panic / mismatch (optional).
	Recorder *FlightRecorder

	// SampleRate is the fraction of messages sent to the shadow in (0,1].
	// Zero (default) means 0.1 (10% canary). Set explicitly to 1 for always-on dual-run.
	SampleRate float64
	// contains filtered or unexported fields
}

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

type SlowConsumerConfig struct {
	OnSlow func(SlowConsumerEvent)
	// PollInterval is how often ConsumerInfo is polled (default 2s).
	PollInterval time.Duration
	// SustainFor is how long thresholds must hold before firing (default 30s).
	SustainFor time.Duration
	// PendingThreshold fires when NumPending >= this value (default 1000).
	PendingThreshold uint64
	// LagThreshold fires when stream tip − delivered stream seq >= this value (default 1000).
	LagThreshold uint64
	// AckPendingRatio fires when NumAckPending >= ratio * MaxAckPending (default 0.9).
	// Ignored when MaxAckPending <= 0.
	AckPendingRatio float64
	// CircuitStop stops the watcher after the first slow event.
	CircuitStop bool
}

type SlowConsumerEvent struct {
	Stream        string
	Durable       string
	Reasons       []string
	Pending       uint64
	Lag           uint64
	AckPending    int
	MaxAckPending int
	SustainedFor  time.Duration
}

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

type SoftLivenessConfig struct {
	OnStall func(SoftLivenessEvent)
	// PollInterval is how often ConsumerInfo is polled (default 2s).
	PollInterval time.Duration
	// StallAfter is the minimum time since last successful process before a stall can fire (default 10s).
	StallAfter time.Duration
	// RisingWindows is consecutive polls with rising NumPending required (default 3).
	RisingWindows int
	// CircuitStop stops the watcher after the first stall (apps may then restart the pod).
	CircuitStop bool
}

type SoftLivenessEvent struct {
	Err        error
	NumPending uint64
	StalledFor time.Duration
}

type StorageType = natspkg.StorageType

type StoredMessage struct {
	Time        time.Time
	Header      map[string][]string
	Subject     string
	Data        []byte
	Sequence    uint64
	MessageType MessageType
}

type StreamConfig struct {
	// Mirror configures this stream as a mirror of another stream (geo / DR).
	// Prefer nats CLI or platform ops for complex cross-domain setups; see devops.md.
	Mirror      *StreamSource
	Name        string
	Description string
	Subjects    []string
	// Sources aggregates messages from other streams into this stream.
	Sources         []*StreamSource
	Storage         StorageType
	MaxBytes        int64
	MaxAge          time.Duration
	MaxMsgs         int64
	Discard         DiscardPolicy
	DuplicateWindow time.Duration
	MaxConsumers    int
	Retention       RetentionPolicy
	Replicas        int
	MaxMsgSize      int32
	NoAck           bool
}

type StreamLastSeqFunc func(ctx context.Context, stream string) (uint64, error)

type StreamManager interface {
	CreateOrUpdateStream(ctx context.Context, cfg StreamConfig) (*natspkg.StreamInfo, error)
	AddStream(ctx context.Context, cfg *natspkg.StreamConfig) (*natspkg.StreamInfo, error)
	UpdateStream(ctx context.Context, cfg *natspkg.StreamConfig) (*natspkg.StreamInfo, error)
	DeleteStream(ctx context.Context, name string) error
	StreamInfo(ctx context.Context, name string) (*natspkg.StreamInfo, error)
	ListStreamsPage(ctx context.Context, offset, limit int) ([]*natspkg.StreamInfo, int, error)
	PurgeStream(ctx context.Context, name string, opts ...PurgeOpt) error
	GetMsg(ctx context.Context, stream string, seq uint64) (*natspkg.RawStreamMsg, error)
	GetLastMsg(ctx context.Context, stream, subject string) (*natspkg.RawStreamMsg, error)
	GetNextMsgAfter(ctx context.Context, stream string, seq uint64) (*natspkg.RawStreamMsg, error)
}

type StreamSource = natspkg.StreamSource

type SubscribeFn func(ctx context.Context) (Subscription, error)

type Subscription interface {
	Unsubscribe() error
	Drain() error
	IsValid() bool
	Subject() string
	SetPendingLimits(msgLimit, bytesLimit int) error
	ConsumerInfo() (*natspkg.ConsumerInfo, error)
	Type() natspkg.SubscriptionType
}

type SupervisedSubscription interface {
	Subscription
	Events() <-chan SupervisorEvent
	Stop() error
}

type SupervisorConfig struct {
	OnEvent        func(SupervisorEvent)
	InitialBackoff time.Duration
	MaxBackoff     time.Duration
	CheckInterval  time.Duration
	// HealthyBackoffInterval is the maximum poll interval after consecutive healthy checks (0 disables).
	HealthyBackoffInterval time.Duration
	// HealthyChecksBeforeBackoff is the number of healthy checks before increasing the poll interval.
	HealthyChecksBeforeBackoff int
	// MaxRetries is resubscribe attempts after interest is lost.
	// 0 means default (10). -1 means unlimited.
	MaxRetries int
}

type SupervisorEvent struct {
	Err     error
	Kind    SupervisorEventKind
	Attempt int
}

type SupervisorEventKind uint8

type TrackedConsumer struct {
	Stream  string
	Durable string
}

type WorkerSetup struct {
	Queue    string
	Subject  string
	Stream   StreamConfig
	Consumer DurableConsumerConfig
}