events

type Consumer struct {
	// ID is the ID of the consumer.
	ID string
}

type ConsumerConfig struct {
	// Name of the consumer. If empty, an ephemeral consumer will be created.
	Name string
	// Stream to consume events from. Must be specified and should be created
	// using Manager.EnsureStream().
	Stream string
	// Subjects to consume events from. At least one subject must be specified,
	// and multiple subjects are supported from NATS 2.10+.
	Subjects []string

	// Timeout is the timeout for processing an event. If not specified, the
	// default timeout of 30 seconds will be used.
	Timeout time.Duration

	// MaxDeliveryAttempts is the maximum number of times an event will be
	// delivered before it is considered failed.
	MaxDeliveryAttempts uint

	// From describes where to start consuming from. If not specified, the
	// default policy is to only consume new events.
	From *StreamPointer
}

type DiscardPolicy int

type Event struct {

	// Context is the context of this event. It will be valid until the event
	// expires, is acknowledged or rejected.
	Context context.Context

	// Subject is the subject the event was published to.
	Subject string

	// ConsumerSeq is the sequence number of the event.
	ConsumerSeq uint64

	// StreamSeq is the sequence number of the event in the event stream. Can
	// be used for resuming from a certain point in time. For example with an
	// ephemeral consumer, the consumer can store the last seen StreamSeq and
	// resume from there on the next run.
	StreamSeq uint64

	// DeliveryAttempt is the number of times the event has been delivered to
	// a consumer. The first delivery is 1.
	DeliveryAttempt uint64

	// Headers contains the headers of the event.
	Headers *Headers

	// Data is the protobuf message published by the producer.
	Data *anypb.Any
	// contains filtered or unexported fields
}

type EventConsumeConfig struct {
	// Stream is the name of the stream to consume events from.
	Stream string
	// Name is the name of the consumer to consume events from.
	Name string
	// MaxPendingEvents is the maximum number of events that can be pending
	// before the consumer will stop receiving events. If set to 0, a default
	// value of 50 will be used.
	MaxPendingEvents uint
}

type Events struct {

	// Timeout is the timeout for processing an event. Will be fetched
	// from the consumer configuration.
	Timeout time.Duration
	// contains filtered or unexported fields
}

type Headers struct {
	// PublishedAt is the time the event was published by the producer.
	PublishedAt time.Time
	// IdempotencyKey is the idempotency key of the event. An idempotency key
	// is used to ensure that an event is only published once. May be empty.
	IdempotencyKey *string
	// TraceParent is the trace parent of the event. May be empty.
	TraceParent *string
	// TraceState is the trace state of the event. May be empty.
	TraceState *string
}

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

type PublishConfig struct {
	// Subject to publish event to
	Subject string
	// Data to publish
	Data *anypb.Any
	// ExpectedSubjectSeq is the expected sequence number of the subject.
	ExpectedSubjectSeq *uint64
	// PublishedTime is the time the event was published. If nil, the current time will be used.
	PublishedTime *time.Time
	// IdempotencyKey is the idempotency key for the event. If empty, the event will not be idempotent.
	IdempotencyKey string
}

type PublishedEvent struct {
	// ID is the sequence number of the event.
	ID uint64
}

type StorageType int

type Stream struct{}

type StreamConfig struct {
	// Name of the stream.
	Name string

	// MaxAge is the maximum age of a message before it is considered stale.
	MaxAge time.Duration
	// MaxMsgs is the maximum number of messages to retain in the stream.
	MaxMsgs uint
	// MaxBytes is the maximum number of bytes to retain in the stream.
	MaxBytes uint
	// MaxMsgsPerSubject is the maximum number of messages to retain per subject.
	MaxMsgsPerSubject uint

	// DiscardPolicy controls the policy for discarding messages when the
	// stream reaches its maximum size.
	DiscardPolicy DiscardPolicy
	// DiscardNewPerSubject controls whether the discard policy applies to
	// each subject individually, or to the stream as a whole. Only used when
	// DiscardPolicy is set to DiscardPolicy.New.
	DiscardNewPerSubject bool

	// Subjects that the stream will receive events from.
	Subjects []string
	// Mirror makes it so this stream mirrors messages from another stream.
	Mirror *StreamSource
	// Sources is a list of streams to receive events from.
	Sources []*StreamSource

	// StorageType is the type of storage to use for the stream.
	StorageType StorageType
	// Replicas is the number of replicas to keep of the stream.
	Replicas *uint

	// DeduplicationWindow is the amount of time to keep idempotency keys.
	DeduplicationWindow *time.Duration
	// MaxEventSize is the maximum size of an event.
	MaxEventSize *uint
}

type StreamPointer struct {
	// ID is the ID of the message to start consuming from.
	ID uint64
	// Time is the time to start consuming from.
	Time time.Time
	// First indicates that the consumer should start consuming from the
	// first message in the stream.
	First bool
}

type StreamSource struct {
	// Name of the stream to mirror.
	Name string
	// From is the position in the stream to start mirroring from.
	From *StreamPointer
	// FilterSubjects is a list of subjects to filter messages from.
	FilterSubjects []string
}

type ZapConsumerConfig jetstream.ConsumerConfig

type ZapStreamConfig jetstream.StreamConfig

type ZapStreamSource jetstream.StreamSource