command

type AliasConflictPolicy string

type ArrayShape struct {
	Items    ValueShape
	MinItems *int
	MaxItems *int
}

type Artifact struct {
	Name        string `json:"name" schema:"required" doc:"logical artifact name"`
	Location    string `json:"location" schema:"required" doc:"host-resolved saved location"`
	Size        int64  `json:"size_bytes" schema:"required;minimum=0" doc:"committed byte count"`
	ContentType string `json:"content_type,omitempty" schema:"optional" doc:"response media type"`
	// contains filtered or unexported fields
}

type AuthorizationDefinition struct {
	Identities    map[Identity]IdentityAuthorization
	IdentityOrder []Identity
}

type BooleanShape struct{ Enum []bool }

type CLIEncoding string

type CLIInput struct {
	Aliases      []FlagAlias
	ValueSources []ValueSource
	Encoding     CLIEncoding
	Hidden       bool
	Deprecated   string
}

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

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

type CommandMetadata struct {
	Service       DomainName
	Command       string
	Description   string
	Risk          Risk
	Hidden        bool
	Authorization AuthorizationDefinition
}

type ConditionalScope struct {
	Scopes      []string         `json:"scopes"`
	When        string           `json:"when,omitempty"`
	Params      []string         `json:"params,omitempty"`
	Requirement ScopeRequirement `json:"requirement"`
}

type ConstShape struct{ Value JSONValue }

type ContextOptions struct {
	Identity Identity
	DryRun   bool

	// InputStage marks a context serving Normalize or Validate. Those hooks
	// run before the high-risk confirmation gate, so the design gives them no
	// network: Validate is specified as parameter checking that issues no
	// request, and a command that reached out from there would produce remote
	// side effects the user was never asked to confirm.
	InputStage bool

	CallJSON        func(context.Context, Request) (map[string]any, error)
	Download        func(context.Context, Request, FileTarget, DownloadOptions) (Artifact, error)
	DownloadURL     func(context.Context, string, FileTarget, DownloadOptions) (Artifact, error)
	PreflightScopes func(...string) error
	CollectPages    func(context.Context, Request, bool) ([]map[string]any, HostPagination, error)
}

type DataDefinition struct {
	Shape     ValueShape
	Overrides []DataField
}

type DataField struct {
	Path        string
	Description string
	Shape       ValueShape
}

type Definition[Args any, Data any] struct {
	Metadata CommandMetadata
	Input    InputDefinition
	Output   OutputDefinition
	Hooks    Hooks[Args, Data]
}

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

type DomainName string

type DownloadOptions struct {
	Representation download.Representation
	Transfer       download.Options
	// contains filtered or unexported fields
}

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

type DryRunView struct {
	Description string
	Requests    []RequestView
	Files       []FileIntent
}

type Failure struct {
	Type      string `json:"type" schema:"required" doc:"error category"`
	Subtype   string `json:"subtype,omitempty" schema:"optional" doc:"error subtype"`
	Code      int    `json:"code,omitempty" schema:"optional" doc:"remote error code"`
	Message   string `json:"message" schema:"required" doc:"safe error message"`
	Hint      string `json:"hint,omitempty" schema:"optional" doc:"recovery hint"`
	LogID     string `json:"log_id,omitempty" schema:"optional" doc:"remote request log identifier"`
	Retryable bool   `json:"retryable,omitempty" schema:"optional" doc:"whether retry may succeed"`
}

type FileIntent struct {
	Name     string         `json:"name"`
	IfExists IfExistsPolicy `json:"if_exists"`
	Content  string         `json:"content,omitempty"`
	// contains filtered or unexported fields
}

type FileTarget struct {
	Name     string
	IfExists IfExistsPolicy
	// contains filtered or unexported fields
}

type FlagAlias struct {
	Name       string
	Mode       FlagAliasMode
	Conflict   AliasConflictPolicy
	Hidden     bool
	Deprecated bool
}

type FlagAliasMode string

