protocol

type Aggregate struct {
	// Grouped distinguishes an ungrouped answer, which omits the member
	// entirely, from the group of rows whose field is null, which reports it
	// as null and counts toward the group limit.
	Grouped bool
	Group   *string
	// GroupReference carries the group of a reference-valued grouping, as the
	// bare qualified identity distinct references already returns. At most one
	// of Group and GroupReference is set; both nil in a grouped answer is the
	// null group, which is a group like any other.
	//
	// One representation of a reference rather than two, because a client that
	// has to decode an identity differently depending on which read produced
	// it is a client with two decoders and one of them under-tested.
	GroupReference *Reference
	RowCount       int
	ValueCount     int
	Sum            json.RawMessage
	Minimum        json.RawMessage
	Maximum        json.RawMessage
}

type AttachmentTarget struct {
	TypeID       string `json:"type_id"`
	CollectionID string `json:"collection_id"`
	ObjectID     string `json:"object_id,omitempty"`
}

type DeprecatedVersion struct {
	Version string `json:"version"`
	Sunset  string `json:"sunset"`
}

type Error struct {
	OperationIndex *int           `json:"operation_index,omitempty"`
	Code           string         `json:"code"`
	Message        string         `json:"message"`
	Details        map[string]any `json:"details,omitempty"`
}

type Field struct {
	ID     string `json:"id"`
	MetaID string `json:"meta_id"`
	Name   string `json:"name"`
	Type   Type   `json:"type"`
	// Scale is the greatest number of fraction digits a value of this field
	// may carry. It is required on a `fixed` field and MUST be absent on every
	// other type, so that a reader never has to decide what scale means for a
	// type that has no fraction.
	//
	// It bounds rather than pads. A canonical fixed value carries no trailing
	// zero, so a scale-2 field stores `1`, `1.5` and `1.25`, and refuses
	// `1.255` — which would have to be rounded, and rounding is the caller's
	// decision rather than the store's.
	Scale *int `json:"scale,omitempty"`
	// Immutable fixes a value once it is written: an update may set the field
	// while it holds nothing, and may restate what it holds, and may do nothing
	// else to it. It constrains update, never deletion, and it is a rule the
	// server applies mechanically — the store still does not know what the
	// field means. `false` and absent are the same, and only `true` is returned.
	Immutable bool `json:"immutable,omitempty"`
	// Creator marks a text field populated by the server from the authenticated
	// principal on insert. A caller cannot supply or change its value.
	Collection  bool                       `json:"collection,omitempty"`
	Creator     bool                       `json:"creator,omitempty"`
	Roles       []string                   `json:"roles,omitempty"`
	Annotations map[string]json.RawMessage `json:"annotations,omitempty"`
}

type IdentifierKind string

type Identity struct {
	ID     string `json:"id"`
	MetaID string `json:"meta_id"`
}

type Limits struct {
	MaxMaterializedBytes int `json:"max_materialized_bytes,omitempty"`
	// MaxStoredBytes is the dataset's storage quota: the stored bytes past
	// which a write is refused 507 dataset_full. Zero, and absent on the
	// wire, is no quota. It is not the materialization bound, which is how
	// much one operation may hold in memory and is always declared.
	MaxStoredBytes              int `json:"max_stored_bytes,omitempty"`
	MaxAllowedConcreteTypes     int `json:"max_allowed_concrete_types"`
	MaxSelectionPerConcreteType int `json:"max_selection_per_concrete_type"`
	MaxSortTerms                int `json:"max_sort_terms"`
	MaxProjectedFields          int `json:"max_projected_fields"`
	MaxOverallLimit             int `json:"max_overall_limit"`
	MaxPageSize                 int `json:"max_page_size"`
	MaxDistinctReferences       int `json:"max_distinct_references"`
	// MaxAggregateGroups bounds the distinct groups one aggregation may
	// return. Exceeding it refuses the whole request; a prefix returned as if
	// complete is the answer this bound exists to prevent.
	MaxAggregateGroups int `json:"max_aggregate_groups"`
	// MaxTransactionOperations bounds the operations in one transaction. It
	// was enforced before it was declared, and a caller exceeding it got a
	// bare invalid_field naming neither the bound nor the number — a limit a
	// client could only find by being refused.
	MaxTransactionOperations int `json:"max_transaction_operations"`
	MaxPredicateDepth        int `json:"max_predicate_depth"`
	MaxPredicateWidth        int `json:"max_predicate_width"`
	// MaxFixedDigits bounds the significant digits of a `fixed` value, sign
	// and decimal point excluded. It is a value bound rather than a field
	// bound: a field's own `scale` bounds its fraction digits, and this bounds
	// how large the whole number may be whatever the field declares.
	MaxFixedDigits     int `json:"max_fixed_digits"`
	MaxTextBytes       int `json:"max_text_bytes"`
	MaxInlineBlobBytes int `json:"max_inline_blob_bytes"`
	MaxRequestBytes    int `json:"max_request_bytes"`
	MaxScannedRows     int `json:"max_scanned_rows"`
	MaxRoles           int `json:"max_roles"`
	MaxRoleLength      int `json:"max_role_length"`
	// IdempotencyRetentionSeconds is how long a claimed key stays answerable,
	// measured from the claim. It MUST be at least
	// MinimumIdempotencyRetentionSeconds: a window shorter than that leaves a
	// client unable to reconcile a lost response, which is the one thing the
	// key exists to make possible.
	IdempotencyRetentionSeconds int `json:"idempotency_retention_seconds"`
}

