gitlab

type Artifacts struct {
	// NOTE: this type must be verified if we need to use it !
	// See https://docs.gitlab.com/ee/ci/yaml/#rules
	Paths     []string `yaml:"paths,omitempty"`
	When      string   `yaml:"when,omitempty"`
	Name      string   `yaml:"name,omitempty"`
	Untracked bool     `yaml:"untracked,omitempty"`
}

type Branch struct {
	Name string `json:"name"`
}

type BranchProtection struct {
	ProtectionPattern         string                        `json:"protectionPattern"`
	AllowForcePush            bool                          `json:"allowForcePush"`
	CodeOwnerApprovalRequired bool                          `json:"codeOwnerApprovalRequired"`
	MinPushAccessLevel        int                           `json:"minPushAccessLevel"`
	MinMergeAccessLevel       int                           `json:"minMergeAccessLevel"`
	PushAccessLevels          []BranchProtectionAccessLevel `json:"pushAccessLevels"`
	MergeAccessLevels         []BranchProtectionAccessLevel `json:"mergeAccessLevels"`
}

type BranchProtectionAccessLevel struct {
	AccessLevel            int    `json:"accessLevel"`
	AccessLevelDescription string `json:"accessLevelDescription"`
}

type CICDVariable struct {
	Name        string `json:"name"`
	Type        string `json:"type"`
	Environment string `json:"environment"`
	Protected   bool   `json:"protected"`
	Masked      bool   `json:"masked"`
	Hidden      bool   `json:"hidden"`
	Value       string `json:"value"`
}

type CICDVariableConf struct {
	Path        string `json:"path" validate:"required,max=300"`
	Name        string `json:"name" validate:"required,max=300"`
	Environment string `json:"environment" validate:"required,max=100"`
	Protected   bool   `json:"protected"`
	Masked      bool   `json:"masked"`
}

type CICDVariableSource struct {
	ID         int            `json:"id"`
	Name       string         `json:"name"`
	Path       string         `json:"path"`
	Visibility string         `json:"visibility"`
	Type       string         `json:"type"`
	All        []CICDVariable `json:"all"`
}

type CICatalogResource struct {
	ID                  string                     `json:"id"`
	Name                string                     `json:"name"`
	Description         string                     `json:"description"`
	Topics              []string                   `json:"topics"`
	VerificationLevel   string                     `json:"verificationLevel"`
	VisibilityLevel     string                     `json:"visibilityLevel"`
	StarCount           int                        `json:"starCount"`
	Icon                string                     `json:"icon"`
	FullPath            string                     `json:"fullPath"`
	Last30DayUsageCount int                        `json:"last30DayUsageCount"`
	LatestReleasedAt    string                     `json:"latestReleasedAt"`
	WebPath             string                     `json:"webPath"`
	Versions            []CICatalogResourceVersion `json:"versions"`
}

type CICatalogResourceVersion struct {
	Name       string        `json:"name"`
	Path       string        `json:"path"`
	Components []CIComponent `json:"components"`
}

type CIComponent struct {
	ID          string `json:"id"`
	Name        string `json:"name"`
	IncludePath string `json:"includePath"`
}

type CIConfDefault struct {
	Image interface{} `yaml:"image,omitempty"`
}

type CIConfVariable struct {
	Description string   `yaml:"description,omitempty"`
	Value       string   `yaml:"value,omitempty"`
	Options     []string `yaml:"options,omitempty"`
}

type Cache struct {
	// NOTE: this type must be verified if we need to use it !
	// See https://docs.gitlab.com/ee/ci/yaml/#rules
	Key       interface{} `yaml:"key,omitempty"`
	Paths     []string    `yaml:"paths,omitempty"`
	Policy    string      `yaml:"policy,omitempty"`
	When      string      `yaml:"when,omitempty"`
	Untracked bool        `yaml:"untracked,omitempty"`
}

type Environment struct {
	// NOTE: this type must be verified if we need to use it !
	// See https://docs.gitlab.com/ee/ci/yaml/#rules
	Name map[string]string `yaml:",inline"`
	URL  string            `yaml:"url,omitempty"`
}

