theta

type CloudWatchHandler struct {
	EventHandler EventHandler
}

type CompositeEventHandler []EventHandler

type DictionaryEventHandler map[string]EventHandler

type DynamoHandler struct {
	EventEncoder EventEncoder
	EventHandler EventHandler
}

type Event struct {
	ID        string    `json:"id" validate:"required"`
	Name      string    `json:"name" validate:"required"`
	Source    string    `json:"source" validate:"required"`
	Sender    string    `json:"sender" validate:"required"`
	Timestamp time.Time `json:"timestamp" validate:"required"`
}

type EventArgs struct {
	Event *Event          `json:"event" validate:"required"`
	Meta  Metadata        `json:"meta" validate:"-"`
	Body  json.RawMessage `json:"body" validate:"required"`
}

type EventDecoder interface {
	Decode([]byte, interface{}) error
}

type EventEncoder interface {
	Encode(interface{}) ([]byte, error)
}

type EventHandler interface {
	// HandleContext handles event
	HandleContext(ctx context.Context, args *EventArgs) error
}

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

type GatewayHandlerAuth struct {
	// Credentials keeps a map of the registered credentials
	Config *GatewayHandlerAuthConfig
}

type GatewayHandlerAuthConfig struct {
	Users []*GatewayHandlerAuthUserConfig
}

type GatewayHandlerAuthUserConfig struct {
	Name     string
	Password string
}

type GatewayInterceptor func(http.Handler) http.Handler

type GatewayRoute interface {
	Mount(r chi.Router)
}

type KinesisClient = kinesisiface.KinesisAPI

type KinesisCollector struct {
	Scanner      KinesisScanner
	EventHandler EventHandler
	EventDecoder EventDecoder
	Cancel       context.CancelFunc
}

type KinesisCollectorConfig struct {
	RoleArn      string
	Region       string
	StreamName   string
	Options      []KinesisCollectorOption
	EventHandler EventHandler
}

type KinesisCollectorOption = consumer.Option

type KinesisCollectorStore = consumer.Store

type KinesisDispatcher struct {
	StreamName string
	Client     KinesisClient
}

type KinesisDispatcherConfig struct {
	RoleArn    string
	Region     string
	StreamName string
}

type KinesisHandler struct {
	EventHandler EventHandler
	EventDecoder EventDecoder
}

type KinesisRecord = consumer.Record

type KinesisScanFunc = consumer.ScanFunc

type KinesisScanner interface {
	Scan(ctx context.Context, fn KinesisScanFunc) error
}

type Metadata map[string]string

type SQSClient = sqsiface.SQSAPI

type SQSDispatcher struct {
	// QueueURL address
	QueueURL string
	// Clinet for the SQS
	Client SQSClient
}

type SQSHandler struct {
	EventHandler EventHandler
}

type XrayEventHandler struct {
	Segment      string
	Metadata     map[string]interface{}
	EventHandler EventHandler
}