apilive

type AbstractType struct {
	Kind          string   `json:"kind"`
	PossibleTypes []string `json:"possible_types"`
}

type AdditionalScope struct {
	Permissions   []string  `json:"permissions,omitempty"`
	BoundaryType  string    `json:"boundary_type,omitempty"`
	BoundaryParam string    `json:"boundary_param,omitempty"`
	Boundary      *Callable `json:"boundary,omitempty"`
	UnknownKeys   []string  `json:"unknown_keys,omitempty"`
}

type Assignable struct {
	Name         string `json:"name"`
	Category     string `json:"category"`
	CategoryName string `json:"category_name"`
	Resource     string `json:"resource"`
	ResourceName string `json:"resource_name"`
	Action       string `json:"action"`
	// Display is "Resource: Action" exactly as GitLab writes it in a refusal.
	Display string `json:"display"`
	// Boundaries are the boundary types the permission can be granted at.
	Boundaries []string `json:"boundaries"`
	// Permissions are the raw permissions it expands to.
	Permissions []string `json:"permissions"`
	// AvailableFor names who may hold it: granular_access_token, role, or
	// both.
	AvailableFor   []string              `json:"available_for"`
	Deprecated     bool                  `json:"deprecated,omitempty"`
	AssignableWhen []AssignableCondition `json:"assignable_when,omitempty"`
}

type AssignableCondition struct {
	Condition  string   `json:"condition"`
	Boundaries []string `json:"boundaries,omitempty"`
}

type AssignableMatch struct {
	// First is the first definition that expands to the raw permission,
	// deprecated ones included, which is the name GitLab's refusal prints.
	First string `json:"first"`
	// FirstAvailable is the first one a token can be granted: not deprecated
	// and available to a granular access token. Empty when there is none.
	FirstAvailable string `json:"first_available,omitempty"`
}

type AuthorizationCounts struct {
	AuthorizedRoutes                int `json:"authorized_routes"`
	SkippedRoutes                   int `json:"skipped_routes"`
	TodoRoutes                      int `json:"todo_routes"`
	UndeclaredRoutes                int `json:"undeclared_routes"`
	AssignablePermissions           int `json:"assignable_permissions"`
	DeprecatedAssignablePermissions int `json:"deprecated_assignable_permissions"`
	GraphQLDeclaredTypes            int `json:"graphql_declared_types"`
	// GraphQLUndeclaredTypes are the types GitLab checks and that declare
	// nothing. A fine-grained token is denied an object of every one of them
	// but two: Query and Mutation are counted here and pass, because the
	// check passes when there is neither an object nor arguments to find a
	// boundary in, which is what a root is. A reader taking this figure, or
	// Enforced without Declared, for "denied" has to set those two apart.
	GraphQLUndeclaredTypes int `json:"graphql_undeclared_types"`
	// GraphQLUncheckedUndeclaredTypes are the ones GitLab's todo rule calls
	// undeclared and its check never runs on, such as PageInfo.
	GraphQLUncheckedUndeclaredTypes int `json:"graphql_unchecked_undeclared_types"`
	GraphQLDeclaredMutations        int `json:"graphql_declared_mutations"`
	GraphQLUndeclaredMutations      int `json:"graphql_undeclared_mutations"`
}

type Boundary struct {
	BoundaryType  string    `json:"boundary_type,omitempty"`
	BoundaryParam string    `json:"boundary_param,omitempty"`
	Boundary      *Callable `json:"boundary,omitempty"`
	UnknownKeys   []string  `json:"unknown_keys,omitempty"`
}

type Callable struct {
	Callable bool   `json:"callable"`
	File     string `json:"file,omitempty"`
	Line     int    `json:"line,omitempty"`
	Text     string `json:"text,omitempty"`
}