type Except struct {
	// NOTE: this type must be verified if we need to use it !
	// See https://docs.gitlab.com/ee/ci/yaml/#rules
	Refs      []string          `yaml:"refs,omitempty"`
	Kinds     []string          `yaml:"kinds,omitempty"`
	Variables map[string]string `yaml:"variables,omitempty"`
}

type GitlabCIConf struct {
	Image           interface{}            `yaml:"image,omitempty"`
	GlobalVariables map[string]interface{} `yaml:"variables,omitempty"`
	Stages          []string               `yaml:"stages,omitempty"`
	BeforeScript    interface{}            `yaml:"before_script,omitempty"`
	AfterScript     interface{}            `yaml:"after_script,omitempty"`
	DefaultScript   interface{}            `yaml:"script,omitempty"`
	Default         CIConfDefault          `yaml:"default,omitempty"`
	Spec            interface{}            `yaml:"spec,omitempty"`

	Include    IncludeList            `yaml:"include,omitempty"` // Can be list of string or list of include
	GitlabJobs map[string]interface{} `yaml:",inline"`           // Can be a string or a map[string]GitlabJob
	Workflow   interface{}            `yaml:"workflow,omitempty"`
	Cache      interface{}            `yaml:"cache,omitempty"`
}

type GitlabJob struct {
	Script       interface{}            `yaml:"script,omitempty"`        // Can be both multi lines or one literal block scalar
	BeforeScript interface{}            `yaml:"before_script,omitempty"` // Can be both multi lines or one literal block scalar
	AfterScript  interface{}            `yaml:"after_script,omitempty"`  // Can be both multi lines or one literal block scalar
	Stage        string                 `yaml:"stage,omitempty"`
	Image        interface{}            `yaml:"image,omitempty"`
	Services     interface{}            `yaml:"services,omitempty"` // Can be both a list of string or a list of Serive
	Only         interface{}            `yaml:"only,omitempty"`
	Except       interface{}            `yaml:"except,omitempty"`
	Variables    map[string]interface{} `yaml:"variables,omitempty"`
	Cache        interface{}            `yaml:"cache,omitempty"`
	Dependencies interface{}            `yaml:"dependencies,omitempty"`
	Needs        interface{}            `yaml:"needs,omitempty"`
	Rules        interface{}            `yaml:"rules,omitempty"`
	Artifacts    interface{}            `yaml:"artifacts,omitempty"`
	Environment  interface{}            `yaml:"environment,omitempty"`
	When         interface{}            `yaml:"when,omitempty"`
	AllowFailure interface{}            `yaml:"allow_failure,omitempty"`
	Extends      interface{}            `yaml:"extends,omitempty"`
}

type GitlabPipelineImageData struct {
	// Gitlab CI configuration
	MergedConf *GitlabCIConf
	CiValid    bool
	CiMissing  bool

	// Default image and variables
	DefaultImage string
	InstanceVars map[string]string
	GroupVars    map[string]string
	ProjectVars  map[string]string
	GlobalVars   map[string]string

	// Images found in the pipeline
	Images []GitlabPipelineImageInfo `json:"images"`
}

type GitlabPipelineImageDataCollection struct{}

type GitlabPipelineImageInfo struct {
	Link     string `json:"link"`
	Name     string `json:"image"`
	Tag      string `json:"tag"`
	Registry string `json:"registry"`
	Job      string `json:"job"`
	// Unresolved records that the reference still contained a `$VARIABLE`
	// after substitution, so the registry, name and tag below were parsed
	// out of a placeholder rather than out of an image reference.
	//
	// This is not a small imprecision. `$CI_REGISTRY_IMAGE:$TAG` parses to
	// the "unknown" registry and either an empty tag or the literal string
	// "$TAG", and the rules then answer real questions about it: whether the
	// registry is on the trusted list, whether the tag is forbidden. Both
	// answers are arbitrary. Marking the reference lets the rules abstain on
	// that one job and keep judging every other one.
	Unresolved bool `json:"unresolved,omitempty"`
}

