common

type DispatchMode string

type DispatchStatus string

type EnhancedPoolMetrics struct {
	TotalSuccess     uint64 `json:"totalSuccess"`
	TotalFailure     uint64 `json:"totalFailure"`
	TotalRateLimited uint64 `json:"totalRateLimited"`
	// TotalSuppressed counts messages ACKed without delivery because their
	// group was suppressed by the GroupFlushRegistry (R-53). Kept separate
	// from TotalSuccess/TotalFailure: no delivery was attempted, so neither
	// bucket fits, and a pool suppressing a flushed group should read
	// busy-but-suppressed rather than idle.
	TotalSuppressed uint64                `json:"totalSuppressed"`
	SuccessRate     float64               `json:"successRate"`
	ProcessingTime  ProcessingTimeMetrics `json:"processingTime"`
	Last5Min        WindowedMetrics       `json:"last5Min"`
	Last30Min       WindowedMetrics       `json:"last30Min"`
}

type InFlightMessage struct {
	MessageID       string
	BrokerMessageID string
	PoolCode        string
	QueueIdentifier string
	StartedAt       time.Time
	// LastSeenAt is refreshed every time the broker redelivers this message
	// (receipt-handle swap). The reaper ages entries on LastSeenAt, not
	// StartedAt: while the broker still holds the message it keeps
	// redelivering (refreshing this), so a long-buffered entry is never
	// reaped out from under the dedup; once the broker no longer has the
	// message, refreshes stop and the entry ages out.
	LastSeenAt     time.Time
	MessageGroupID string
	BatchID        string
	ReceiptHandle  string
	// DeferredUntil is set while the router has handed this copy back to the
	// broker for capacity (Pool.deferMsg) and expects it to return at about
	// this time. The entry is KEPT, not removed, so that a second copy of the
	// same message id published meanwhile — the platform's stale-QUEUED
	// recovery republishes a job whose message is parked longer than its
	// stale threshold, with a fresh broker id — is recognised as a duplicate
	// and deleted instead of being deferred alongside it (owner, 2026-09-22:
	// "500 in flight but only 200 pending — use the messageId, not the SQS
	// id"). Zero while the copy is in the pipeline.
	DeferredUntil time.Time
	// Attempts is >0 once the message has failed at least once and is being
	// retried in-pipeline. The stall detector never force-NACKs such an entry
	// (a live retry owns it, and yanking it away would double-deliver), and
	// the reaper exempts it from the idle bound — but only for as long as
	// LastRetryAt says that retry is still live.
	Attempts uint
	// LastRetryAt is when this entry last recorded a new in-pipeline attempt
	// (InFlightTracker.MarkRetrying, the single mutator of Attempts). It is
	// what makes the reaper's Attempts>0 exemption FINITE.
	//
	// The exemption used to be unconditional, on the reasoning that the retry
	// budget (maxInPipelineAttempts) always ends in a release that removes the
	// entry. A drainer cancelled mid-retry never reaches that release — it
	// re-fronts the message, clears the group's working flag and returns — so
	// the entry outlived its owner and, being permanently exempt, could never
	// be reaped. Every subsequent redelivery of the message was then dropped
	// as a duplicate of a copy nobody owned, for ever.
	//
	// Zero while Attempts is 0.
	LastRetryAt time.Time
}

type LeaderElectionConfig struct {
	Enabled                  bool
	RedisURL                 string
	LockKey                  string
	LockTTLSeconds           uint64
	HeartbeatIntervalSeconds uint64
	InstanceID               string
}