type Condition struct {
	// Kind is Grape's own class name for it: BlockCondition for a lambda,
	// HashCondition for `if: {…}`, SymbolCondition for `if: :option`.
	Kind string `json:"kind"`
	// Inverse is true for `unless:`.
	Inverse bool `json:"inverse,omitempty"`
	// File and Line locate a block condition's lambda, repository relative.
	// A hash or a symbol condition carries neither: grape-entity keeps the
	// options it tests and nothing about where the exposure declaring it was
	// written, and the exposure records no location of its own either.
	File string `json:"file,omitempty"`
	Line int    `json:"line,omitempty"`
	// Text is those lines read back from inside the image and squeezed onto
	// one. A Proc knows where it was written and not what it says, so this is
	// the only way the condition arrives readable, and it is what a rule
	// classifies on.
	Text string `json:"text,omitempty"`
	// Hash is a hash condition's own data, as Ruby inspects it: the options
	// the presenter must be given, and the values they must hold.
	Hash string `json:"hash,omitempty"`
	// Symbol is a symbol condition's option, without its colon: the field is
	// sent when the presenter is given that option with a truthy value, which
	// is a choice of the endpoint rendering it and never of the entity.
	Symbol string `json:"symbol,omitempty"`
}

type Directive struct {
	Permissions      []string `json:"permissions,omitempty"`
	BoundaryType     string   `json:"boundary_type,omitempty"`
	Boundary         string   `json:"boundary,omitempty"`
	BoundaryArgument string   `json:"boundary_argument,omitempty"`
	RequirementGroup string   `json:"requirement_group,omitempty"`
	AssignableWhen   []string `json:"assignable_when,omitempty"`
	SkipReason       string   `json:"skip_reason,omitempty"`
	UnknownKeys      []string `json:"unknown_keys,omitempty"`
}

type Document struct {
	SchemaVersion int    `json:"schema_version"`
	Note          string `json:"note"`
	Source        Source `json:"source"`
	// Entities is every API::Entities class the instance had loaded, keyed by
	// its Ruby name (API::Entities::Project). OpenAPIName translates that to
	// the spelling the OpenAPI record uses, for a reader joining the two.
	Entities map[string]Entity `json:"entities"`
	// Routes is every endpoint Grape had mounted, in the order the router
	// holds them.
	Routes []Route `json:"routes"`
	// Features maps a licensed feature symbol to the tier that unlocks it.
	Features map[string]string `json:"features"`
	// Granular is the permission vocabulary a fine-grained token is granted
	// in, and GraphQLAuthz what the GraphQL schema demands of one. A version 4
	// record without either cannot answer what a fine-grained token reaches,
	// and the gate refuses it.
	Granular     *Granular     `json:"granular,omitempty"`
	GraphQLAuthz *GraphQLAuthz `json:"graphql_authz,omitempty"`
	// KeysetPaginators maps each of GitLab's keyset paginators, one of
	// [Probed], to the parameters its next link names, as the paginator
	// answered when the introspection had it write one. A version 5 record
	// without it was written by an introspection that does not walk keyset
	// pagination, and the gate refuses it.
	KeysetPaginators map[string][]string `json:"keyset_paginators,omitempty"`
}

type Entity struct {
	// Error is set when the class refused to describe itself, which is a fact
	// about that class rather than a reason to drop it: a silently missing
	// entity reads as one GitLab does not have.
	Error string `json:"error,omitempty"`
	// Fields are the exposures in declaration order, with everything the
	// class inherits already flattened in, because root_exposures answers for
	// the class as it will render.
	Fields []Field `json:"fields,omitempty"`
}

