ui

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

type LoginFlowOptions struct {
	DeviceID        string
	OSInfo          string
	Signup          bool
	CallbackTimeout time.Duration
	// GetUser, if non-nil, is called after token exchange to display
	// the authenticated user's login name.
	GetUser func(ctx context.Context, host, token string) (id uuid.UUID, username string, err error)
	Color   bool
}

type LoginMethod int

type LoginResult struct {
	Cancelled bool
	Host      string    // resolved base URL
	Token     string    // set when auth succeeds (either method)
	UserID    uuid.UUID // set when GetUser is provided and succeeds
	Username  string    // set when GetUser is provided and succeeds
	Err       error
}

type OrbInitCategory struct {
	ID   string
	Name string
}

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

type OrbInitFlowOptions struct {
	// Path is the target directory. It seeds the default orb name (its final
	// segment) and the default remote URL.
	Path string
	// Private / TemplateOnly / OrgSlug / SkipGit mirror the command flags. A
	// non-zero value skips the matching prompt: --private skips the visibility
	// picker, --template-only skips the mode picker, --org skips the org prompt,
	// and --skip-git skips the git-setup confirm (forcing GitSetup off).
	Private      bool
	TemplateOnly bool
	OrgSlug      string
	SkipGit      bool
	// Branch is the default primary branch (the --branch flag, default "main").
	Branch string
	// Remote is the --remote flag; unused by the interactive flow (which always
	// prompts for it) but carried for symmetry.
	Remote string

	// ExistingRemote and ExistingBranch are what the git repository already at
	// Path has configured, empty when there is no repository or the value is not
	// set there yet. When a value is present its prompt is skipped: asking for a
	// remote URL that is sitting in .git/config is asking the author to retype
	// something the CLI can read, and lets them mistype it.
	ExistingRemote string
	ExistingBranch string

	// Download fetches and extracts the orb template into Path, removing the
	// template LICENSE when private is true. Shown behind a spinner.
	Download func(ctx context.Context, private bool) error
	// GetOrb reports whether an orb already exists under the given full name
	// ("namespace/orb"). Shown behind a spinner.
	GetOrb func(ctx context.Context, fullName string) (exists bool, err error)
	// ListCategories lists the assignable orb categories. Shown behind a spinner;
	// an empty list skips the category picker entirely.
	ListCategories func(ctx context.Context) ([]OrbInitCategory, error)

	Color bool
	// Animate reports whether the loading spinner should animate. Pass false when
	// CIRCLE_SPINNER_DISABLED is set so the loading line stays static.
	Animate bool
}

type OrbInitResult struct {
	Cancelled bool
	// Err is set when a download / orb-lookup / category-list callback failed.
	Err error

	Private      bool
	TemplateOnly bool
	OrgSlug      string
	Namespace    string
	OrbName      string
	Categories   []OrbInitCategory
	SetupContext bool
	GitSetup     bool
	Branch       string
	Remote       string
}

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

type RunCreatedFilter struct {
	Newer    bool
	Duration time.Duration
	Label    string
}

type RunGetAction int

type RunGetArtifactItem struct {
	Path      string
	URL       string
	Execution int
}

type RunGetError struct {
	Type    string
	Message string
}

type RunGetExecution struct {
	Label string
	Icon  string
	Index int
	Steps []RunGetStepItem
}

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

