notification

type BalanceThreshold = api.NotificationRuleBalanceThresholdValue

type BalanceThresholdPayload struct {
	EntitlementValuePayloadBase

	Threshold api.NotificationRuleBalanceThresholdValue `json:"threshold"`
}

type BalanceThresholdRuleConfig struct {
	// Features store the list of features the rule is associated with.
	Features []string `json:"features"`
	// Thresholds store the list of thresholds used to trigger a new notification event if the balance exceeds one of the thresholds.
	Thresholds []BalanceThreshold `json:"thresholds"`
}

type Channel struct {
	models.NamespacedID
	models.ManagedModel
	models.Annotations
	models.Metadata

	// Type of the notification channel (e.g. webhook)
	Type ChannelType `json:"type"`
	// Name of is the user provided name of the Channel.
	Name string `json:"name"`
	// Disabled defines whether the Channel is disabled or not.
	Disabled bool `json:"disabled"`
	// Config stores the actual Channel configuration specific to the Type.
	Config ChannelConfig `json:"config"`
}

type ChannelConfig struct {
	ChannelConfigMeta

	// WebHook
	WebHook WebHookChannelConfig `json:"webhook"`
}

type ChannelConfigMeta struct {
	Type ChannelType `json:"type"`
}

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

type ChannelRepository interface {
	ListChannels(ctx context.Context, params ListChannelsInput) (pagination.Result[Channel], error)
	CreateChannel(ctx context.Context, params CreateChannelInput) (*Channel, error)
	DeleteChannel(ctx context.Context, params DeleteChannelInput) error
	GetChannel(ctx context.Context, params GetChannelInput) (*Channel, error)
	UpdateChannel(ctx context.Context, params UpdateChannelInput) (*Channel, error)
}

type ChannelService interface {
	ListChannels(ctx context.Context, params ListChannelsInput) (ListChannelsResult, error)
	CreateChannel(ctx context.Context, params CreateChannelInput) (*Channel, error)
	DeleteChannel(ctx context.Context, params DeleteChannelInput) error
	GetChannel(ctx context.Context, params GetChannelInput) (*Channel, error)
	UpdateChannel(ctx context.Context, params UpdateChannelInput) (*Channel, error)
}

type ChannelType string

type CreateChannelInput struct {
	models.NamespacedModel

	// Type defines the Channel type (e.g. webhook)
	Type ChannelType
	// Name stores the user defined name of the Channel.
	Name string
	// Disabled defines whether the Channel is disabled or not. Deleted Channels are always disabled.
	Disabled bool
	// Config stores the Channel Type specific configuration.
	Config ChannelConfig
	// Metadata
	Metadata models.Metadata
	// Annotations
	Annotations models.Annotations
}

type CreateEventInput struct {
	models.NamespacedModel
	Annotations models.Annotations `json:"annotations,omitempty"`

	// Type of the notification Event (e.g. entitlements.balance.threshold)
	Type EventType `json:"type"`
	// Payload is the actual payload sent to Channel as part of the notification Event.
	Payload EventPayload `json:"payload"`
	// RuleID defines the notification Rule that generated this Event.
	RuleID string `json:"ruleId"`
	// HandlerDeduplicationHash is a hash that the handler can use to deduplicate events if needed
	HandlerDeduplicationHash string `json:"handlerDeduplicationHash"`
}

type CreateRuleInput struct {
	models.NamespacedModel

	// Type defines the Rule type (e.g. entitlements.balance.threshold)
	Type EventType
	// Name stores the user defined name of the Rule.
	Name string
	// Disabled defines whether the Rule is disabled or not. Deleted Rules are always disabled.
	Disabled bool
	// Config stores the Rule Type specific configuration.
	Config RuleConfig
	// Channels defines the list of Channels the Rule needs to send Events.
	Channels []string
	// Metadata
	Metadata models.Metadata
	// Annotations
	Annotations models.Annotations
}

type DeleteChannelInput = GetChannelInput