type Field struct {
	// Name is the key GitLab sends.
	Name string `json:"name"`
	// Attribute is the method the value comes from, recorded only when `as:`
	// made it differ from Name: the key is what a client sees and the
	// attribute is what a reader greps the source for.
	Attribute string `json:"attribute,omitempty"`
	// Using names the entity the value renders with, in the same keying as
	// Document.Entities. It is the edge that makes the record a tree rather
	// than a list.
	Using string `json:"using,omitempty"`
	// Merge is set for an exposure whose value is merged into the object
	// around it instead of being placed under Name: `expose :user, merge:
	// true, using: UserBasic` on a member sends the user's own keys on the
	// member, and no `user` key at all.
	//
	// Recording it is what keeps the record from reading as the opposite of
	// what GitLab sends. Without it a member said it carries a `user` object
	// and said nothing about the id, username and name it really carries, so
	// an audit reported the one key GitLab never sends as missing and the
	// nine it does send as invented.
	Merge bool `json:"merge,omitempty"`
	// Conditions gate the field. Empty means GitLab sends it with every
	// response of every endpoint that renders this entity.
	Conditions []Condition `json:"conditions,omitempty"`
}

type Gate struct {
	// If and Unless are the conditions as [Condition.Describe] renders them,
	// joined with " && " when a field carries several, since Grape requires
	// all of them to pass.
	If     string
	Unless string
	// Tier is the highest plan the conditions demand, empty when they demand
	// none.
	Tier string
	// Edition is "ee" when a condition was written under ee/, which is where
	// Enterprise prepends live.
	//
	// It is read from the condition's own file, so a field with no condition
	// has no location to answer from and reports nothing: an exposure records
	// where its lambda was written and not where the exposure itself was.
	//
	// Only a block condition has a file. A hash or a symbol condition carries
	// none, so a field gated by one of those alone never answers "ee", even
	// when the exposure was written under ee/: an epic's reference, gated by
	// `if: { with_reference: true }` in ee/lib/api/entities/epic.rb, reads
	// with no edition. Empty therefore means "no located condition said so",
	// never "written outside ee/".
	Edition string
}

type Granular struct {
	// Assignable are the permissions a user grants, deprecated ones kept so a
	// grant written under an older name still reads, in the file-path order
	// GitLab searches them.
	Assignable []Assignable `json:"assignable"`
	// RawPermissions are every raw permission GitLab defines.
	RawPermissions []string `json:"raw_permissions"`
	// RawToAssignable maps each raw permission some assignable expands to
	// onto the assignable GitLab names for it.
	RawToAssignable map[string]AssignableMatch `json:"raw_to_assignable"`
	// PublicAnonymous is what an anonymous caller may do on a public project
	// and group, which GitLab serves to a token whatever its grant holds.
	// Absent when the evaluation could not run, which PublicAnonymousError
	// then explains.
	PublicAnonymous      *PublicAnonymous `json:"public_anonymous,omitempty"`
	PublicAnonymousError string           `json:"public_anonymous_error,omitempty"`
	// FlagDefaultEnabled is whether fine-grained tokens are on unless an
	// administrator turns them off.
	FlagDefaultEnabled *bool `json:"flag_default_enabled,omitempty"`
}

type GraphQLAuthz struct {
	// Types are every object type, keyed by its GraphQL name.
	Types map[string]GraphQLType `json:"types"`
	// Abstract are every union and interface with the object types GitLab may
	// resolve there.
	Abstract map[string]AbstractType `json:"abstract"`
	// Mutations are keyed by the field name a document uses.
	Mutations map[string]Mutation `json:"mutations"`
	// Fields are the field-level declarations, keyed Type.field.
	Fields map[string][]Directive `json:"fields"`
	// UndeclaredByTodoRule is the set GitLab's own rule for its todo list
	// computes, so the two can be held to each other.
	UndeclaredByTodoRule TodoSet `json:"undeclared_by_todo_rule"`
	// Todo is GitLab's list of what it has not declared yet, when the image
	// ships it.
	Todo *Todo `json:"todo,omitempty"`
}