type GitlabPipelineImageMetrics struct {
	Total                      uint `json:"total"`
	IssueUntrusted             uint `json:"issueUntrusted"`
	IssueUntrustedDismissed    uint `json:"issueUntrustedDismissed"`
	IssueForbiddenTag          uint `json:"issueForbiddenTag"`
	IssueForbiddenTagDismissed uint `json:"issueForbiddenTagDismissed"`
}

type GitlabPipelineJobData struct {
	Name         string   `json:"name"`
	Extends      []string `json:"extends"`
	Lines        int      `json:"lines"`
	IsHardocded  bool     `json:"isHardcoded"`
	IsOverridden bool     `json:"isOverridden"`
}

type GitlabPipelineJobGitlabComponent struct {
	RepoFullPath           string `json:"repoFullPath"`
	RepoWebPath            string `json:"repoWebPath"`
	RepoName               string `json:"repoName"`
	ComponentName          string `json:"componentName"`
	ComponentLatestVersion string `json:"componentLatestVersion"`
	ComponentIncludePath   string `json:"componentIncludePath"`
}

type GitlabPipelineJobPlumberOrigin struct {
	ID            uint   `json:"id"`
	Path          string `json:"path"`
	LatestVersion string `json:"latestVersion"`
}

type GitlabPipelineOriginData struct {

	// Gitlab CI configuration
	Conf           *GitlabCIConf
	ConfString     string
	MergedConf     *GitlabCIConf
	MergedResponse *MergedCIConfResponse
	CiValid        bool
	CiMissing      bool
	CiErrors       []string // Specific CI config errors for output
	IncludesFailed []string // include locations whose fetch failed (jobs dropped from analysis, #220)
	// RefProbesFailed names the includes whose tag-vs-branch ambiguity probe
	// could not be completed.
	//
	// The probe is fail-safe by design: only a CONFIRMED tag-and-branch
	// double hit sets RefIsAmbiguous, so a probe that errors leaves the flag
	// false. That is the right default for the flag and the wrong answer for
	// the report, because false reads as "this ref is unambiguous" - a pass
	// the run has no evidence for. Recording the failures lets the caller
	// mark the control not_evaluable instead of certifying a ref it never
	// managed to look up.
	RefProbesFailed []string
	// VersionLookupsFailed names the includes whose LATEST upstream version
	// could not be looked up - the component catalogue query, or the tag
	// listing on a versioned project include.
	//
	// Same shape of hazard as RefProbesFailed and the same reason for
	// recording it. A failed lookup leaves Current empty, and the
	// up-to-date rule requires a non-empty Current, so the include is
	// silently skipped and the control reports a clean pass over includes it
	// never compared against anything. These queries hit the include's
	// SOURCE project, so they are among the first to fail for a token scoped
	// to the analyzed project.
	VersionLookupsFailed []string
	// RawConfigUnavailable records that the project's own UNMERGED CI file
	// could not be read, while the merged pipeline was obtained anyway.
	//
	// Two controls read the pre-merge document by design, and both fail
	// SILENTLY without it: the hardcoded-job map comes up empty, so every
	// job reads as contributed by an include, and the local-variable
	// comparison has nothing to compare. Neither produces a finding, so
	// both would report a clean pass over a document nobody read.
	RawConfigUnavailable bool
	LimitedAnalysis      bool

	// Origins and jobs data
	Origins []GitlabPipelineOriginDataFull

	// CI conf content
	JobMap              map[string]*GitlabPipelineJobData
	JobExtendsMap       map[string][]string
	JobHardcodedMap     map[string]bool
	JobHardcodedContent map[string]interface{}
}

type GitlabPipelineOriginDataCollection struct{}

type GitlabPipelineOriginDataFull struct {
	// Origin data generic and specific
	GitlabPipelineOriginDataGeneric
	GitlabPipelineOriginDataProjectSpecific
}

type GitlabPipelineOriginDataGeneric struct {
	OriginType          string                           `json:"originType"`
	FromPlumber         bool                             `json:"fromPlumber"`
	FromGitlabCatalog   bool                             `json:"fromGitlabCatalog"`
	PlumberOrigin       GitlabPipelineJobPlumberOrigin   `json:"plumberOrigin"`
	GitlabIncludeOrigin IncludeOriginWithoutRef          `json:"gitlabIncludeOrigin"`
	GitlabComponent     GitlabPipelineJobGitlabComponent `json:"gitlabComponent"`
	OriginHash          uint64                           `json:"originHash"`
}