type DeleteRuleInput = GetRuleInput

type EntitlementResetPayload EntitlementValuePayloadBase

type EntitlementResetRuleConfig struct {
	Features []string `json:"features"`
}

type EntitlementValuePayloadBase struct {
	Entitlement api.EntitlementMetered `json:"entitlement"`
	Feature     api.Feature            `json:"feature"`
	Subject     api.Subject            `json:"subject"`
	Value       api.EntitlementValue   `json:"value"`
	Customer    api.Customer           `json:"customer"`
}

type Event struct {
	models.NamespacedID
	models.Annotations

	// Type of the notification Event (e.g. entitlements.balance.threshold)
	Type EventType `json:"type"`
	// CreatedAt Timestamp when the notification event was created.
	CreatedAt time.Time `json:"createdAt"`
	// DeliveryStatus defines the delivery status of the notification Event per Channel.
	DeliveryStatus []EventDeliveryStatus `json:"deliveryStatus"`
	// Payload is the actual payload sent to Channel as part of the notification Event.
	Payload EventPayload `json:"payload"`
	// Rule defines the notification Rule that generated this Event.
	Rule Rule `json:"rule"`
	// DeduplicationHash is a hash that the handler can use to deduplicate events if needed
	HandlerDeduplicationHash string `json:"-"`
}

type EventDeliveryAttempt struct {
	State     EventDeliveryStatusState     `json:"state"`
	Response  EventDeliveryAttemptResponse `json:"response"`
	Timestamp time.Time                    `json:"timestamp"`
}

type EventDeliveryAttemptResponse struct {
	StatusCode *int          `json:"status_code,omitempty,omitzero"`
	Body       string        `json:"body,omitzero"`
	Duration   time.Duration `json:"duration,omitempty,omitzero"`
	URL        *string       `json:"url,omitempty,omitzero"`
}

type EventDeliveryStatus struct {
	models.NamespacedID

	// EventID defines the Event identifier the EventDeliveryStatus belongs to.
	EventID string

	ChannelID string
	State     EventDeliveryStatusState
	Reason    string
	CreatedAt time.Time
	UpdatedAt time.Time

	Attempts    []EventDeliveryAttempt
	NextAttempt *time.Time

	Annotations models.Annotations
}

type EventDeliveryStatusState string

type EventDispatcher interface {
	Dispatch(ctx context.Context, event *Event) error
}

type EventHandler interface {
	EventDispatcher
	EventReconciler

	Start() error
	Close() error
}

type EventPayload struct {
	EventPayloadMeta

	// Entitlements
	BalanceThreshold *BalanceThresholdPayload `json:"balanceThreshold,omitempty"`
	EntitlementReset *EntitlementResetPayload `json:"entitlementReset,omitempty"`

	// Invoice
	Invoice *InvoicePayload `json:"invoice,omitempty"`
}

type EventPayloadMeta struct {
	Type    EventType `json:"type"`
	Version int       `json:"version,omitempty"`
}

type EventReconciler interface {
	Reconcile(ctx context.Context) error
}

type EventRepository interface {
	ListEvents(ctx context.Context, params ListEventsInput) (pagination.Result[Event], error)
	GetEvent(ctx context.Context, params GetEventInput) (*Event, error)
	CreateEvent(ctx context.Context, params CreateEventInput) (*Event, error)
	ListEventsDeliveryStatus(ctx context.Context, params ListEventsDeliveryStatusInput) (pagination.Result[EventDeliveryStatus], error)
	GetEventDeliveryStatus(ctx context.Context, params GetEventDeliveryStatusInput) (*EventDeliveryStatus, error)
	UpdateEventDeliveryStatus(ctx context.Context, params UpdateEventDeliveryStatusInput) (*EventDeliveryStatus, error)
}