type Meta struct {
	SchemaVersion string                     `json:"schema_version,omitempty"`
	ID            string                     `json:"id"`
	ParentID      *string                    `json:"parent_id"`
	Name          string                     `json:"name"`
	Fields        []Field                    `json:"fields"`
	Roles         []string                   `json:"roles,omitempty"`
	Annotations   map[string]json.RawMessage `json:"annotations,omitempty"`
}

type ObjectID struct {
	ID        string `json:"id"`
	DatasetID string `json:"dataset_id"`
}

type Operation struct {
	SchemaVersion string                     `json:"schema_version,omitempty"`
	Op            string                     `json:"op"`
	Type          string                     `json:"type,omitempty"`
	Target        *Target                    `json:"target,omitempty"`
	Fields        map[string]json.RawMessage `json:"fields,omitempty"`
	As            string                     `json:"as,omitempty"`
	Meta          *Meta                      `json:"meta,omitempty"`
	Filter        json.RawMessage            `json:"filter,omitempty"`
	ObjectIDs     []string                   `json:"object_ids,omitempty"`
	Version       *string                    `json:"version,omitempty"`
	Guards        []string                   `json:"guards,omitempty"`
	Cascade       bool                       `json:"cascade,omitempty"`
	Confirm       string                     `json:"confirm,omitempty"`
}

type OperationResult struct {
	Objects []Identity `json:"objects,omitempty"`
	// RecordSet is the stored row, present only where the caller asked for it
	// with `Prefer: return=representation` and may read what it wrote. It is
	// what a read of the new object would return, produced by the same path,
	// so a client cannot be handed a representation that a subsequent read
	// would contradict.
	//
	// Objects stays whatever this carries. The identity is what every caller
	// of an insert needs and the representation is what some do, and the two
	// are built from one object inside one transaction, so they cannot
	// disagree — which is the objection that would otherwise apply to saying
	// the same thing twice.
	RecordSet      *RecordSet `json:"record_set,omitempty"`
	Affected       *int       `json:"affected,omitempty"`
	Type           *Meta      `json:"type,omitempty"`
	DeletedTypes   []string   `json:"deleted_types,omitempty"`
	DeletedObjects *int       `json:"deleted_objects,omitempty"`
}

type Predicate struct {
	Kind         string
	Field        string
	Exact        *Value
	Lower, Upper *Value
	Text         string
	IDs          []string
	After        string
	Children     []*Predicate
}

type Query struct {
	TypeScope         *TypeScope      `json:"type_scope,omitempty"`
	Filter            json.RawMessage `json:"filter,omitempty"`
	Selection         *Selection      `json:"selection,omitempty"`
	ResultSort        []SortTerm      `json:"result_sort,omitempty"`
	Fields            []string        `json:"fields"`
	MaximumTextLength *int            `json:"maximum_text_length,omitempty"`
	IncludeVersions   bool            `json:"include_versions,omitempty"`
}

type Record struct {
	ID      ObjectID `json:"id"`
	MetaID  string   `json:"meta_id"`
	Values  []Value  `json:"values"`
	Version string   `json:"version,omitempty"`
}

type RecordSet struct {
	Meta      Meta     `json:"meta"`
	Records   []Record `json:"records"`
	Watermark string   `json:"watermark"`
}

type Reference struct {
	DatasetID string `json:"dataset_id"`
	ObjectID  string `json:"object_id"`
	MetaID    string `json:"meta_id"`
}

type Selection struct {
	Kind      string     `json:"kind"`
	Count     int        `json:"count,omitempty"`
	OrderedBy []SortTerm `json:"ordered_by,omitempty"`
}

type SortTerm struct {
	FieldID   string `json:"field_id"`
	Ascending bool   `json:"ascending"`
}

type Target struct {
	Type string `json:"type"`
	ID   string `json:"id"`
}

type Transaction struct {
	Operations []Operation `json:"operations"`
}

type TransactionResult struct {
	Results   []OperationResult `json:"results"`
	Watermark string            `json:"watermark"`
}

type Type string

type TypeScope struct {
	Kind                   string   `json:"kind"`
	AllowedConcreteTypeIDs []string `json:"allowed_concrete_type_ids,omitempty"`
}

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