type GraphQLType struct {
	Class string `json:"class,omitempty"`
	// Enforced is whether GitLab's granular check runs on an object of the
	// type. A type outside Types::BaseObject, or one overriding authorized?
	// without calling super, is never checked whatever it declares. Query and
	// Mutation are enforced and declare nothing, and pass anyway: the check
	// passes when there is neither an object nor arguments to find a
	// boundary in, which is what the root objects are.
	Enforced bool `json:"enforced,omitempty"`
	// AuthorizedBy names the override of authorized?, when there is one.
	AuthorizedBy string `json:"authorized_by,omitempty"`
	// Abilities are the type's ability authorization, one of the two
	// conditions under which a list of it is redacted rather than nulled.
	Abilities []string    `json:"abilities,omitempty"`
	Granular  []Directive `json:"granular,omitempty"`
	// ObjectFields are the fields whose type is an object, an interface or a
	// union, with their full signature.
	ObjectFields map[string]ObjectField `json:"object_fields,omitempty"`
}

type KeysetFlag struct {
	Name string `json:"name"`
	// DefaultEnabled is whether GitLab turns the flag on unless an
	// administrator turns it off, and nil when GitLab defines no such flag.
	DefaultEnabled *bool `json:"default_enabled,omitempty"`
}

type KeysetSite struct {
	// Paginator is what would serve the page, one of [Paginators].
	Paginator string `json:"paginator"`
	// File and Line locate the call, repository relative, and Text is that
	// line read back from the image.
	File string `json:"file"`
	Line int    `json:"line"`
	Text string `json:"text,omitempty"`
	// Via names the helpers the walk went through from the route's block to
	// the call, outermost first, and is empty when the block makes it.
	Via []string `json:"via,omitempty"`
	// Cursor is the parameter, or the pair, the next page is asked by when
	// the paginator serves one. At a [PaginatorStrategies] site it is the
	// cursor of the paginator a model with keyset orderings gets, unless the
	// call passes `use_cursor: false`.
	Cursor []string `json:"cursor,omitempty"`
	// Flags are the feature flags the call is behind, in the two shapes the
	// walk reads them in: `if Feature.enabled?(:flag)` or
	// `unless Feature.disabled?(:flag)`.
	Flags []KeysetFlag `json:"flags,omitempty"`
}

type Mutation struct {
	// Name is the mutation's GraphQL name, the key GitLab's todo list uses.
	Name    string `json:"name"`
	Class   string `json:"class"`
	Payload string `json:"payload"`
	// Granular is what GitLab's runtime check reads, the mutation class's own
	// directives, and is empty for a mutation that declares nothing, which a
	// fine-grained token is refused.
	Granular []Directive `json:"granular,omitempty"`
	// FieldGranular is what GitLab's permission task reads for the mutation,
	// the Mutation field's directives (which graphql-ruby answers with any the
	// field declares itself followed by the class's), recorded only where it
	// differs from Granular. The task's todo list is generated from this
	// reading and the runtime check never makes it, so the gate refuses a
	// record carrying one: the todo list and what a token is refused would
	// then describe two requirements. Empty for every mutation at 19.4.1.
	FieldGranular []Directive `json:"field_granular,omitempty"`
}

type ObjectField struct {
	// Type is the signature as GraphQL writes it: [T!]!, [T], T!.
	Type       string `json:"type"`
	Connection bool   `json:"connection,omitempty"`
}

type Param struct {
	Required bool   `json:"required,omitempty"`
	Type     string `json:"type,omitempty"`
	Default  string `json:"default,omitempty"`
	Desc     string `json:"desc,omitempty"`
}

type PublicAnonymous struct {
	// Source says how the subjects were built.
	Source string `json:"source"`
	// Licensed is set when every licensed feature was made available for the
	// evaluation, so the set is the widest a licensed instance serves.
	Licensed bool     `json:"licensed,omitempty"`
	Project  []string `json:"project"`
	Group    []string `json:"group"`
}

type Requirement struct {
	Permissions []string
	Any         finegrained.Boundary
}