type GitlabPipelineOriginDataProjectSpecific struct {
	// Data specific to this project
	Version  string `json:"version"`
	UpToDate bool   `json:"upToDate"`
	Nested   bool   `json:"nested"`
	// RefIsAmbiguous: the pinned Version resolves upstream as both a
	// tag and a branch (ref-confusion, ISSUE-402). Set by the origin
	// collector's tag+branch probe; false unless both are confirmed.
	RefIsAmbiguous bool `json:"refIsAmbiguous"`

	// Job related data
	Jobs []GitlabPipelineJobData `json:"jobs"`
}

type GitlabPipelineOriginMetrics struct {

	// Data metrics: jobs
	JobTotal     uint `json:"jobTotal"`
	JobHardcoded uint `json:"jobHardcoded"`

	// Data metrics: origin
	OriginTotal         uint `json:"originTotal"`
	OriginComponent     uint `json:"originComponent"`
	OriginLocal         uint `json:"originLocal"`
	OriginProject       uint `json:"originProject"`
	OriginRemote        uint `json:"originRemote"`
	OriginTemplate      uint `json:"originTemplate"`
	OriginGitLabCatalog uint `json:"originGitLabCatalog"`
	OriginOutdated      uint `json:"originOutdated"`
}

type GitlabProtectionAnalysisData struct {
	Branches          []string           `json:"branches"`
	BranchProtections []BranchProtection `json:"branchProtections"`
	// BranchProtectionsKnown records whether the protection listing was read
	// authoritatively. False on a 403 or any other failure, so the branch
	// controls report not-evaluable rather than reading an unreadable
	// listing as "this project protects nothing" - which is the precise
	// violation they exist to catch, and so the most damaging thing to
	// fabricate.
	//
	// The branch NAMES survive a protection failure, so the two facts are
	// tracked separately: the run still knows which branches exist.
	BranchProtectionsKnown bool                        `json:"branchProtectionsKnown"`
	MRApprovalRules        []*glab.ProjectApprovalRule `json:"mrApprovalRules"`
	// MRApprovalRulesKnown records whether the approval-rules listing was
	// read authoritatively. It stays false on a 403/404 (non-premium
	// GitLab, or a token without scope), so the approval-rule controls
	// (ISSUE-502/504) report not-evaluable rather than a false pass: an
	// unreadable listing must not make a project look compliant.
	MRApprovalRulesKnown bool                   `json:"mrApprovalRulesKnown"`
	MRApprovalSettings   *glab.ProjectApprovals `json:"mrApprovalSettings"`
	MRSettings           *glab.Project          `json:"mrSettings"`
}

type GitlabProtectionData struct {
	Branches []*GitlabProtectionDataBranch `json:"branches"`
}

type GitlabProtectionDataBranch struct {
	BranchName string `json:"branchName"`
	Default    bool   `json:"default"`
}

type GitlabProtectionDataCollection struct{}

type GitlabProtectionMetrics struct {
	Branches int `json:"branches"`
}

type GitlabVariablesAnalysisData struct {
	Variables []CICDVariable
	Known     bool
}

type Group struct {
	IdOnPlatform      int       `json:"idOnPlatform" validate:"required,number"`
	GroupIdOnPlatform int       `json:"groupIdOnPlatform" validate:"number"`
	Path              string    `json:"path" validate:"required,max=300"`
	Name              string    `json:"name" validate:"required,max=300"`
	Visibility        string    `json:"visibility" validate:"required,max=50"`
	CreatedAt         time.Time `json:"createdAt"`
}

type GroupMetadataNode struct {
	ID         string
	FullName   string
	FullPath   string
	Visibility string
	CreatedAt  time.Time
	Parent     struct {
		ID string
	}
}

type GroupProjectsResponse struct {
	Group struct {
		Projects struct {
			Nodes    []ProjectMetadataNode
			PageInfo PageInfo
		}
	}
}

