rabbitmqamqp

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

type AMQPBindingInfo struct {
}

type AmqpAddress struct {
	// the address of the AMQP server
	// it is in the form of amqp://<host>:<port>
	// or amqps://<host>:<port>
	// the port is optional
	// the default port is 5672
	// the default protocol is amqp
	// the default host is localhost
	// the default virtual host is "/"
	// the default user is guest
	// the default password is guest
	// the default SASL type is SASLTypeAnonymous
	Address string
	// Options: Additional options for the connection
	Options *AmqpConnOptions
}

type AmqpConnOptions struct {
	// wrapper for amqp.ConnOptions
	ContainerID string

	// wrapper for amqp.ConnOptions
	HostName string
	// wrapper for amqp.ConnOptions
	IdleTimeout time.Duration

	// wrapper for amqp.ConnOptions
	MaxFrameSize uint32

	// wrapper for amqp.ConnOptions
	MaxSessions uint16

	// wrapper for amqp.ConnOptions
	Properties map[string]any

	// wrapper for amqp.ConnOptions
	SASLType amqp.SASLType

	// wrapper for amqp.ConnOptions
	TLSConfig *tls.Config

	// wrapper for amqp.ConnOptions
	WriteTimeout time.Duration

	// RecoveryConfiguration is used to configure the recovery behavior of the connection.
	// when the connection is closed unexpectedly.
	RecoveryConfiguration *RecoveryConfiguration

	// TopologyRecoveryOptions is used to configure the topology recovery behavior of the connection.
	TopologyRecoveryOptions TopologyRecoveryOptions

	// The OAuth2Options is used to configure the connection with OAuth2 token.
	OAuth2Options *OAuth2Options

	// Local connection identifier (not sent to the server)
	// if not provided, a random UUID is generated
	Id string
}

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

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

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

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

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

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

type AutoGeneratedQueueSpecification struct {
	IsAutoDelete   bool
	IsExclusive    bool
	MaxLength      int64
	MaxLengthBytes int64
	Arguments      map[string]any
	// contains filtered or unexported fields
}

type BalancedLeaderLocator struct {
}

type ClassicQueueSpecification struct {
	Name                 string
	IsAutoDelete         bool
	IsExclusive          bool
	AutoExpire           int64
	MessageTTL           int64
	OverflowStrategy     IOverflowStrategy
	SingleActiveConsumer bool
	DeadLetterExchange   string
	DeadLetterRoutingKey string
	MaxLength            int64
	MaxLengthBytes       int64
	MaxPriority          int64
	LeaderLocator        ILeaderLocator
	Arguments            map[string]any
}

type ClientLocalLeaderLocator struct {
}

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

type ConsumerOptions struct {
	//ReceiverLinkName: see the IConsumerOptions interface
	ReceiverLinkName string
	//InitialCredits: see the IConsumerOptions interface
	InitialCredits int32
	// The id of the consumer
	Id string

	//
	DirectReplyTo bool
}

type CorrelationIdExtractor func(message *amqp.Message) any

type CorrelationIdSupplier interface {
	Get() any
}

type CustomExchangeSpecification struct {
	Name             string
	IsAutoDelete     bool
	ExchangeTypeName string
	Arguments        map[string]any
}

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

type DeliveryState = amqp.DeliveryState

type DirectExchangeSpecification struct {
	Name         string
	IsAutoDelete bool
	Arguments    map[string]any
}

type DropHeadOverflowStrategy struct {
}

type Endpoint struct {
	Address string
	Options *AmqpConnOptions
}

type Environment struct {
	EndPointStrategy TEndPointStrategy
	// contains filtered or unexported fields
}

type ExchangeAddress struct {
	Exchange string // The name of the exchange
	Key      string // The routing key. Can be empty
}

type ExchangeToExchangeBindingSpecification struct {
	SourceExchange      string
	DestinationExchange string
	BindingKey          string
	Arguments           map[string]any
}

type ExchangeToQueueBindingSpecification struct {
	SourceExchange   string
	DestinationQueue string
	BindingKey       string
	Arguments        map[string]any
}

type FanOutExchangeSpecification struct {
	Name         string
	IsAutoDelete bool
	Arguments    map[string]any
}

type GinkgoLogHandler struct {
	slog.Handler
	// contains filtered or unexported fields
}

