protocol

type CloudEvent struct {
	ID          string
	Source      *url.URL
	SpecVersion string
	Type        string

	DataContentType string
	DataSchema      *url.URL
	Subject         string
	Time            time.Time
}

type CommandExecutor[Req any, Res any] struct {
	// contains filtered or unexported fields
}

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

type CommandExecutorOptions struct {
	Idempotent bool
	CacheTTL   time.Duration

	Concurrency uint
	Timeout     time.Duration
	ShareName   string

	TopicNamespace string
	TopicTokens    map[string]string
	Logger         *slog.Logger
}

type CommandHandler[Req any, Res any] func(
	context.Context,
	*CommandRequest[Req],
) (*CommandResponse[Res], error)

type CommandInvoker[Req any, Res any] struct {
	// contains filtered or unexported fields
}

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

type CommandInvokerOptions struct {
	ResponseTopic       func(string) string
	ResponseTopicPrefix string
	ResponseTopicSuffix string

	TopicNamespace string
	TopicTokens    map[string]string
	Logger         *slog.Logger
}

type CommandRequest[Req any] struct {
	Message[Req]

	FencingToken hlc.HybridLogicalClock
}

type CommandResponse[Res any] struct {
	Message[Res]
}

type Empty struct{}

type Encoding[T any] interface {
	ContentType() string
	PayloadFormat() byte
	Serialize(T) ([]byte, error)
	Deserialize([]byte) (T, error)
}

type InvocationError struct {
	Message       string
	PropertyName  string
	PropertyValue any
}

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

type InvokeOptions struct {
	FencingToken hlc.HybridLogicalClock

	Timeout     time.Duration
	TopicTokens map[string]string
	Metadata    map[string]string
}

type JSON[T any] struct{}

type Listener interface {
	Start(context.Context) error
	Close()
}

type Listeners []Listener

type Message[T any] struct {
	// The message payload.
	Payload T

	// The ID of the calling MQTT client.
	ClientID string

	// The data that identifies a single unique request.
	CorrelationData string

	// The timestamp of when the message was sent.
	Timestamp hlc.HybridLogicalClock

	// All topic tokens resolved from the incoming topic.
	TopicTokens map[string]string

	// Any user-provided metadata values.
	Metadata map[string]string
}

type MqttClient interface {
	ID() string
	Publish(
		context.Context,
		string,
		[]byte,
		...mqtt.PublishOption,
	) (*mqtt.Ack, error)
	RegisterMessageHandler(mqtt.MessageHandler) func()
	Subscribe(
		context.Context,
		string,
		...mqtt.SubscribeOption,
	) (*mqtt.Ack, error)
	Unsubscribe(
		context.Context,
		string,
		...mqtt.UnsubscribeOption,
	) (*mqtt.Ack, error)
}

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

type Raw struct{}

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

type RespondOptions struct {
	Metadata map[string]string
}

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

type SendOptions struct {
	CloudEvent *CloudEvent
	Retain     bool

	Timeout     time.Duration
	TopicTokens map[string]string
	Metadata    map[string]string
}

type TelemetryHandler[T any] func(context.Context, *TelemetryMessage[T]) error

type TelemetryMessage[T any] struct {
	Message[T]

	// CloudEvent will be present if the message was sent with cloud events.
	*CloudEvent

	// Ack provides a function to manually ack if enabled and if possible;
	// it will be nil otherwise. Note that, since QoS 0 messages cannot be
	// acked, this will be nil in this case even if manual ack is enabled.
	Ack func()
}

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

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

type TelemetryReceiverOptions struct {
	ManualAck bool

	Concurrency uint
	Timeout     time.Duration
	ShareName   string

	TopicNamespace string
	TopicTokens    map[string]string
	Logger         *slog.Logger
}

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

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

type TelemetrySenderOptions struct {
	TopicNamespace string
	TopicTokens    map[string]string
	Logger         *slog.Logger
}

type WithCacheTTL time.Duration

type WithConcurrency uint

type WithFencingToken hlc.HybridLogicalClock

type WithIdempotent bool

type WithManualAck bool

type WithMetadata map[string]string

type WithResponseTopic func(string) string

type WithResponseTopicPrefix string

type WithResponseTopicSuffix string

type WithRetain bool

type WithShareName string

type WithTimeout time.Duration

type WithTopicNamespace string

type WithTopicTokenNamespace string

type WithTopicTokens map[string]string