type Image struct {
	Name       string        `yaml:"name,omitempty"`
	Entrypoint []string      `yaml:"entrypoint,omitempty"`
	PullPolicy StringOrSlice `yaml:"pull_policy,omitempty"`
}

type Include struct {
	Local    string      `yaml:"local,omitempty"`
	Project  string      `yaml:"project,omitempty"`
	Remote   string      `yaml:"remote,omitempty"`
	Template string      `yaml:"template,omitempty"`
	File     interface{} `yaml:"file,omitempty"` // Slice of string or string
	Ref      string      `yaml:"ref,omitempty"`
}

type IncludeJobs struct {
	// Jobs the include contributed, by name.
	Jobs []string

	// Known reports whether the attribution was established. False means the
	// include could not be resolved, and the caller must NOT read the empty
	// Jobs as "this include contributed nothing": the jobs it did contribute
	// are still in the merged pipeline with nothing attributing them
	// upstream, so rules keyed on that distinction fire on them as though the
	// project had written them.
	Known bool

	// Nested marks an include pulled in by another include rather than by
	// this project. Its jobs are attributed to the include that pulled it in,
	// so it contributes none at this level: an empty Jobs with Known true.
	Nested bool
}

type IncludeJobsRequest struct {
	// RawConfig is the project's OWN unmerged CI configuration - the file as
	// written, not the merged document. The inputs an include is called with
	// only exist there: the merged result has them already applied.
	RawConfig *GitlabCIConf

	// Includes is the merged response's include list. The result is returned
	// in THIS order and the index is the join key.
	Includes []MergedCIConfResponseInclude

	// Stages from the MERGED configuration. A component may reference a stage
	// defined at the root, and an include re-merged without them fails to
	// resolve.
	Stages []string

	// ProjectPath is the project being analysed, and is what decides whether
	// an include is nested: an include whose ContextProject differs was
	// pulled in by another include, not by this project.
	ProjectPath string

	Token  string
	APIURL string

	// SHA the includes are resolved at.
	SHA string

	Conf *configuration.Configuration
}

type IncludeList []interface{}

type IncludeOrigin struct {
	IncludeOriginWithoutRef
	Raw string `json:"raw"`
	Ref string `json:"ref"`
}

type IncludeOriginWithoutRef struct {
	Location string `json:"location"`
	Type     string `json:"type"`
	Project  string `json:"project"`
}

type InstanceGroupsResponse struct {
	Groups struct {
		Nodes    []GroupMetadataNode
		PageInfo PageInfo
	}
}

type InstanceProjectsResponse struct {
	Projects struct {
		Nodes    []ProjectMetadataNode
		PageInfo PageInfo
	}
}

type MergedCIConfResponse struct {
	CiConfig struct {
		MergedYaml string                        `json:"mergedYaml"`
		Errors     []string                      `json:"errors"`
		Warnings   []interface{}                 `json:"warnings"`
		Status     string                        `json:"status"`
		Includes   []MergedCIConfResponseInclude `json:"includes"`
		Stages     struct {
			Nodes []struct {
				Name   string `json:"name"`
				Groups struct {
					Nodes []struct {
						Name string `json:"name"`
						Size int    `json:"size"`
						Jobs struct {
							Nodes []struct {
								Name   string   `json:"name"`
								Script []string `json:"script"`
							} `json:"nodes"`
						} `json:"jobs"`
					} `json:"nodes"`
				} `json:"groups"`
			} `json:"nodes"`
		} `json:"stages"`
	} `json:"ciConfig"`
}