type MediationOutcome struct {
	Result       MediationResult
	DelaySeconds int // 0 if no delay
	StatusCode   int // 0 if not from HTTP
	ErrorMessage string

	// FlushGroup is set when a 2xx body carried {"flushGroup": true}: the
	// target is asking us to stop delivering this message's group and just
	// ACK its siblings. DelaySeconds carries how long to suppress for.
	// Honoured only alongside a successful delivery — a target that wants
	// the message back cannot also discard the group.
	FlushGroup bool

	// PreFlight marks an outcome decided BEFORE any request went out — an
	// unsupported mediation type, an unusable target URL, a payload that would
	// not marshal. Such an outcome is no evidence about the target's health in
	// either direction, so the circuit breaker must ignore it. Recording one as
	// a success actively masks a failing endpoint: a misconfigured URL would
	// hold the breaker closed on a host that is down.
	//
	// Set only by PreFlightError, so it cannot be forgotten at a call site.
	PreFlight bool
}

type MediationResult int

type MediationType string

type Message struct {
	ID              string        `json:"id"`
	PoolCode        string        `json:"poolCode,omitempty"`
	AuthToken       *string       `json:"authToken,omitempty"`
	SigningSecret   *string       `json:"signingSecret,omitempty"`
	MediationType   MediationType `json:"mediationType"`
	MediationTarget string        `json:"mediationTarget"`
	MessageGroupID  *string       `json:"messageGroupId,omitempty"`
	HighPriority    bool          `json:"highPriority,omitempty"`
	DispatchMode    DispatchMode  `json:"dispatchMode,omitempty"`
}

type OutboxItemType string

type OutboxStatus int

type PoolConfig struct {
	Code               string  `json:"code"`
	Concurrency        uint32  `json:"concurrency"`
	RateLimitPerMinute *uint32 `json:"rateLimitPerMinute,omitempty"`
}

type ProcessingTimeMetrics struct {
	AvgMs       float64 `json:"avgMs"`
	MinMs       uint64  `json:"minMs"`
	MaxMs       uint64  `json:"maxMs"`
	P50Ms       uint64  `json:"p50Ms"`
	P95Ms       uint64  `json:"p95Ms"`
	P99Ms       uint64  `json:"p99Ms"`
	SampleCount uint64  `json:"sampleCount"`
}

type QueueConfig struct {
	Name              string `json:"queueName"`
	URI               string `json:"queueUri"`
	Connections       uint32 `json:"connections"`
	VisibilityTimeout uint32 `json:"visibilityTimeout"`
}

type QueuedMessage struct {
	Message         Message
	ReceiptHandle   string
	BrokerMessageID string // empty if not provided
	QueueIdentifier string
	// BatchID is a router-assigned grouping over messages received in the
	// same poll batch. It is set by the pool's
	// poll loop, not the broker, and is informational only.
	BatchID string
	// Attempts counts how many in-pipeline mediation attempts this delivery
	// has already had (0 on first dispatch). The pool increments it on each
	// retry so it can recognise a re-dispatch (skip re-tracking) and grow the
	// backoff. Internal-only; never crosses the wire.
	Attempts uint
}

type RouterConfig struct {
	ProcessingPools []PoolConfig  `json:"processingPools"`
	Queues          []QueueConfig `json:"queues"`
}

type StallConfig struct {
	Enabled               bool   `json:"enabled"`
	StallThresholdSeconds uint64 `json:"stallThresholdSeconds"`
	ForceNackStalled      bool   `json:"forceNackStalled"`
	ForceNackAfterSeconds uint64 `json:"forceNackAfterSeconds"`
	NackDelaySeconds      uint32 `json:"nackDelaySeconds"`
}

type WindowedMetrics struct {
	SuccessCount       uint64                `json:"successCount"`
	FailureCount       uint64                `json:"failureCount"`
	RateLimitedCount   uint64                `json:"rateLimitedCount"`
	SuccessRate        float64               `json:"successRate"`
	ThroughputPerSec   float64               `json:"throughputPerSec"`
	ProcessingTime     ProcessingTimeMetrics `json:"processingTime"`
	WindowStart        time.Time             `json:"windowStart"`
	WindowDurationSecs uint64                `json:"windowDurationSecs"`
}