type HeadersExchangeSpecification struct {
	Name         string
	IsAutoDelete bool
	Arguments    map[string]any
}

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

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

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

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

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

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

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

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

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

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

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

type OAuth2Options struct {
	Token string
}

type OffsetFirst struct {
}

type OffsetLast struct {
}

type OffsetNext struct {
}

type OffsetValue struct {
	Offset uint64
}

type PublishResult struct {
	Outcome DeliveryState
	Message *amqp.Message
}

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

type PublisherOptions struct {
	Id             string
	SenderLinkName string
}

type QueueAddress struct {
	Queue      string // The name of the queue
	Parameters string // Additional parameters not related to the queue. Most of the time it is empty
}

type QuorumQueueSpecification struct {
	Name                   string
	AutoExpire             int64
	MessageTTL             int64
	OverflowStrategy       IOverflowStrategy
	SingleActiveConsumer   bool
	DeadLetterExchange     string
	DeadLetterRoutingKey   string
	MaxLength              int64
	MaxLengthBytes         int64
	DeliveryLimit          int64
	TargetClusterSize      int64
	LeaderLocator          ILeaderLocator
	QuorumInitialGroupSize int
	Arguments              map[string]any
}

type RecoveryConfiguration struct {
	/*
		ActiveRecovery Define if the recovery is activated.
		If is not activated the connection will not try to createSender.
	*/
	ActiveRecovery bool

	/*
		BackOffReconnectInterval The time to wait before trying to createSender after a connection is closed.
		time will be increased exponentially with each attempt.
		Default is 5 seconds, each attempt will double the time.
		The minimum value is 1 second. Avoid setting a value low values since it can cause a high
		number of reconnection attempts.
	*/
	BackOffReconnectInterval time.Duration

	/*
		MaxReconnectAttempts The maximum number of reconnection attempts.
		Default is 5.
		The minimum value is 1.
	*/
	MaxReconnectAttempts int
}

type RejectPublishDlxOverflowStrategy struct {
}

type RejectPublishOverflowStrategy struct {
}

type ReplyPostProcessor func(reply *amqp.Message, correlationID any) *amqp.Message

type RequestPostProcessor func(request *amqp.Message, correlationID any) *amqp.Message

type Requester interface {
	Close(context.Context) error
	Message(body []byte) *amqp.Message
	Publish(context.Context, *amqp.Message) (<-chan *amqp.Message, error)
	GetReplyQueue() (string, error)
}

type RequesterOptions struct {
	// The name of the queue to send requests to. This queue must exist.
	//
	// Mandatory.
	RequestQueueName string
	// The name of the queue to receive replies from.
	//
	// Optional. If not set, a dedicated reply-to queue will be created for each request.
	ReplyToQueueName string
	// Generator of correlation IDs for requests. Each correlationID generated must be unique.
	//
	// Optional. If not set, a random UUID will be used as prefix and an auto-incrementing counter as suffix.
	CorrelationIdSupplier CorrelationIdSupplier
	// Function to extract correlation IDs from replies.
	//
	// Optional. If not set, the `CorrelationID` message property will be used.
	CorrelationIdExtractor CorrelationIdExtractor
	// Function to modify requests before they are sent.
	//
	// Optional. If not set, the default `RequestPostProcessor` assigns the correlation ID to the `MessageID` property.
	RequestPostProcessor RequestPostProcessor
	// The timeout for requests.
	//
	// Optional. If not set, a default timeout of 30 seconds will be used.
	RequestTimeout time.Duration

	// If true, the requester will set the 'Direct-Reply-To' feature for RabbitMQ.
	// see: https://www.rabbitmq.com/direct-reply-to.html
	DirectReplyTo bool
}

type Responder interface {
	// Close the RPC server and its underlying resources.
	Close(context.Context) error
	// Pause the server to stop receiving messages.
	Pause()
	// Unpause requests to receive messages again.
	Unpause() error

	GetRequestQueue() (string, error)
}

type ResponderHandler func(ctx context.Context, request *amqp.Message) (*amqp.Message, error)