type MergedCIConfResponseInclude struct {
	Location       string `json:"location,omitempty"`
	Raw            string `json:"raw,omitempty"`
	Blob           string `json:"blob,omitempty"` // Contains version-specific reference (e.g., blob SHA) - critical for cache key differentiation
	ContextProject string `json:"contextProject,omitempty"`
	Type           string `json:"type,omitempty"`
	Extra          struct {
		Project string `json:"project,omitempty"`
		Ref     string `json:"ref,omitempty"`
	} `json:"extra,omitempty"`

	// RefExistsAsTag and RefExistsAsBranch report whether this include's ref
	// names an existing tag, and an existing branch, in the source project.
	//
	// Tri-state deliberately. A nil pointer means the host did not determine
	// the answer - a skipped probe, a rate limit, a cancelled request - which
	// is NOT a determined false and must not be read as one. A ref that could
	// not be checked is not an unambiguous ref, and collapsing the two is the
	// silent pass ISSUE-402 exists to catch.
	RefExistsAsTag    *bool `json:"ref_exists_as_tag,omitempty"`
	RefExistsAsBranch *bool `json:"ref_exists_as_branch,omitempty"`

	// Jobs is the list of job names this include contributed, and JobsKnown
	// whether that was established.
	//
	// The CLI derives this itself with one config-merge request per include
	// (DeriveIncludeJobs). A host that has already done so serves it here and
	// the request is skipped.
	//
	// JobsKnown is the discriminator, not the emptiness of Jobs: an empty
	// list is a REAL answer (a nested include, or one contributing only
	// variables), so it cannot double as "we did not find out". Jobs is read
	// only when JobsKnown is true; anything else falls through to the CLI's
	// own resolution, and if that cannot run the include controls degrade
	// rather than treating an unresolved include as one that contributed
	// nothing.
	Jobs      []string `json:"jobs,omitempty"`
	JobsKnown bool     `json:"jobs_known,omitempty"`

	// SourceCatalog is the CI catalogue listing for the include's source
	// project, exactly as GetGitlabCIComponentResource returns it: every
	// published version and the components each one carries.
	//
	// It is served verbatim rather than reduced to a "latest version" on
	// purpose. Which versions count is a rule - only those still carrying
	// the named component - and latestCatalogVersion applies it here. A host
	// that reduces first has to reimplement that rule to do so, and a
	// component dropped in a later version is then reported as upgradeable
	// to a version that does not contain it.
	//
	// Nil means the lookup did not complete, which leaves the component with
	// no known latest version and the up-to-date control without a verdict.
	SourceCatalog *CICatalogResource `json:"source_catalog,omitempty"`
}

type Only struct {
	// NOTE: this type must be verified if we need to use it !
	// See https://docs.gitlab.com/ee/ci/yaml/#rules
	Refs      []string          `yaml:"refs,omitempty"`
	Kinds     []string          `yaml:"kinds,omitempty"`
	Variables map[string]string `yaml:"variables,omitempty"`
}

type PageInfo struct {
	EndCursor   string
	HasNextPage bool
}

type Project struct {
	IdOnPlatform        int       `json:"idOnPlatform" validate:"required,number"`
	GroupIdOnPlatform   int       `json:"groupIdOnPlatform" validate:"required,number"`
	Path                string    `json:"path" validate:"required,max=300"`
	Name                string    `json:"name" validate:"required,max=300"`
	Visibility          string    `json:"visibility" validate:"required,max=50"`
	DefaultBranch       string    `json:"defaultBranch" validate:"max=100"`
	CiConfPath          string    `json:"ciConfPath" validate:"required,max=100"`
	LastActivityAt      time.Time `json:"lastActivityAt" validate:"required"`
	Archived            bool      `json:"archived"`
	LatestHeadCommitSha string    `json:"latestHeadCommitSha"`
	IsCatalogResource   bool      `json:"isCatalogResource"`
	//Note: IsOfficialCatalogResource is not returned by gitlab, we set it ourselves
	IsOfficialCatalogResource bool              `json:"isOfficialCatalogResource"`
	Languages                 []ProjectLanguage `json:"languages"`
	CreatedAt                 time.Time         `json:"createdAt" validate:"required"`

	// The merge-request settings mergeRequestSettingsMustBeCompliant
	// (ISSUE-506) compares against. They come from the same
	// Projects.GetProject response as everything above, so carrying them
	// costs no extra request - they were simply not projected before.
	//
	// The Plumber platform imports this package to build its own collector
	// and cannot serve a project_details lane for ISSUE-506 without them
	// (#368 ask 4). MergeMethod and SquashOption are GitLab typed strings
	// upstream; they are plain strings here because nothing in this repo
	// compares them as anything else.
	MergeMethod                     string `json:"mergeMethod"`
	SquashOption                    string `json:"squashOption"`
	MergePipelinesEnabled           bool   `json:"mergePipelinesEnabled"`
	MergeTrainsEnabled              bool   `json:"mergeTrainsEnabled"`
	AllowMergeOnSkippedPipeline     bool   `json:"allowMergeOnSkippedPipeline"`
	ResolveOutdatedDiffDiscussions  bool   `json:"resolveOutdatedDiffDiscussions"`
	PrintingMergeRequestLinkEnabled bool   `json:"printingMergeRequestLinkEnabled"`
	RemoveSourceBranchAfterMerge    bool   `json:"removeSourceBranchAfterMerge"`
}

