operation

type Access func(Context) (Decision, error)

type AccessCapabilities struct {
	Operations OperationCapabilities
	Fields     map[string]FieldCapabilities
}

type CapabilitiesRequest struct {
	Collection      string
	ID              string
	Data            store.Values
	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	TrashOnly       bool
	Locale          string
	FallbackLocales []schema.LocaleCode
	DisableFallback bool
	AllLocales      bool
}

type Collection struct {
	Key      string
	Schema   schema.Collection
	Access   map[operation.Kind]Access
	Hooks    Hooks
	Bindings []FieldBinding
}

type Computed func(Context, store.Document) (store.Value, error)

type Config struct {
	Collections               []Collection
	Store                     store.Store
	AllowIDOnCreate           bool
	MaxDepth                  int
	PluginValidators          map[string]PluginValidator
	DispatchAfterCommit       func(Context, Hook) error
	BeginPermanentDeleteFence func(context.Context, []PermanentDelete) func(bool)
	CleanupPermanentDeletes   func(context.Context, []PermanentDelete) error
	ValidateUploadImport      func(context.Context, schema.Collection, store.Values) error
	RootAfterError            []Hook
	Localization              *schema.LocalizationSettings
}

type Context struct {
	Context             context.Context
	Operation           operation.Kind
	Collection          schema.Collection
	ID                  string
	Actor               *store.Document
	ActorCollection     schema.CollectionSlug
	Data                store.Values
	Value               store.Value
	SiblingData         store.Values
	InputSiblingData    store.Values
	RootData            store.Values
	LiveValidation      bool
	OriginalValue       store.Value
	OriginalSiblingData store.Values

	Document     *store.Document
	Original     *store.Document
	FieldPath    string
	OccurrenceID string
	ValuePresent bool

	RuntimePath string
	Error       error
	Locale      schema.LocaleCode
	AllLocales  bool
	Locales     []schema.LocaleCode
	// contains filtered or unexported fields
}

type Decision struct {
	Kind   DecisionKind
	Access *query.Node
}

type DecisionKind string

type DistinctRequest struct {
	Collection      string
	Field           query.Path
	Filter          query.Expression
	Page            int
	Limit           int
	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	Draft           *bool
	TrashOnly       bool
	Locale          string
	FallbackLocales []schema.LocaleCode
	DisableFallback bool
}

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

type Error struct {
	Code    string
	Status  int
	Message string
	Issues  []schema.Issue
	Cause   error
	// Committed reports that the durable transaction succeeded before a later
	// after-commit effect failed. Callers that stage external resources must not
	// roll those resources back when this is true.
	Committed bool
	// CommitAttempted reports that Commit was sent but its durable outcome could
	// not be proven. External resources must be retained and reconciled instead
	// of rolled back when this is true.
	CommitAttempted bool
}

type FieldAccess func(Context) (bool, error)

type FieldBinding struct {
	ID             string
	Field          schema.Field
	LocaleOwned    bool
	Hooks          Hooks
	Access         FieldRules
	Validators     []FieldValidator
	LiveValidators []FieldLiveValidator
	Computed       Computed
	Default        FieldDefault
}

type FieldCapabilities struct {
	Read   bool
	Create bool
	Update bool
}

type FieldDefault func(Context) (store.Value, bool, error)

type FieldLiveValidator func(Context) ([]schema.Issue, bool, error)

type FieldRules struct {
	Create FieldAccess
	Read   FieldAccess
	Update FieldAccess
}

type FieldValidator func(Context) ([]schema.Issue, error)

type FilteredSelectionItem struct {
	ID           string
	Capabilities AccessCapabilities
}

type FilteredSelectionRequest struct {
	Collection      string
	Filter          query.Expression
	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	TrashOnly       bool
	Locale          string
	FallbackLocales []schema.LocaleCode
	DisableFallback bool
	AllLocales      bool
}

type FilteredSelectionResult struct {
	Items []FilteredSelectionItem
}

type Hook func(Context) error