type Route struct {
	Method string `json:"method"`
	// Path is Grape's origin, without the (.:format) suffix the router adds,
	// since no caller sends that.
	Path string `json:"path"`
	// Entity is what the endpoint's `desc … success/entity` annotation names,
	// which is the same annotation GitLab's OpenAPI generator reads. It can be
	// wrong about what the endpoint really presents, and being wrong in the
	// record is better than being absent: GET /keys is annotated
	// APIEntitiesUserWithAdmin and serves an SSH key with a user under it.
	Entity  string `json:"entity,omitempty"`
	Summary string `json:"summary,omitempty"`
	// Params is what the endpoint declares it accepts, keyed by name.
	Params map[string]Param `json:"params,omitempty"`
	// Authorization is what the route demands of a fine-grained token. nil
	// means it declares nothing, which GitLab answers a fine-grained token by
	// refusing it.
	Authorization *RouteAuthorization `json:"authorization,omitempty"`
	// Keyset is every place the code the route reaches calls a keyset
	// paginator, which is where GitLab can serve the route a keyset page:
	// whether it does also depends on the relation's model and the order
	// asked for, which the record does not say ([KeysetSite]). Empty means it
	// reaches none, so GitLab ignores pagination=keyset there and answers an
	// offset page.
	Keyset []KeysetSite `json:"keyset,omitempty"`
}

type RouteAuthorization struct {
	// Permissions are raw permission names, the vocabulary GitLab checks a
	// token's expanded grant against, never the assignable names a user
	// grants.
	Permissions []string `json:"permissions,omitempty"`
	// BoundaryType is project, group, user or instance, and BoundaryParam the
	// request parameter naming the project or group when it is not the
	// default (project_id or group_id, then id).
	BoundaryType  string `json:"boundary_type,omitempty"`
	BoundaryParam string `json:"boundary_param,omitempty"`
	// Boundaries are alternatives: the token passes when it holds every
	// permission on any one of them.
	Boundaries []Boundary `json:"boundaries,omitempty"`
	// Boundary is a callable GitLab evaluates per request, which wins over
	// Boundaries and BoundaryType whenever the route declares one.
	Boundary *Callable `json:"boundary,omitempty"`
	// AdditionalScopes must each pass on their own, on top of the primary
	// requirement.
	AdditionalScopes []AdditionalScope `json:"additional_scopes,omitempty"`
	// Skip is the reason the route opts out of the fine-grained check. Any
	// reason disables it, so the grant does not decide such a route.
	Skip string `json:"skip,omitempty"`
	// Todo defers the decision; a fine-grained token is denied meanwhile.
	Todo string `json:"todo,omitempty"`
	// AssignableWhen names the conditions under which GitLab offers the
	// permission in its token form. It describes and never enforces.
	AssignableWhen []string `json:"assignable_when,omitempty"`
	// UnknownKeys are keys of the hash no reader here understands, recorded
	// so a new option is seen rather than dropped.
	UnknownKeys []string `json:"unknown_keys,omitempty"`
}

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

type Source struct {
	Image       string `json:"image"`
	Digest      string `json:"digest,omitempty"`
	Version     string `json:"version"`
	Revision    string `json:"revision,omitempty"`
	RetrievedAt string `json:"retrieved_at"`
	// SHA256 is of the introspection output as it left the container, before
	// this record wrapped it, so two runs of one image can be compared without
	// the wrapper's own fields entering the digest.
	SHA256   string `json:"sha256"`
	Entities int    `json:"entities"`
	Fields   int    `json:"fields"`
	Routes   int    `json:"routes"`
	Features int    `json:"features"`
	// AuthorizationCounts are the fine-grained figures, counted from the
	// record when it is written.
	AuthorizationCounts
	// KeysetRoutes counts the routes whose code reaches a keyset paginator,
	// from the record when it is written.
	KeysetRoutes int `json:"keyset_routes"`
}

type Todo struct {
	Digest string `json:"digest"`
	TodoSet
	// UnknownEntries are lines of a kind other than type: and mutation:.
	UnknownEntries []string `json:"unknown_entries,omitempty"`
}

type TodoSet struct {
	Types     []string `json:"types"`
	Mutations []string `json:"mutations"`
}