type ResponderOptions struct {
	// RequestQueue is the name of the queue to subscribe to. This queue must be pre-declared.
	// The RPC server does not declare the queue, it is the responsibility of the caller to declare the queue.
	//
	// Mandatory.
	RequestQueue string
	// Handler is a function to process the request message. If the server wants to send a response to
	// the client, it must return a response message. If the function returns nil, the server will not send a response.
	//
	// It is encouraged to initialise the response message properties in the handler. If the handler returns a non-nil
	// error, the server will discard the request message and log an error.
	//
	// The server handler blocks until this function returns. It is highly recommended to functions that process and return quickly.
	// If you need to perform a long running operation, it's advisable to dispatch the operation to another queue.
	//
	// Example:
	// 		func(ctx context.Context, request *amqp.Message) (*amqp.Message, error) {
	// 			return amqp.NewMessage([]byte(fmt.Sprintf("Pong: %s", request.GetData()))), nil
	// 		}
	//
	// Mandatory.
	Handler ResponderHandler
	// CorrectionIdExtractor is a function that extracts a correction ID from the request message.
	// The returned value should be an AMQP type that can be binary encoded.
	//
	// This field is optional. If not provided, the server will use the `MessageID` as the correlation ID.
	//
	// Example:
	// 		func(message *amqp.Message) any {
	// 			return message.Properties.MessageID
	// 		}
	//
	// The default correlation ID extractor also handles nil cases.
	//
	// Optional.
	CorrelationIdExtractor CorrelationIdExtractor
	// PostProcessor is a function that receives the reply message and the extracted correlation ID, just before the reply is sent.
	// It can be used to modify the reply message before it is sent.
	//
	// The post processor must set the correlation ID in the reply message properties.
	//
	// This field is optional. If not provided, the server will set the correlation ID in the reply message properties, using
	// the correlation ID extracted from the CorrelationIdExtractor.
	//
	// Example:
	// 		func(reply *amqp.Message, correlationID any) *amqp.Message {
	// 			reply.Properties.CorrelationID = correlationID
	// 			return reply
	// 		}
	//
	// The default post processor also handles nil cases.
	//
	// Optional.
	ReplyPostProcessor ReplyPostProcessor
}

type StateAccepted = amqp.StateAccepted

type StateChanged struct {
	From ILifeCycleState
	To   ILifeCycleState
}

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

type StateClosing struct {
}

type StateModified = amqp.StateModified

type StateOpen struct {
}

type StateReconnecting struct {
}

type StateRejected = amqp.StateRejected

type StateReleased = amqp.StateReleased

type StreamConsumerOptions struct {
	//ReceiverLinkName: see the IConsumerOptions interface
	ReceiverLinkName string
	//InitialCredits: see the IConsumerOptions interface
	InitialCredits int32
	// The offset specification for the stream consumer
	// see the interface implementations
	Offset              IOffsetSpecification
	StreamFilterOptions *StreamFilterOptions
	Id                  string
}

type StreamFilterOptions struct {
	// Filter values.
	Values []string
	//
	MatchUnfiltered bool

	// Filter the data based on Application Property
	ApplicationProperties map[string]any

	// Filter the data based on Message Properties
	Properties *amqp.MessageProperties

	/* SQLFilter: documentation https://www.rabbitmq.com/docs/next/stream-filtering#sql-filter-expressions
	It requires RabbitMQ 4.2 or later

	Example:
	<code>
	Define a message like:
	var  msg  := NewMessage([]byte(..))
	msg.Properties = &amqp.MessageProperties{Subject: ptr("mySubject"), To: ptr("To")}
	msg.ApplicationProperties = map[string]interface{}{"filter_key": "filter_value"}

	publisher.Publish(context.Background(), msg)
	Then you can create a consumer with a SQL filter like:
	consumer, err := connection.NewConsumer(context.Background(), "myQueue", &StreamConsumerOptions{
			InitialCredits: 200,
			Offset:         &OffsetFirst{},
			StreamFilterOptions: &StreamFilterOptions{
				SQL: "properties.subject LIKE '%mySubject%' AND properties.to = 'To' AND filter_key = 'filter_value'",
			},
		})
	</code>
	*/
	SQL string
}

type StreamQueueSpecification struct {
	Name               string
	MaxLengthBytes     int64
	InitialClusterSize int
	Arguments          map[string]any
}

type TEndPointStrategy int

type TExchangeType string

type TQueueType string

type TopicExchangeSpecification struct {
	Name         string
	IsAutoDelete bool
	Arguments    map[string]any
}

type TopologyRecoveryOptions byte

type URI struct {
	Scheme   string
	Host     string
	Port     int
	Username string
	Password string
	Vhost    string
}

type Version struct {
	Major int
	Minor int
	Patch int
}