type Hooks struct {
	BeforeDuplicate []Hook
	BeforeValidate  []Hook
	BeforeChange    []Hook
	BeforeOperation []Hook
	BeforeRead      []Hook
	BeforeDelete    []Hook
	AfterChange     []Hook
	AfterRead       []Hook
	AfterDelete     []Hook
	AfterOperation  []Hook
	AfterError      []Hook
	AfterCommit     []Hook
}

type JoinMutationRequest struct {
	Collection      string
	ID              string
	Field           string
	Additions       []string
	Removals        []string
	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	Locale          string
	FallbackLocales []schema.LocaleCode
	DisableFallback bool
	AllLocales      bool
}

type JoinMutationResult struct {
	Document store.Document
	Added    int
	Removed  int
}

type LiveValidationEmbeddedScope struct {
	Field       string
	TreeKey     string
	CaseTag     string
	VariantSlug string
	Identity    string
	Data        store.Values
}

type LiveValidationEvaluation struct {
	Path   string
	Target string
	Status string
	Issues []schema.Issue
}

type LiveValidationRequest struct {
	Collection      string
	ID              string
	Data            store.Values
	Fields          []string
	Embedded        []LiveValidationEmbeddedScope
	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	Locale          string
}

type LiveValidationResult struct{ Evaluations []LiveValidationEvaluation }

type LocalizationOptions struct {
	Locale          string
	FallbackLocales []schema.LocaleCode
	DisableFallback bool
	AllLocales      bool
	// ActorCollection identifies the exact auth collection that owns Actor on
	// specialized version and locale operations.
	ActorCollection schema.CollectionSlug
}

type OperationCapabilities struct {
	Admin           bool
	Create          bool
	Read            bool
	ReadVersions    bool
	Update          bool
	Delete          bool
	Duplicate       bool
	Publish         bool
	Unpublish       bool
	RestoreDeleted  bool
	DeletePermanent bool
	SelectAll       bool
	Unlock          bool
}

type PermanentDelete struct {
	Collection schema.Collection
	DocumentID string
	Original   store.Document
}

type PluginValidator func(schema.Field, store.Value, string) []schema.Issue

type Request struct {
	Operation  operation.Kind
	Collection string
	ID         string
	Data       store.Values
	Filter     query.Expression

	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	Page            int
	Limit           int
	IndexWindow     *store.IndexWindow
	Sort            []query.Sort
	Select          []query.Path
	Populate        []query.Population
	// OutputFields limits computed and inverse-join resolution. Nil preserves
	// the local API's historical behavior of resolving every output field; a
	// non-nil empty slice resolves none. This is deliberately separate from
	// Select because computed resolvers may depend on unprojected stored data.
	OutputFields []query.Path
	// Draft overrides versioned read visibility or selects the status written
	// by create/update. Nil preserves the caller's existing behavior.
	Draft            *bool
	ExpectedRevision int
	Status           *store.Status
	ImportID         string
	ImportCreatedAt  time.Time
	ImportUpdatedAt  time.Time
	TrashOnly        bool
	StoragePrepared  bool
	// ValidateUploadObjects re-adopts existing upload keys. The engine locks and
	// verifies every final key inside the write transaction before committing
	// metadata that can make those objects live again.
	ValidateUploadObjects bool
	LocalizationPrepared  bool

	// SkipFieldAccess is reserved for framework-owned initialization that must
	// author the first administrator before an actor exists. Collection access,
	// validation, hooks, and the transaction remain active.
	SkipFieldAccess     bool
	TransactionMutation TransactionMutation
	// TransactionResource binds one framework-owned external resource to the
	// true outer transaction. Commit retains it, a definite rollback cleans it
	// up, and an unknown commit outcome retains it for reconciliation rather
	// than risking a dangling durable row.
	TransactionResource *TransactionResource
	Locale              string
	FallbackLocales     []schema.LocaleCode
	DisableFallback     bool
	AllLocales          bool
	// contains filtered or unexported fields
}

type Result struct {
	Document      *store.Document
	Page          *store.Page
	WindowHasMore bool
}

type TransactionMutation func(context.Context, store.Transaction, schema.Collection, store.Document) error

type TransactionResource struct {
	Commit   func()
	Rollback func(context.Context) error
	Unknown  func()
	// contains filtered or unexported fields
}