nu

type Block uint64

type CellPath struct {
	Members []PathMember
	Span    Span
}

type Closure struct {
	BlockID  uint
	Captures msgpack.RawMessage
}

type Command struct {
	Signature PluginSignature
	Examples  []Example

	// callback executed on command invocation
	OnRun func(context.Context, *ExecCommand) error
}

type Config struct {

	// Logger the Plugin should use. If not provided the plugin will create
	// Error level logger which logs to stderr.
	Logger *slog.Logger

	// if assigned incoming data is also copied to this writer.
	// NB! this writer must not block!
	SniffIn io.Writer

	// if assigned outgoing data is also copied to this writer.
	// NB! this writer must not block!
	SniffOut io.Writer
}

type CustomValue interface {
	// The human-readable name of the custom value emitted by the plugin.
	Name() string
	// Whether the engine should send drop notification about this variable.
	NotifyOnDrop() bool
	// This method is called to notify the plugin that a CustomValue that had notify_on_drop set to
	// true (ie the NotifyOnDrop method returns true) was dropped in the engine - i.e., all copies
	// of it have gone out of scope.
	Dropped(ctx context.Context) error
	// Returns the result of following a numeric cell path (e.g. $custom_value.0) on the custom value.
	// This is most commonly used with custom types that act like lists or tables.
	// The result may be another custom value.
	FollowPathInt(ctx context.Context, item uint) (Value, error)
	// Returns the result of following a string cell path (e.g. $custom_value.field) on the custom value.
	// This is most commonly used with custom types that act like lists or tables.
	// The result may be another custom value.
	FollowPathString(ctx context.Context, item string) (Value, error)
	// Returns the result of evaluating an Operator on this custom value with another value.
	// The rhs Value may be any value - not just the same custom value type.
	// The result may be another custom value.
	Operation(ctx context.Context, op operator.Operator, rhs Value) (Value, error)
	// Compares the custom value to another value and returns the Ordering that should be used, if any.
	// The argument may be any value - not just the same custom value type.
	PartialCmp(ctx context.Context, v Value) Ordering
	// Returns a plain value that is representative of the custom value, or an error if this is not possible.
	// Sending a custom value back for this operation is not allowed.
	ToBaseValue(ctx context.Context) (Value, error)
}

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

type Error struct {
	Err    error   // The main message for the error
	Code   string  // A unique machine- and search-friendly error code to associate to the error. (e.g. nu::shell::missing_config_value)
	Url    string  // A link to documentation about the error, used in conjunction with "code"
	Help   string  // Additional help for the error, usually a hint about what the user might try
	Labels []Label // Labeled spans attached to the error, demonstrating to the user where the problem is
	Inner  []Error // Errors that are related to or caused this error
}

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

type Example struct {
	Example     string
	Description string
	Result      *Value
}

type ExecCommand struct {
	Name string

	// Span of the command invocation
	Head Span
	// Values of positional arguments
	Positional []Value
	// Names and values of named arguments
	Named NamedParams

	/*
		Input to the command. Is one of:

		- nil: no input;
		- Value: single value input;
		- <-chan Value: stream of Values;
		- io.ReadCloser: raw stream;
	*/
	Input any
	// contains filtered or unexported fields
}

type Filesize int64

type Flag struct {
	Long     string // long name of the flag
	Short    rune   // optional short name of the flag
	Shape    syntaxshape.SyntaxShape
	Required bool
	Desc     string
	VarId    uint
	Default  *Value
}

type Glob struct {
	Value string
	// If true, the expansion of wildcards is disabled and Value should be treated
	// as a literal path.
	NoExpand bool
}

type InOutTypes struct {
	In  types.Type
	Out types.Type
}

type IntRange struct {
	Start int64
	Step  int64
	End   int64
	Bound RangeBound // end bound kind of the range
}

type Label struct {
	Text string // The message for the label.
	Span Span   // The span in the source code that the label should point to.
}

type NamedParams map[string]Value

type Ordering int8

type PathMember interface {
	// Type indicates whether the path member is uint or string,
	// return either PathVariantInt or PathVariantString
	Type() uint

	// PathInt returns uint value of the path member, should be called
	// only when Type returns PathVariantInt
	PathInt() uint

	// PathStr returns string value of the path member, should be called
	// only when Type returns PathVariantString
	PathStr() string

	// Optional path members will not cause errors if they can't be
	// accessed - the path access will just return Nothing instead.
	Optional() bool

	// Is the path element case-sensitive (true) or case-insensitive (false).
	CaseSensitive() bool

	Span() Span
	// contains filtered or unexported methods
}

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

type PluginSignature struct {
	Name string
	// This should be a single sentence as it is the part shown for example in the completion menu.
	Desc string
	// Additional documentation of the command.
	Description        string
	SearchTerms        []string
	Category           string // https://docs.rs/nu-protocol/latest/nu_protocol/enum.Category.html
	RequiredPositional []PositionalArg
	OptionalPositional []PositionalArg
	RestPositional     *PositionalArg

	// The "help" (short "h") flag will be added automatically when plugin
	// is created, do not use these names for other flags or arguments.
	Named                []Flag
	InputOutputTypes     []InOutTypes
	IsFilter             bool
	CreatesScope         bool
	AllowsUnknownArgs    bool
	AllowMissingExamples bool
}

type PositionalArg struct {
	Name    string
	Desc    string
	Shape   syntaxshape.SyntaxShape
	VarId   uint
	Default *Value
}

type RangeBound uint8

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

type Record map[string]Value

type Span struct {
	Start int `msgpack:"start"`
	End   int `msgpack:"end"`
}

type Value struct {
	Value any
	Span  Span
}