configapp

type Against struct {
	Workspace bool
	Revision  *string
}

type AppliedPlan struct {
	Items   []WorkspaceRef `json:"items"`
	Comment string         `json:"comment,omitempty"`
}

type ApplyRequest struct {
	Plan   configplan.Plan
	PlanID string
	Review bool
	// Confirmed are the IDs of the exceptions to confirm reported to the
	// administrator: every one of them.
	Confirmed []string
	Comment   string
	// Agent names the agent (its token) applying the plan; empty: the
	// administrator, in the console.
	Agent string
}

type Built struct {
	Base    revision.Revision
	Spec    *config.Spec
	Config  *config.Config
	Payload []byte
}

type CatalogCounts struct {
	All       int `json:"all"`
	New       int `json:"new"`
	Workspace int `json:"workspace"`
	Published int `json:"published"`
	Drift     int `json:"drift"`
}

type CatalogCoverage struct {
	Datasource string `json:"datasource"`
	// Schemas scanned.
	Scanned int `json:"scanned"`
	// Schemas listed; null when never listed.
	Listed *int `json:"listed,omitempty"`
	// Listed schemas never scanned.
	Unscanned []string `json:"unscanned"`
	// When the oldest scanned schema was scanned; null when none.
	OldestScan *time.Time `json:"oldestScan,omitempty"`
}

type CatalogFilter struct {
	// Datasources to search; empty: all.
	Datasources []string `json:"datasources,omitempty"`
	// Glob patterns (* and ?) on schema names.
	Schemas []string `json:"schemas,omitempty"`
	// Glob patterns on table names.
	Tables []string `json:"tables,omitempty"`
	// A part of the table name or its comment.
	Search *string  `json:"search,omitempty"`
	Status []string `json:"status,omitempty"`
	// Only configured tables whose columns and fields differ.
	Drift *bool `json:"drift,omitempty"`
}

type CatalogLinks struct {
	Outgoing []TableLink `json:"outgoing"`
	Incoming []TableLink `json:"incoming"`
}

type CatalogPage struct {
	// Tables matching the filter.
	Total  int          `json:"total"`
	Tables []CatalogRow `json:"tables"`
	// Tables by status, matching every condition but the status.
	Counts   *CatalogCounts    `json:"counts"`
	Coverage []CatalogCoverage `json:"coverage"`
}

type CatalogRow struct {
	// datasource.schema.table: the ID an entity named like the table would have.
	Ref         string `json:"ref"`
	Datasource  string `json:"datasource"`
	Schema      string `json:"schema"`
	Table       string `json:"table"`
	Description string `json:"description"`
	View        bool   `json:"view"`
	Columns     int    `json:"columns"`
	// Foreign keys of the table, and of other scanned tables referencing it.
	ForeignKeys  int `json:"foreignKeys"`
	ReferencedBy int `json:"referencedBy"`
	// Whether a key identifies a row.
	HasKey      bool   `json:"hasKey"`
	SideEffects bool   `json:"sideEffects"`
	Status      string `json:"status"`
	// The entity that reads the table.
	Entity *string `json:"entity,omitempty"`
	// Columns without a field, and fields without a column.
	Added   []string `json:"added"`
	Missing []string `json:"missing"`
	// When the table's schema was scanned.
	ScannedAt *time.Time `json:"scannedAt,omitempty"`
}

type CommitInput struct {
	Version           int     `json:"version"`
	ExpectedPublished string  `json:"expectedPublished"`
	Comment           *string `json:"comment,omitempty"`
	RestartRequired   *bool   `json:"restartRequired,omitempty"`
}

type Draft struct {
	Base string
	Edit configedit.Edit
}

type EntityItem struct {
	Name          string             `json:"name"`
	Source        *string            `json:"source,omitempty"`
	Datasource    *string            `json:"datasource,omitempty"`
	Schema        *string            `json:"schema,omitempty"`
	Kind          *string            `json:"kind,omitempty"`
	Description   *string            `json:"description,omitempty"`
	PrimaryKey    []string           `json:"primaryKey"`
	UniqueKeys    [][]string         `json:"uniqueKeys"`
	Fields        []FieldItem        `json:"fields"                 merge:"key=name"`
	Relationships []RelationshipItem `json:"relationships"          merge:"key=name"`
	TenantPolicy  any                `json:"tenantPolicy,omitempty"`
	LegacyAccess  any                `json:"legacyAccess,omitempty"`
	Mcp           *EntityMCPItem     `json:"mcp,omitempty"`
	Params        []string           `json:"params"`
	Affects       []string           `json:"affects"`
	AllowCascade  *bool              `json:"allowCascade,omitempty" merge:"unset"`
}