type RunGetFlowOptions struct {
	// Runs is an optional pre-loaded run list. When non-nil the model skips the
	// initial fetch and opens the picker immediately. When nil, Init() fetches
	// runs for the InitialScope asynchronously.
	Runs            []RunGetItem
	FetchWorkflows  func(ctx context.Context, runID uuid.UUID) ([]RunGetItem, error)
	FetchJobs       func(ctx context.Context, workflowID uuid.UUID) ([]RunGetItem, error)
	FetchExecutions func(ctx context.Context, jobID uuid.UUID) ([]RunGetExecution, error)
	// FetchStepStdout reads a step's stdout from byte offset, returning the new
	// bytes (raw, ANSI intact) and whether stdout has finished. The pager polls
	// this until terminal. FetchStepStderr reads the step's full stderr once
	// stdout terminates (stdout always completes first).
	FetchStepStdout func(ctx context.Context, jobID uuid.UUID, execution, stepNum int, offset int64) (data []byte, terminal bool, err error)
	FetchStepStderr func(ctx context.Context, jobID uuid.UUID, execution, stepNum int) ([]byte, error)
	// FetchFailedTests lists a job's failed tests for the "failed tests" picker.
	// Each item carries the message shown in the pager when the test is picked.
	FetchFailedTests func(ctx context.Context, jobID uuid.UUID) ([]RunGetTestItem, error)
	// RenderRunSummary returns the run summary (all workflows) as markdown, shown
	// in an in-flow pager when "see all workflows" is chosen so esc returns to the
	// workflow picker rather than quitting the flow. When nil (or RenderMarkdown is
	// nil) the option instead quits with RunGetActionShowRun and the caller prints
	// the summary itself. RenderMarkdown renders the returned markdown.
	RenderRunSummary func(ctx context.Context, runID uuid.UUID) (string, error)
	// RenderWorkflowSummary is the counterpart for the "all jobs in workflow"
	// option: it returns the workflow summary (all jobs) as markdown, shown in an
	// in-flow pager whose esc returns to the job picker. When nil the option quits
	// with RunGetActionShowWorkflow instead.
	RenderWorkflowSummary func(ctx context.Context, workflowID uuid.UUID) (string, error)
	// RenderJobSummary returns the job report (the short per-job summary) as
	// markdown for the "job report" option, and RenderJobOutput the full per-step
	// output report for the "full job report" option. Both are shown in an in-flow
	// pager whose esc returns to whichever picker offered them (the execution
	// picker for a parallel job, else the step picker). When nil the option quits
	// with RunGetActionShowJob / RunGetActionShowJobOutput instead.
	RenderJobSummary func(ctx context.Context, jobID uuid.UUID) (string, error)
	RenderJobOutput  func(ctx context.Context, jobID uuid.UUID) (string, error)
	// FetchArtifacts lists a job's artifacts for the artifact browser. When nil the
	// "artifacts" option is not offered at all. FetchArtifactContent reads one
	// artifact for viewing in the pager, reporting whether it is displayable text
	// (the caller decides: it applies the size cap and the binary sniff, since it
	// owns the transport). DownloadArtifacts writes the given artifacts under dir,
	// preserving their paths; when nil the download key is not offered.
	// OpenArtifactURL opens an artifact's URL in a browser; when nil that key is
	// not offered either.
	//
	// The items handed to DownloadArtifacts carry the path the browser displayed
	// (which for a job with parallel executions includes the per-execution
	// directory), so what lands on disk mirrors what was on screen for any subset
	// of the job's artifacts.
	FetchArtifacts       func(ctx context.Context, jobID uuid.UUID) ([]RunGetArtifactItem, error)
	FetchArtifactContent func(ctx context.Context, item RunGetArtifactItem) (data []byte, text bool, err error)
	DownloadArtifacts    func(ctx context.Context, items []RunGetArtifactItem, dir string) error
	OpenArtifactURL      func(url string) error
	// RenderResourceUsage returns the job's CPU and memory usage report as
	// markdown for the "resource usage" option, paged in-flow like the summaries
	// above. When nil the option quits with RunGetActionShowResourceUsage
	// instead.
	RenderResourceUsage func(ctx context.Context, jobID uuid.UUID) (string, error)
	Color               bool
	// Animate reports whether the loading spinner should animate. Pass false when
	// CIRCLE_SPINNER_DISABLED is set (or the session is non-interactive) so the
	// loading line stays static instead of repainting.
	Animate bool

	// CurrentBranch is the branch the initial Runs were fetched for (or that
	// the initial scope-based fetch will target). When FetchRuns is non-nil
	// (project available), the picker offers branch scopes and optionally "my
	// runs". When FetchRuns is nil (no project), only the "my runs" scope is
	// available.
	CurrentBranch string
	// DefaultBranch is the project's default branch. When it differs from
	// CurrentBranch a second branch scope is added to the toggle cycle. When
	// empty or equal to CurrentBranch the extra scope is omitted.
	DefaultBranch string
	// FetchRuns lists runs for a branch. The status argument is the active
	// status filter ("" = every status). The created argument is the active
	// "Created" filter from the filter dialog.
	FetchRuns func(ctx context.Context, branch, status string, created RunCreatedFilter) ([]RunGetItem, error)
	// FetchMyRuns lists the authenticated user's recent runs across all projects
	// (the counterpart to "circleci my runs"). When set, the run picker's
	// shift+tab cycle gains a "my runs" scope that fetches via this callback
	// rather than by branch; when nil the scope is omitted. status and created are
	// the active status and created filters, as for FetchRuns.
	FetchMyRuns func(ctx context.Context, status string, created RunCreatedFilter) ([]RunGetItem, error)
	// InitialScope selects which scope the picker opens on. The default
	// (ScopeCurrentBranch) starts on the current branch. Use ScopeMyRuns to
	// open on the user's runs. When FetchRuns is nil, InitialScope is ignored
	// and "my runs" is the only available scope.
	InitialScope RunScopeKind
	// StatusFilters are the pipeline statuses the "s" key cycles through, in
	// order. The picker prepends an "all statuses" (no filter) entry, so pressing
	// "s" cycles no-filter → each status → back. When empty, the "s" action is
	// omitted.
	StatusFilters []RunStatusFilter

	// RenderMarkdown renders markdown as styled text wrapped to width columns,
	// backing the "?" keyboard-shortcut help overlay the pickers offer. The flow
	// supplies its own help markdown; the caller only provides the renderer (which
	// keeps the ui package decoupled from glamour). When nil, the "?" key is inert
	// and no help hint is shown.
	RenderMarkdown func(md string, width int) string
}

