amqp1

type Attach struct {
	Source               *Source
	Target               *Target
	Properties           Map
	Name                 string
	OfferedCapabilities  []Symbol
	DesiredCapabilities  []Symbol
	MaxMessageSize       uint64
	Handle               uint32
	InitialDeliveryCount uint32
	SndSettleMode        uint8
	RcvSettleMode        uint8
	Role                 bool
}

type AttachReplier interface {
	ReplyAttach(reply *Attach)
}

type Begin struct {
	RemoteChannel  *uint16
	NextOutgoingID uint32
	IncomingWindow uint32
	OutgoingWindow uint32
	HandleMax      uint32
}

type Close struct{ Error *Error }

type Config struct {
	Handler        Handler
	TLS            *tls.Config
	Logger         *slog.Logger
	ContainerID    string
	MaxFrameSize   uint32
	MaxMessageSize uint64
}

type ConnHandler interface {
	// AttachSender is called when the peer opens a receiving link; the server
	// then sends messages from the returned endpoint.
	AttachSender(a *Attach) (SenderEndpoint, *Error)
	// AttachReceiver is called when the peer opens a sending link; the server
	// then receives messages into the returned endpoint.
	AttachReceiver(a *Attach) (ReceiverEndpoint, *Error)
	// Close releases connection state.
	Close()
}

type DeferredAttach interface {
	Ready(ctx context.Context) *Error
}

type DeliveryState struct {
	Error             *Error
	Kind              uint64
	DeliveryFailed    bool
	UndeliverableHere bool
}

type Described struct {
	Descriptor any
	Value      any
}

type Detach struct {
	Error  *Error
	Handle uint32
	Closed bool
}

type Disposition struct {
	Last    *uint32
	State   *DeliveryState
	First   uint32
	Role    bool
	Settled bool
}

type End struct{ Error *Error }

type Error struct {
	Info        Map
	Condition   Symbol
	Description string
}

type Flow struct {
	NextIncomingID *uint32
	Handle         *uint32
	DeliveryCount  *uint32
	LinkCredit     *uint32
	IncomingWindow uint32
	NextOutgoingID uint32
	OutgoingWindow uint32
	Drain          bool
	Echo           bool
}

type Frame struct {
	Body    []byte
	Channel uint16
	Type    byte
}

type Handler interface {
	// Authenticate validates SASL credentials. ANONYMOUS passes empty strings.
	Authenticate(mechanism Symbol, username, password string) bool
	// NewConn creates the per-connection handler.
	NewConn() ConnHandler
}

type Header struct {
	TTL           time.Duration
	DeliveryCount uint32
	Priority      uint8
	Durable       bool
	FirstAcquirer bool
}

type Incoming struct {
	Tag     []byte
	Payload []byte
	Format  uint32
	Settled bool
}

type List []any

type Map map[any]any

type Message struct {
	Header                *Header
	Properties            *Properties
	DeliveryAnnotations   Map
	Annotations           Map
	ApplicationProperties Map
	Footer                Map
	Value                 any
	Data                  [][]byte
	Sequence              []List
	HasValue              bool
}

type Open struct {
	Properties          Map
	ContainerID         string
	Hostname            string
	OfferedCapabilities []Symbol
	MaxFrameSize        uint32
	IdleTimeout         uint32
	ChannelMax          uint16
}

type Outgoing struct {
	Ref     any
	Tag     []byte
	Payload []byte
	Format  uint32
	Settled bool
}

type Performative interface {
	// contains filtered or unexported methods
}

type Properties struct {
	AbsoluteExpiryTime time.Time
	CreationTime       time.Time
	MessageID          any
	CorrelationID      any
	Subject            string
	To                 string
	ReplyTo            string
	ContentType        string
	ContentEncoding    string
	GroupID            string
	ReplyToGroupID     string
	UserID             []byte
	GroupSequence      uint32
}

type ReceiverEndpoint interface {
	// Deliver handles one message and returns the outcome to report.
	Deliver(ctx context.Context, in *Incoming) DeliveryState
	// Close is called once when the link ends.
	Close()
}

type SASLInit struct {
	Mechanism       Symbol
	Hostname        string
	InitialResponse []byte
}

type SASLMechanisms struct{ Mechanisms []Symbol }

type SASLOutcome struct{ Code uint8 }

type SenderEndpoint interface {
	// Next blocks until a message is available or ctx is done.
	Next(ctx context.Context) (*Outgoing, error)
	// Settle records the peer's outcome for a sent message.
	Settle(o *Outgoing, st DeliveryState)
	// Release returns an unsettled message when its link or connection ends.
	Release(o *Outgoing)
	// Close is called once when the link ends.
	Close()
}

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

type SettleGuard interface {
	SettleError(o *Outgoing) *Error
}

type Source struct {
	Filter       Map
	Address      string
	Capabilities []Symbol
	Timeout      uint32
	Durable      uint32
	Dynamic      bool
}

type Symbol string

type Target struct {
	Address      string
	Capabilities []Symbol
	Timeout      uint32
	Durable      uint32
	Dynamic      bool
}

type Transfer struct {
	DeliveryID    *uint32
	MessageFormat *uint32
	State         *DeliveryState
	DeliveryTag   []byte
	Payload       []byte
	Handle        uint32
	Settled       bool
	More          bool
	Aborted       bool
}

type UUID [16]byte