type EntityMCPItem struct {
	DmlTools         *bool `json:"dmlTools,omitempty"`
	CustomTool       *bool `json:"customTool,omitempty"       merge:"unset"`
	TrustedProcedure *bool `json:"trustedProcedure,omitempty" merge:"unset"`
}

type FieldItem struct {
	Name        string  `json:"name"`
	Alias       *string `json:"alias,omitempty"`
	Description *string `json:"description,omitempty"`
	Mask        *string `json:"mask,omitempty"`
	Exclude     *bool   `json:"exclude,omitempty"     merge:"unset"`
}

type FieldReference struct {
	Field string  `json:"field"`
	Kind  string  `json:"kind"`
	Name  string  `json:"name"`
	Via   *string `json:"via,omitempty"`
}

type GrantItem struct {
	Entity           string   `json:"entity"`
	Actions          []string `json:"actions"`
	FieldsRestricted *bool    `json:"fieldsRestricted,omitempty"`
	ReadFields       []string `json:"readFields"`
	WriteFields      []string `json:"writeFields"`
	Rows             any      `json:"rows,omitempty"`
}

type Imports struct {
	Datasource    string
	DefaultSchema string
	// Source is the token of the database the tables were read from.
	Source string
	Tables []configplan.Candidate
}

type Introspection func(
	ctx context.Context, datasource string, database config.DatabaseConfig, fn func(introspect.Introspector) error,
) error

type McpToken struct {
	ID        string    `json:"id"`
	Name      string    `json:"name"`
	CreatedAt time.Time `json:"createdAt"`
	// null: never expires.
	ExpiresAt  *time.Time `json:"expiresAt,omitempty"`
	LastUsedAt *time.Time `json:"lastUsedAt,omitempty"`
	// The datasources it reaches; null: every one.
	Datasources []string `json:"datasources,omitempty"`
	// Refused: created read only, which is no longer offered; generate a new one.
	Retired bool `json:"retired"`
}

type McpTokenInput struct {
	// Names the client, unique among the administrator's tokens.
	Name string `json:"name"`
	// Days until it expires; null or 0 never.
	ExpiresInDays *int `json:"expiresInDays,omitempty"`
	// Limits it to these datasources; null: every one.
	Datasources []string `json:"datasources,omitempty"`
}

type McpTokenSecret struct {
	// Shown only once.
	Token string    `json:"token"`
	Info  *McpToken `json:"info"`
}

type PendingDraft struct {
	Revision revision.Revision
	BasedOn  int64
}

type PendingPlan struct {
	// Changes when the report does: a new situation opens again.
	Key      string        `json:"key"`
	Template *PlanTemplate `json:"template"`
	Report   *PlanReport   `json:"report"`
	State    *PendingState `json:"state,omitempty"`
}

type PendingState struct {
	Key string `json:"key"`
	// open, snoozed or ignored; a snooze that ended reads open.
	Status    string     `json:"status"`
	Owner     *string    `json:"owner,omitempty"`
	Reason    *string    `json:"reason,omitempty"`
	Until     *time.Time `json:"until,omitempty"`
	UpdatedBy string     `json:"updatedBy"`
	UpdatedAt time.Time  `json:"updatedAt"`
}

type PendingStateInput struct {
	// The item's key, as PendingWork gives it.
	Key string `json:"key"`
	// open, snoozed or ignored.
	Status string  `json:"status"`
	Owner  *string `json:"owner,omitempty"`
	Reason *string `json:"reason,omitempty"`
	// When a snoozed item opens again.
	Until *time.Time `json:"until,omitempty"`
}

type PendingTable struct {
	// Changes when the differences do.
	Key     string        `json:"key"`
	Ref     string        `json:"ref"`
	Entity  string        `json:"entity"`
	Added   []string      `json:"added"`
	Missing []string      `json:"missing"`
	State   *PendingState `json:"state,omitempty"`
}