type EventService interface {
	ListEvents(ctx context.Context, params ListEventsInput) (ListEventsResult, error)
	GetEvent(ctx context.Context, params GetEventInput) (*Event, error)
	CreateEvent(ctx context.Context, params CreateEventInput) (*Event, error)
	ResendEvent(ctx context.Context, params ResendEventInput) error
	ListEventsDeliveryStatus(ctx context.Context, params ListEventsDeliveryStatusInput) (ListEventsDeliveryStatusResult, error)
	GetEventDeliveryStatus(ctx context.Context, params GetEventDeliveryStatusInput) (*EventDeliveryStatus, error)
	UpdateEventDeliveryStatus(ctx context.Context, params UpdateEventDeliveryStatusInput) (*EventDeliveryStatus, error)
}

type EventType string

type FeatureMeta = api.FeatureMeta

type FeatureService interface {
	ListFeature(ctx context.Context, namespace string, features ...string) ([]feature.Feature, error)
}

type GetChannelInput models.NamespacedID

type GetEventDeliveryStatusInput struct {
	models.NamespacedID

	// EventID defines the Event identifier the EventDeliveryStatus belongs to. Must be provided if ID is empty.
	EventID string
	// ChannelID defines the Channel identifier the EventDeliveryStatus belongs to. Must be provided if ID is empty.
	ChannelID string
}

type GetEventInput models.NamespacedID

type GetRuleInput models.NamespacedID

type InvoicePayload struct {
	api.Invoice
}

type InvoiceRuleConfig struct{}

type ListChannelsInput struct {
	pagination.Page

	Namespaces      []string
	Channels        []string
	IncludeDisabled bool

	OrderBy OrderBy
	Order   sortx.Order
}

type ListChannelsResult = pagination.Result[Channel]

type ListEventsDeliveryStatusInput struct {
	pagination.Page

	// Namespaces is a list of namespaces to be used to filter the list of EventDeliveryStatus to be returned.
	Namespaces []string

	// From limits the scope fo the request by defining the earliest date to be used for lookup.
	// This filter is applied to EventDeliveryStatus.UpdatedAt field.
	From time.Time
	// To limits the scope fo the request by defining the latest date to be used for lookup.
	// This filter is applied to EventDeliveryStatus.UpdatedAt field.
	To time.Time

	// Events is a list of Event identifiers used as filter.
	Events []string
	// Channels is a list of Channel identifiers used as filter.
	Channels []string
	// State is a list of Event State used as filter.
	States []EventDeliveryStatusState
}

type ListEventsDeliveryStatusResult = pagination.Result[EventDeliveryStatus]

type ListEventsInput struct {
	pagination.Page

	Namespaces []string `json:"namespaces,omitempty"`
	Events     []string `json:"events,omitempty"`

	From time.Time `json:"from,omitempty"`
	To   time.Time `json:"to,omitempty"`

	Subjects []string `json:"subjects,omitempty"`
	Features []string `json:"features,omitempty"`

	Rules    []string `json:"rules,omitempty"`
	Channels []string `json:"channels,omitempty"`

	DeduplicationHashes []string `json:"deduplicationHashes,omitempty"`

	DeliveryStatusStates []EventDeliveryStatusState `json:"deliveryStatusStates,omitempty"`

	NextAttemptBefore time.Time `json:"nextAttemptBefore,omitempty"`

	OrderBy OrderBy
	Order   sortx.Order
}

type ListEventsResult = pagination.Result[Event]

type ListRulesInput struct {
	pagination.Page

	Namespaces      []string
	Rules           []string
	IncludeDisabled bool
	Types           []EventType
	Channels        []string

	OrderBy OrderBy
	Order   sortx.Order
}

type ListRulesResult = pagination.Result[Rule]

type NotFoundError struct {
	models.NamespacedID
}

type OrderBy string

type RawPayload map[string]any

type Repository interface {
	entutils.TxCreator

	ChannelRepository
	RuleRepository
	EventRepository
}

type ResendEventInput struct {
	models.NamespacedID

	Channels []string `json:"channels,omitempty"`
}