type RunGetItem struct {
	Label string
	Icon  string
	ID    uuid.UUID
	// Errors, set only for run rows, are the run's config/setup errors. When the
	// run is selected they are shown beneath the workflow picker's title so a run
	// that produced no workflows (e.g. a config that failed to compile) explains
	// itself rather than presenting an empty list.
	Errors []RunGetError
	// Pending, set only for job rows, names the status of a job that has not started
	// yet — "queued", "created" — and is empty once the job is running or finished.
	// Those states are the ones the glyph column conveys least well: they sit a
	// hollow or neutral dot away from the running one, and the API's own jobs list
	// reports a queued job as "started" until the CLI corrects it
	// (apiclient.effectiveJobPhase). Such a job also has no steps to pick from — it
	// opens straight into its job report — so the picker appends the status to the
	// label, making it unmistakable beside a running job before it is picked.
	Pending string
}

type RunGetResult struct {
	Action     RunGetAction
	RunID      uuid.UUID
	WorkflowID uuid.UUID
	JobID      uuid.UUID
	// Err is set when a mid-flow fetch (workflows, jobs or steps) failed; Action
	// is RunGetActionCancel in that case.
	Err error
}

type RunGetStepItem struct {
	Label     string
	Icon      string
	Execution int
	StepNum   int
}

type RunGetTestItem struct {
	Label   string
	Icon    string
	Message string
}

type RunScopeKind int

type RunStatusFilter struct {
	Value string // pipeline.status value
	Label string // title/footer wording, e.g. "failed", "needs approval"
	Icon  string // status glyph shown in the filter dialog's status list
}

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

type RunWatchFlowOptions struct {
	RunID  uuid.UUID
	Branch string

	Color   bool
	Animate bool

	// FailFast ends the watch as soon as any job has failed, without waiting for
	// the rest of the run.
	FailFast bool

	// Timeout ends the watch once this much time has elapsed. Zero means no
	// timeout.
	Timeout time.Duration

	// PollInterval and MaxPollInterval override the default poll cadence. Zero
	// means RunWatchPollInterval / RunWatchMaxPollInterval.
	PollInterval    time.Duration
	MaxPollInterval time.Duration

	Fetch func(ctx context.Context) (RunWatchState, error)
}

type RunWatchJob struct {
	ID     uuid.UUID
	Name   string
	Symbol string
	Status string
	Type   string
	Failed bool
}

type RunWatchResult struct {
	State     RunWatchState
	Elapsed   time.Duration
	Cancelled bool
	TimedOut  bool
	FailFast  bool
	Err       error
}

type RunWatchState struct {
	Workflows []RunWatchWorkflow
	Done      bool
	Outcome   string
}

type RunWatchWorkflow struct {
	Name     string
	Symbol   string
	Status   string
	Duration string
	Jobs     []RunWatchJob
}

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