type PendingWork struct {
	// Recurring templates whose plan would change the configuration or has rules it cannot apply.
	Plans []PendingPlan `json:"plans"`
	// Tables whose fields differ from their columns.
	DriftTables      []PendingTable `json:"driftTables"`
	Drift            int            `json:"drift"`
	NewTables        int            `json:"newTables"`
	UnscannedSchemas int            `json:"unscannedSchemas"`
	// Datasources whose schemas were never listed: what they hold is unknown.
	UnlistedDatasources []string `json:"unlistedDatasources"`
}

type PlanChange struct {
	// import, createRole, grant, exclude, mask, syncAdd or syncRemove.
	Kind      string   `json:"kind"`
	Principal *string  `json:"principal,omitempty"`
	Actions   []string `json:"actions"`
	Mask      *string  `json:"mask,omitempty"`
	// Fields a field change touches.
	Fields   int      `json:"fields"`
	Entities []string `json:"entities"`
}

type PlanException struct {
	// Identifies the exception within its plan: a draft is saved with each exception to confirm
	// confirmed by its ID.
	ID string `json:"id"`
	// renamed, noKey, sideEffects, relationshipDropped, qualified, unknownUser,
	// noFields, referenced, denied or review.
	Kind string `json:"kind"`
	// block (the proposal cannot be taken), confirm (taking it needs the
	// exception acknowledged) or info.
	Level string `json:"level"`
	// Not only informative: level is block or confirm.
	Warning bool `json:"warning"`
	// The table, when excluding it is a way out.
	Ref    *string `json:"ref,omitempty"`
	Entity *string `json:"entity,omitempty"`
	Detail *string `json:"detail,omitempty"`
}

type PlanObjects struct {
	Datasource string `json:"datasource"`
	Schema     string `json:"schema"`
	Tables     int    `json:"tables"`
	Imported   int    `json:"imported"`
	Changed    int    `json:"changed"`
}

type PlanReport struct {
	Matched    int                `json:"matched"`
	Excluded   int                `json:"excluded"`
	Objects    []PlanObjects      `json:"objects"`
	Changes    []PlanChange       `json:"changes"`
	Exceptions []PlanException    `json:"exceptions"`
	Unscanned  []UnscannedSchemas `json:"unscanned"`
	// When the tables in scope were scanned, oldest and newest.
	ScannedFrom *time.Time `json:"scannedFrom,omitempty"`
	ScannedTo   *time.Time `json:"scannedTo,omitempty"`
}

type PlanStore interface {
	PlanTemplates(ctx context.Context) ([]configstore.PlanTemplate, error)
	PlanTemplateVersions(ctx context.Context, name string) ([]configstore.PlanTemplate, error)
	PutPlanTemplate(ctx context.Context, t configstore.PlanTemplate, expected int) (configstore.PlanTemplate, error)
	DeletePlanTemplate(ctx context.Context, name string) error
	AdminTokens(ctx context.Context, username string) ([]configstore.AdminToken, error)
	AdminTokenByHash(ctx context.Context, hash string) (configstore.AdminToken, bool, error)
	CreateAdminToken(ctx context.Context, t configstore.AdminToken) (configstore.AdminToken, error)
	DeleteAdminToken(ctx context.Context, username, id string) error
	TouchAdminToken(ctx context.Context, id string, at time.Time) error
	PendingStates(ctx context.Context) ([]configstore.PendingState, error)
	PendingLog(ctx context.Context, key string) ([]configstore.PendingState, error)
	PutPendingState(ctx context.Context, p configstore.PendingState) (configstore.PendingState, error)
	workspace.Store
}

type PlanTemplate struct {
	Name string `json:"name"`
	Plan any    `json:"plan"`
	// Its new matches are pending after each scan.
	Recurring bool `json:"recurring"`
	// Bumped by every save.
	Version int `json:"version"`
	// Who saved this version.
	Author    string    `json:"author"`
	UpdatedAt time.Time `json:"updatedAt"`
}

type PlanTemplateInput struct {
	// 1 to 64 characters.
	Name string `json:"name"`
	Plan any    `json:"plan"`
	// Report its new matches as pending.
	Recurring bool `json:"recurring"`
	// The version edited; null creates a template, failing when the name is
	// taken. Another administrator's save meanwhile fails with CONFLICT.
	ExpectedVersion *int `json:"expectedVersion,omitempty"`
}