type Hooks[Args any, Data any] struct {
	// Normalize folds legacy input spellings into current semantics. It runs
	// first and only when a legacy form exists.
	//
	// Normalize and Validate both run before the high-risk confirmation gate,
	// so their CommandContext carries no network: CallJSON and CollectPages
	// refuse there. A check that needs the API belongs in Execute, after the
	// user has confirmed.
	Normalize func(context.Context, CommandContext, *Args) error

	// Validate checks format, range and field combinations. Requirements the
	// schema tag already states are enforced by the framework; this hook is for
	// the rules a tag cannot express. It issues no request -- see Normalize.
	Validate func(context.Context, CommandContext, *Args) error

	// DryRun returns the requests the command would send, which the framework
	// prints instead of executing. Validate has already run, so the requests
	// follow from Args alone and the hook reports nothing back.
	DryRun func(context.Context, CommandContext, *Args) *DryRun

	// Execute carries the business logic and returns Success. It is
	// the only hook that may call the API, and it must not write to stdout --
	// the framework owns the envelope, format and exit code.
	Execute func(context.Context, CommandContext, *Args) (Result[Data], error)

	// PrettyRenderer customizes --format pretty. It is a single hook rather than
	// a map keyed by format name because pretty is the only format a business
	// command may render itself: JSON, table, CSV and NDJSON are produced by the
	// framework formatters, and a map would let a command declare an entry the
	// compiler can only reject.
	PrettyRenderer Renderer[Data]
}

type HostDefinition struct {
	Metadata   CommandMetadata
	Input      InputDefinition
	Output     OutputDefinition
	ArgsType   reflect.Type
	DataType   reflect.Type
	NewArgs    func() any
	Hooks      HostHooks
	PageOutput bool
}

type HostDomain struct {
	Name string
}

type HostHooks struct {
	Normalize func(context.Context, CommandContext, any) error
	Validate  func(context.Context, CommandContext, any) error
	DryRun    func(context.Context, CommandContext, any) *DryRun
	Execute   func(context.Context, CommandContext, any) (HostResult, error)
	Renderers map[string]func(io.Writer, any) error
}

type HostPagination struct {
	Complete  bool
	Pages     int
	Items     int
	NextToken string
}

type HostResult struct {
	Data       any
	Outcome    string
	Pagination *HostPagination
}

type Identity string

type IdentityAuthorization struct {
	RequiredScopes    []string           `json:"required_scopes"`
	ConditionalScopes []ConditionalScope `json:"conditional_scopes"`
}

type IfExistsPolicy string

type InputDefault struct {
	Set   bool
	Value JSONValue
}

type InputDefinition struct {
	Fields    []InputField
	Relations []Relation
}

type InputField struct {
	Name        string
	Description string
	Shape       ValueShape
	Default     InputDefault
	CLI         CLIInput
}

type IntegerShape struct {
	Enum    []int64
	Minimum *int64
	Maximum *int64
}

type JSONValue = any

type NullShape struct{}

type NumberShape struct {
	Enum    []float64
	Minimum *float64
	Maximum *float64
}

type ObjectShape struct {
	Fields                    []ValueField
	AdditionalProperties      bool
	AdditionalPropertiesShape ValueShape
}

type OneOfShape struct{ Variants []ValueShape }

type OutputDefinition struct {
	Data DataDefinition
	Meta ResultMetaDefinition
	Mode OutputMode

	DisableHTMLEscaping bool
}

type OutputMode string

type Page[T any] struct {
	Items []T `json:"items" schema:"required;nonnullable" doc:"items returned by the API"`
	// contains filtered or unexported fields
}

type PaginationOptions struct {
	All      bool
	MaxPages int
	Delay    time.Duration
}

type PresenceMode string

type Provided[T any] struct {
	Value T
	Set   bool
}

type Relation struct {
	Kind     RelationKind  `json:"kind"`
	Params   []string      `json:"params"`
	Presence PresenceMode  `json:"presence"`
	Stage    RelationStage `json:"stage"`
}

type RelationKind string

type RelationStage string

type Renderer[Data any] func(io.Writer, Data) error

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

type RequestView struct {
	Method      string
	Path        string
	Query       map[string]any
	Body        any
	Description string
}

type Result[Data any] struct {
	// contains filtered or unexported fields
}

type ResultMetaDefinition struct {
	Pagination bool
}

type Risk string

type ScopeRequirement string

type Set struct {
	Domain   Domain
	Commands []Command
	// contains filtered or unexported fields
}

type StringShape struct {
	Enum      []string
	Format    string
	MinLength *int
	MaxLength *int
}

type ValueField struct {
	Name        string
	Description string
	Required    bool
	Shape       ValueShape
}

type ValueShape interface {
	// contains filtered or unexported methods
}

type ValueSource string