type ProjectBranchesResponse struct {
	Project struct {
		Repository struct {
			BranchNames []string
		}
	}
}

type ProjectInfo struct {
	ID                  int // Project ID on GitLab
	Path                string
	CiConfPath          string
	DefaultBranch       string // The actual default branch from GitLab (e.g., "main")
	AnalyzeBranch       string // The branch to analyze (from --branch flag, defaults to DefaultBranch)
	LatestHeadCommitSha string
	Archived            bool
	NotFound            bool
	IsGroup             bool // True if organization is a group (vs instance-wide)
}

type ProjectLanguage struct {
	Name  string  `json:"name"`
	Share float64 `json:"share"`
}

type ProjectMetadataNode struct {
	ID                    string
	CreatedAt             time.Time
	NameWithNamespace     string
	FullPath              string
	Visibility            string
	CiConfigPathOrDefault string
	Repository            struct {
		RootRef string
		Tree    struct {
			LastCommit struct {
				Sha string
			}
		}
	}
	Group struct {
		ID string
	}
	LastActivityAt    time.Time
	Archived          bool
	IsCatalogResource bool
	Languages         []struct {
		Name  string  `json:"name"`
		Share float64 `json:"share"`
	}
}

type Resource struct {
	CPU    int `yaml:"cpu,omitempty"`
	Memory int `yaml:"memory,omitempty"`
}

type Resources struct {
	Limits *Resource `yaml:"limits,omitempty"`
}

type RetryConfig struct {
	MaxRetries     int
	InitialBackoff time.Duration
	MaxBackoff     time.Duration
	BackoffFactor  float64
}

type Rule struct {
	// NOTE: this type must be updated if we need to use it !
	// See https://docs.gitlab.com/ee/ci/yaml/#rules
	If           string   `yaml:"if"`
	ChangesFrom  []string `yaml:"changes"`
	When         string   `yaml:"when"`
	AllowFailure bool     `yaml:"allow_failure"`
}

type SecurityPolicyData struct {
	// Known is true when the linkage was read authoritatively. A nil Project
	// then means "none linked", a real state the rule fires on. False means
	// the read failed (auth error, null project, or the field is unavailable
	// on this instance), so ISSUE-601 reports not-evaluable, not a false pass.
	Known bool
	// Project is the linked security policy project, or nil when none is
	// linked. Only meaningful when Known is true.
	Project *SecurityPolicyProjectLink
}

type SecurityPolicyProject struct {
	Id       int    `json:"id"`
	Name     string `json:"name"`
	FullPath string `json:"fullPath"`
}

type SecurityPolicyProjectLink struct {
	// ID is the numeric project ID of the linked security policy project.
	ID int
	// FullPath is its namespace/path.
	FullPath string
}

type Service struct {
	Name       string      `yaml:"name,omitempty"`
	Alias      string      `yaml:"alias,omitempty"`
	Entrypoint string      `yaml:"entrypoint,omitempty"`
	Image      interface{} `yaml:"image,omitempty"`
	Command    string      `yaml:"command,omitempty"`
}

type StringOrSlice []string

type Workflow struct {
	// NOTE: this type must be verified if we need to use it !
	// See https://docs.gitlab.com/ee/ci/yaml/#rules
	Rules interface{} `yaml:"rules,omitempty"`
}