type Preview struct {
	// PlanID identifies the plan with what it was evaluated against.
	PlanID   string
	Plan     configplan.Plan
	Review   bool
	Proposal configplan.Proposal
	// Base is the configuration the plan applies to.
	Base       *config.Config
	Report     *PlanReport
	Validation *Validation
	// contains filtered or unexported fields
}

type RelationshipItem struct {
	Name        string `json:"name"`
	Target      string `json:"target"`
	Cardinality string `json:"cardinality"`
	JoinOn      any    `json:"joinOn"`
}

type RoleItem struct {
	Name        string      `json:"name"`
	Description *string     `json:"description,omitempty"`
	Grants      []GrantItem `json:"grants"                merge:"key=entity"`
}

type ScanBatch struct {
	ID         string `json:"id"`
	Datasource string `json:"datasource"`
	// running, done or canceled.
	State    string `json:"state"`
	Total    int    `json:"total"`
	Done     int    `json:"done"`
	Failed   int    `json:"failed"`
	Canceled int    `json:"canceled"`
	// Schemas waiting or scanning.
	Pending    int             `json:"pending"`
	Items      []ScanBatchItem `json:"items"`
	StartedBy  string          `json:"startedBy"`
	StartedAt  time.Time       `json:"startedAt"`
	FinishedAt *time.Time      `json:"finishedAt,omitempty"`
}

type ScanBatchInput struct {
	Datasource string   `json:"datasource"`
	Schemas    []string `json:"schemas"`
	// Names the request: sent again with the same key, it gets the batch it started.
	RequestKey *string `json:"requestKey,omitempty"`
}

type ScanBatchItem struct {
	Schema string `json:"schema"`
	// pending, running, done, failed or canceled.
	State string  `json:"state"`
	Error *string `json:"error,omitempty"`
}

type ScanJob struct {
	ID         string `json:"id"`
	Datasource string `json:"datasource"`
	State      string `json:"state"`
	// Why the scan failed or stopped.
	Error *string `json:"error,omitempty"`
}

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

type SchemaInfo struct {
	Name string `json:"name"`
	// When its tables were last scanned; null when never.
	ScannedAt *time.Time `json:"scannedAt,omitempty"`
	// How many tables the last scan found; null when never scanned.
	Tables *int `json:"tables,omitempty"`
}

type SchemaList struct {
	Datasource string `json:"datasource"`
	// Every user schema; when the database cannot list them, one named "" for its
	// default schema, which a scan without schemas reads.
	Schemas []SchemaInfo `json:"schemas"`
	// Where unqualified names resolve; null when unknown.
	DefaultSchema *string   `json:"defaultSchema,omitempty"`
	ListedAt      time.Time `json:"listedAt"`
	// Identifies the database the datasource reads (its driver and read
	// connection); results of another source are stale.
	Source string `json:"source"`
}

type ScopeCondition struct {
	// datasources, schemas, tables, search, status, drift or refs.
	Name string `json:"name"`
	// The condition as written.
	Value   string `json:"value"`
	Matched int    `json:"matched"`
}

type ScopeStats struct {
	Total int `json:"total"`
	// The first matching tables.
	Samples []CatalogRow `json:"samples"`
	// Every condition of the scope with how many tables it selects alone.
	Conditions []ScopeCondition `json:"conditions"`
}

type Sections struct {
	Entities []EntityItem   `json:"entities"`
	Roles    []RoleItem     `json:"roles"`
	Users    []UserItem     `json:"users"`
	Settings map[string]any `json:"settings"`
}

type Service struct {
	Store      revision.Store
	Introspect Introspection
	// Scans runs schema scans in the background and keeps their results;
	// nil refuses them.
	Scans *Scans
	// Plans keeps plan templates, MCP tokens and pending states; nil refuses
	// them.
	Plans PlanStore
	// Capabilities reports the serving snapshot's capabilities; nil reports
	// none.
	Capabilities func() bootstrap.EntityCapabilities
	// contains filtered or unexported fields
}

type SimulateRequest struct {
	// Against selects the configuration.
	Against Against
	// User is a configured user name, or role:<name>.
	User, Entity, Action string
	Fields               []string
	Subject              map[string]any
}

