audit

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

type ActorInput struct {
	Kind ActorKind
	ID   string
	// AuthenticationMethod is empty or one of the exported
	// AuthenticationMethod constants. It records a mechanism, never a credential.
	AuthenticationMethod string
	DelegatedBy          *ActorInput
}

type ActorKind uint8

type AlertFunc func(context.Context, DeliveryAlert) error

type Alerter interface {
	Alert(context.Context, DeliveryAlert) error
}

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

type AppendOutcome uint8

type AppendResult struct {
	RecordID string
	Status   AppendStatus
}

type AppendStatus uint8

type BatchResult struct {
	Results []AppendResult
}

type BufferLimits struct {
	MaxRecords      int
	MaxBytes        int
	MaxBatchRecords int
}

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

type BuilderConfig struct {
	Clock       func() time.Time
	IDGenerator func() (string, error)
	Limits      Limits
}

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

type ChainConfig struct {
	Algorithm IntegrityAlgorithm
	Keys      KeyProvider
	Observer  Observer
}

type ChainLink struct {
	Partition      string
	Sequence       uint64
	PreviousDigest []byte
}

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

type ChangeSetInput struct {
	NoChange bool
	Redacted bool
	Before   map[string]string
	After    map[string]string
}

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

type ContextInput struct {
	TenantID, CorrelationID, CausationID, RequestID, TraceID, IdempotencyID string
	SourceService, SourceVersion, Environment, NetworkOrigin, UserAgent     string
}

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

type DeliveryAlert struct{ Outcome AppendOutcome }

type DeliveryBatchResult struct {
	Disposition DeliveryDisposition
	Append      BatchResult
}

type DeliveryDisposition uint8

type DeliveryMode uint8

type DeliveryResult struct {
	Disposition DeliveryDisposition
	Append      AppendResult
}

type DurableBuffer interface {
	Sink
	BufferLimits() BufferLimits
}

type Exporter interface {
	Export(context.Context, Query, func(Record) error) error
}

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

type IntegrityAlgorithm uint8

type IntegrityInput struct {
	Algorithm              IntegrityAlgorithm
	Partition, KeyID       string
	Sequence               uint64
	PreviousDigest, Digest []byte
}

type IntegrityKey struct {
	ID    string
	Bytes []byte
}

type KeyProvider interface {
	Key(context.Context, KeyRequest) (IntegrityKey, error)
}

type KeyProviderFunc func(context.Context, KeyRequest) (IntegrityKey, error)

type KeyRequest struct {
	Partition  string
	KeyID      string
	RecordedAt time.Time
}

type Limits struct {
	MaxRecordBytes      int
	MaxFieldBytes       int
	MaxDescriptionBytes int
	MaxAttributeEntries int
	MaxAttributeBytes   int
	MaxChangeEntries    int
	MaxChangeBytes      int
	MaxIntegrityBytes   int
}

type Observation struct {
	Kind     ObservationKind
	Count    int
	Duration time.Duration
	Outcome  AppendOutcome
}

type ObservationKind uint8

type Observer interface {
	Observe(context.Context, Observation)
}

type ObserverFunc func(context.Context, Observation)

type Outcome uint8

type Page struct {
	Records []Record
	Next    Cursor
}

type PolicyMetadata struct{ PolicyID, Version string }

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

type QueryInput struct {
	Tenant                                                           TenantScope
	From, Through                                                    time.Time
	RecordID, ActorID, SubjectType, SubjectID, Action, CorrelationID string
	Outcome                                                          Outcome
	Limit                                                            uint32
	After                                                            Cursor
}

type Reader interface {
	Query(context.Context, Query) (Page, error)
}

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

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

type RecordInput struct {
	OccurredAt                      time.Time
	Action, ReasonCode, Description string
	Outcome                         Outcome
	Actor                           ActorInput
	Subject                         SubjectInput
	Context                         ContextInput
	Changes                         ChangeSetInput
	Policy                          PolicyMetadata
	Attributes                      map[string]string
	Integrity                       IntegrityInput
}

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

type RecorderConfig struct {
	Sink            Sink
	Redactor        Redactor
	Mode            DeliveryMode
	Alerter         Alerter
	Buffer          DurableBuffer
	Observer        Observer
	Clock           func() time.Time
	DelayThreshold  time.Duration
	RecoveryTimeout time.Duration
}

type RedactionRules struct {
	DropDescription   bool
	DropNetworkOrigin bool
	DropUserAgent     bool
	AllowedAttributes []string
	AllowedChanges    []string
}

type Redactor interface {
	Redact(context.Context, Record) (Record, error)
}

type RedactorFunc func(context.Context, Record) (Record, error)

type RetentionApplyResult struct{ Deleted, Held, Changed int }

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

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

type RetentionEventInput struct {
	ID, RecordID, ReasonCode string
	Kind                     RetentionEventKind
	OccurredAt               time.Time
}

type RetentionEventKind uint8

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

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

type RetentionRequestInput struct {
	Tenant TenantScope
	Before time.Time
	Limit  uint32
}

type RetentionStore interface {
	AppendRetentionEvent(context.Context, RetentionEvent) (AppendResult, error)
	PlanRetention(context.Context, RetentionRequest) (RetentionPlan, error)
	ApplyRetention(context.Context, RetentionPlan) (RetentionApplyResult, error)
}

type Sink interface {
	Append(context.Context, Record) (AppendResult, error)
	AppendBatch(context.Context, []Record) (BatchResult, error)
}

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

type SubjectInput struct {
	Type    string
	ID      string
	Deleted bool
}

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

type TenantScopeMode uint8