type Rule struct {
	models.NamespacedID
	models.ManagedModel
	models.Annotations
	models.Metadata

	// Type of the notification Rule (e.g. entitlements.balance.threshold)
	Type EventType `json:"type"`
	// Name of is the user provided name of the Rule.
	Name string `json:"name"`
	// Disabled defines whether the Rule is disabled or not.
	Disabled bool `json:"disabled"`
	// Config stores the actual Rule configuration specific to the Type.
	Config RuleConfig `json:"config"`
	// Channels stores the list of channels the Rule send notification Events to.
	Channels []Channel `json:"channels"`
}

type RuleConfig struct {
	RuleConfigMeta

	// Balance Threshold
	BalanceThreshold *BalanceThresholdRuleConfig `json:"balanceThreshold,omitempty"`
	EntitlementReset *EntitlementResetRuleConfig `json:"entitlementReset,omitempty"`

	// Invoice
	Invoice *InvoiceRuleConfig `json:"invoice,omitempty"`
}

type RuleConfigMeta struct {
	Type EventType `json:"type"`
}

type RuleRepository interface {
	ListRules(ctx context.Context, params ListRulesInput) (pagination.Result[Rule], error)
	CreateRule(ctx context.Context, params CreateRuleInput) (*Rule, error)
	DeleteRule(ctx context.Context, params DeleteRuleInput) error
	GetRule(ctx context.Context, params GetRuleInput) (*Rule, error)
	UpdateRule(ctx context.Context, params UpdateRuleInput) (*Rule, error)
}

type RuleService interface {
	ListRules(ctx context.Context, params ListRulesInput) (ListRulesResult, error)
	CreateRule(ctx context.Context, params CreateRuleInput) (*Rule, error)
	DeleteRule(ctx context.Context, params DeleteRuleInput) error
	GetRule(ctx context.Context, params GetRuleInput) (*Rule, error)
	UpdateRule(ctx context.Context, params UpdateRuleInput) (*Rule, error)
}

type Service interface {
	FeatureService

	ChannelService
	RuleService
	EventService
}

type UpdateAfterDeleteError genericError

type UpdateChannelInput struct {
	models.NamespacedID

	// Type defines the Channel type (e.g. webhook)
	Type ChannelType
	// Name stores the user-defined name of the Channel.
	Name string
	// Disabled defines whether the Channel is disabled or not. Deleted Channels are always disabled.
	Disabled bool
	// Config stores the Channel Type specific configuration.
	Config ChannelConfig
	// Metadata
	Metadata models.Metadata
	// Annotations
	Annotations models.Annotations
}

type UpdateEventDeliveryStatusInput struct {
	models.NamespacedID

	// State is the delivery state of the Event.
	State EventDeliveryStatusState
	// Reason describes the reason for the latest State transition.
	Reason string
	// Annotations
	Annotations models.Annotations
	// NextAttempt defines the next time the Event should be attempted to be delivered.
	NextAttempt *time.Time
	// Attempts is a list of delivery attempts for the Event.
	Attempts []EventDeliveryAttempt
}

type UpdateRuleInput struct {
	models.NamespacedID

	// Type defines the Rule type (e.g. entitlements.balance.threshold)
	Type EventType
	// Name stores the user defined name of the Rule.
	Name string
	// Disabled defines whether the Rule is disabled or not. Deleted Rules are always disabled.
	Disabled bool
	// Config stores the Rule Type specific configuration.
	Config RuleConfig
	// Channels defines the list of Channels the Rule needs to send Events.
	Channels []string
	// Metadata
	Metadata models.Metadata
	// Annotations
	Annotations models.Annotations
}

type WebHookChannelConfig struct {
	// CustomHeaders stores a set of HTTP headers which are applied to the outgoing webhook message.
	CustomHeaders map[string]string `json:"customHeaders,omitempty"`
	// URL is the webhook endpoint url where the messages are sent to.
	URL string `json:"url"`
	// SigningSecret defines the secret which can be used for validating the signature of the message sent
	// to the webhook endpoint.
	SigningSecret string `json:"signingSecret"`
}