type Simulation struct {
	Allowed bool     `json:"allowed"`
	Reason  string   `json:"reason"`
	Fields  []string `json:"fields"`
	// Effective row filter in rowPolicies JSON form; null means every row.
	RowFilter any      `json:"rowFilter,omitempty"`
	Grants    []string `json:"grants"`
	// Set when no single grant covers the requested fields.
	FieldScopes [][]string `json:"fieldScopes,omitempty"`
}

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

type TableLink struct {
	// The other table.
	Ref  string `json:"ref"`
	Name string `json:"name"`
	// Columns of the referencing table, and the referenced ones.
	Columns    []string `json:"columns"`
	RefColumns []string `json:"refColumns"`
	// The entity reading the other table, if any.
	Entity *string `json:"entity,omitempty"`
}

type UnscannedSchemas struct {
	Datasource string   `json:"datasource"`
	Schemas    []string `json:"schemas"`
}

type UserItem struct {
	Name        string      `json:"name"`
	Description *string     `json:"description,omitempty"`
	Roles       []string    `json:"roles"`
	Grants      []GrantItem `json:"grants"                merge:"key=entity"`
	Subject     any         `json:"subject,omitempty"`
	Disabled    *bool       `json:"disabled,omitempty"    merge:"unset"`
	TokenHash   *string     `json:"tokenHash,omitempty"`
}

type Validation struct {
	Ok          bool    `json:"ok"`
	Error       *string `json:"error,omitempty"`
	ContentHash *string `json:"contentHash,omitempty"`
	// Changes against the published revision that need a restart.
	RestartRequired []string `json:"restartRequired"`
	// Grants the routed datasource connections cannot run (they do not block publishing).
	Warnings []string `json:"warnings"`
}

type Workspace struct {
	// The revision it builds on.
	Base    string `json:"base"`
	Version int    `json:"version"`
	// The console's sections (entities, roles, users, settings).
	Sections  any                 `json:"sections"`
	Conflicts []WorkspaceConflict `json:"conflicts"`
	// Where changes came from: plans agents applied, drafts taken in.
	Notes []WorkspaceNote `json:"notes"`
	// Drafts taken in or saved from it (not to offer it for review), and the
	// draft it holds as it is (saved from it, nothing changed since).
	Taken      []string   `json:"taken"`
	Checkpoint *string    `json:"checkpoint,omitempty"`
	UpdatedAt  *time.Time `json:"updatedAt,omitempty"`
	// The administrator, or agent:<token name>.
	UpdatedBy string `json:"updatedBy"`
}

type WorkspaceConflict struct {
	ID   string `json:"id"`
	Kind string `json:"kind"`
	Key  string `json:"key"`
	// Where in the item, e.g. fields[email].mask; empty: the whole item.
	Path string `json:"path"`
	// The values (null when removed: MineGone, TheirsGone).
	Mine       any  `json:"mine,omitempty"`
	MineGone   bool `json:"mineGone"`
	Theirs     any  `json:"theirs,omitempty"`
	TheirsGone bool `json:"theirsGone"`
	// published (a newer revision), draft (one taken in) or workspace (a
	// write made meanwhile, by another console or an agent).
	Source string  `json:"source"`
	FromID *string `json:"fromId,omitempty"`
	FromBy *string `json:"fromBy,omitempty"`
}

type WorkspaceEditInput struct {
	Items []WorkspaceItemInput `json:"items"`
}

type WorkspaceItemInput struct {
	Kind        string  `json:"kind"`
	Key         string  `json:"key"`
	Value       any     `json:"value,omitempty"`
	Previous    any     `json:"previous,omitempty"`
	RenamedFrom *string `json:"renamedFrom,omitempty"`
}

type WorkspaceLogEntry struct {
	Version int       `json:"version"`
	At      time.Time `json:"at"`
	By      string    `json:"by"`
	// edit, apply, update, reset, merge, resolve, checkpoint or commit.
	Op    string         `json:"op"`
	Items []WorkspaceRef `json:"items"`
	Note  *string        `json:"note,omitempty"`
}

type WorkspaceNote struct {
	// agent or draft.
	Source string `json:"source"`
	By     string `json:"by"`
	Text   string `json:"text"`
}

type WorkspaceRef struct {
	Kind string `json:"kind"`
	Key  string `json:"key"`
}