bash.go

// Code generated by Fern. DO NOT EDIT.

package api

import (
	json "encoding/json"
	fmt "fmt"
	internal "github.com/agent-infra/sandbox-sdk-go/internal"
	big "math/big"
	time "time"
)

var (
	bashSessionCreateRequestFieldSessionId    = big.NewInt(1 << 0)
	bashSessionCreateRequestFieldExecDir      = big.NewInt(1 << 1)
	bashSessionCreateRequestFieldSnapshotPath = big.NewInt(1 << 2)
)

type BashSessionCreateRequest struct {
	// Session ID. Auto-generated if not provided.
	SessionId *string `json:"session_id,omitempty" url:"-"`
	// Working directory for the new session (absolute path)
	ExecDir *string `json:"exec_dir,omitempty" url:"-"`
	// Path to a shell snapshot script to source on session init
	SnapshotPath *string `json:"snapshot_path,omitempty" url:"-"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (b *BashSessionCreateRequest) require(field *big.Int) {
	if b.explicitFields == nil {
		b.explicitFields = big.NewInt(0)
	}
	b.explicitFields.Or(b.explicitFields, field)
}

// SetSessionId sets the SessionId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashSessionCreateRequest) SetSessionId(sessionId *string) {
	b.SessionId = sessionId
	b.require(bashSessionCreateRequestFieldSessionId)
}

// SetExecDir sets the ExecDir field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashSessionCreateRequest) SetExecDir(execDir *string) {
	b.ExecDir = execDir
	b.require(bashSessionCreateRequestFieldExecDir)
}

// SetSnapshotPath sets the SnapshotPath field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashSessionCreateRequest) SetSnapshotPath(snapshotPath *string) {
	b.SnapshotPath = snapshotPath
	b.require(bashSessionCreateRequestFieldSnapshotPath)
}

var (
	bashExecRequestFieldSessionId       = big.NewInt(1 << 0)
	bashExecRequestFieldCommand         = big.NewInt(1 << 1)
	bashExecRequestFieldExecDir         = big.NewInt(1 << 2)
	bashExecRequestFieldEnv             = big.NewInt(1 << 3)
	bashExecRequestFieldAsyncMode       = big.NewInt(1 << 4)
	bashExecRequestFieldTimeout         = big.NewInt(1 << 5)
	bashExecRequestFieldHardTimeout     = big.NewInt(1 << 6)
	bashExecRequestFieldMaxOutputLength = big.NewInt(1 << 7)
)

type BashExecRequest struct {
	// Target session ID. If not provided, a new session is created automatically. Reuse the same session_id to maintain state (env vars, cwd, etc.) across commands.
	SessionId *string `json:"session_id,omitempty" url:"-"`
	// Shell command to execute
	Command string `json:"command" url:"-"`
	// Working directory (absolute path). Takes effect on every call — if the session already exists, the working directory is updated persistently.
	ExecDir *string `json:"exec_dir,omitempty" url:"-"`
	// Extra environment variables to inject for this command only.
	Env map[string]*string `json:"env,omitempty" url:"-"`
	// If true, return immediately with running status. Use /output to poll results.
	AsyncMode *bool `json:"async_mode,omitempty" url:"-"`
	// HTTP timeout (seconds). Only effective when async_mode=false. If the command does not complete within this time, HTTP returns running status and the command continues in the background. Use /output to get results.
	Timeout *float64 `json:"timeout,omitempty" url:"-"`
	// Hard execution timeout (seconds). When reached, the process is killed and status becomes timed_out. None means no limit.
	HardTimeout *float64 `json:"hard_timeout,omitempty" url:"-"`
	// Maximum character length for stdout/stderr in the response. When output exceeds this limit, middle truncation is applied (head and tail preserved, middle replaced with a marker). Only effective in sync mode (async_mode=false). Set to 0 to disable truncation.
	MaxOutputLength *int `json:"max_output_length,omitempty" url:"-"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (b *BashExecRequest) require(field *big.Int) {
	if b.explicitFields == nil {
		b.explicitFields = big.NewInt(0)
	}
	b.explicitFields.Or(b.explicitFields, field)
}

// SetSessionId sets the SessionId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecRequest) SetSessionId(sessionId *string) {
	b.SessionId = sessionId
	b.require(bashExecRequestFieldSessionId)
}

// SetCommand sets the Command field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecRequest) SetCommand(command string) {
	b.Command = command
	b.require(bashExecRequestFieldCommand)
}

// SetExecDir sets the ExecDir field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecRequest) SetExecDir(execDir *string) {
	b.ExecDir = execDir
	b.require(bashExecRequestFieldExecDir)
}

// SetEnv sets the Env field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecRequest) SetEnv(env map[string]*string) {
	b.Env = env
	b.require(bashExecRequestFieldEnv)
}

// SetAsyncMode sets the AsyncMode field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecRequest) SetAsyncMode(asyncMode *bool) {
	b.AsyncMode = asyncMode
	b.require(bashExecRequestFieldAsyncMode)
}

// SetTimeout sets the Timeout field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecRequest) SetTimeout(timeout *float64) {
	b.Timeout = timeout
	b.require(bashExecRequestFieldTimeout)
}

// SetHardTimeout sets the HardTimeout field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecRequest) SetHardTimeout(hardTimeout *float64) {
	b.HardTimeout = hardTimeout
	b.require(bashExecRequestFieldHardTimeout)
}

// SetMaxOutputLength sets the MaxOutputLength field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecRequest) SetMaxOutputLength(maxOutputLength *int) {
	b.MaxOutputLength = maxOutputLength
	b.require(bashExecRequestFieldMaxOutputLength)
}

var (
	bashKillRequestFieldSessionId = big.NewInt(1 << 0)
	bashKillRequestFieldSignal    = big.NewInt(1 << 1)
)

type BashKillRequest struct {
	// Target session ID
	SessionId string `json:"session_id" url:"-"`
	// Signal to send: SIGTERM, SIGKILL, or SIGINT
	Signal *string `json:"signal,omitempty" url:"-"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (b *BashKillRequest) require(field *big.Int) {
	if b.explicitFields == nil {
		b.explicitFields = big.NewInt(0)
	}
	b.explicitFields.Or(b.explicitFields, field)
}

// SetSessionId sets the SessionId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashKillRequest) SetSessionId(sessionId string) {
	b.SessionId = sessionId
	b.require(bashKillRequestFieldSessionId)
}

// SetSignal sets the Signal field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashKillRequest) SetSignal(signal *string) {
	b.Signal = signal
	b.require(bashKillRequestFieldSignal)
}

var (
	bashOutputRequestFieldSessionId    = big.NewInt(1 << 0)
	bashOutputRequestFieldCommandId    = big.NewInt(1 << 1)
	bashOutputRequestFieldOffset       = big.NewInt(1 << 2)
	bashOutputRequestFieldStderrOffset = big.NewInt(1 << 3)
	bashOutputRequestFieldWait         = big.NewInt(1 << 4)
	bashOutputRequestFieldWaitTimeout  = big.NewInt(1 << 5)
)

type BashOutputRequest struct {
	// Target session ID
	SessionId string `json:"session_id" url:"-"`
	// Target a specific async command. If not set, uses session-level output.
	CommandId *string `json:"command_id,omitempty" url:"-"`
	// Stdout byte offset to read from
	Offset *int `json:"offset,omitempty" url:"-"`
	// Stderr byte offset to read from
	StderrOffset *int `json:"stderr_offset,omitempty" url:"-"`
	// If true, long-poll until new output is available or wait_timeout is reached.
	Wait *bool `json:"wait,omitempty" url:"-"`
	// Max seconds to wait for new output when wait=true.
	WaitTimeout *float64 `json:"wait_timeout,omitempty" url:"-"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (b *BashOutputRequest) require(field *big.Int) {
	if b.explicitFields == nil {
		b.explicitFields = big.NewInt(0)
	}
	b.explicitFields.Or(b.explicitFields, field)
}

// SetSessionId sets the SessionId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputRequest) SetSessionId(sessionId string) {
	b.SessionId = sessionId
	b.require(bashOutputRequestFieldSessionId)
}

// SetCommandId sets the CommandId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputRequest) SetCommandId(commandId *string) {
	b.CommandId = commandId
	b.require(bashOutputRequestFieldCommandId)
}

// SetOffset sets the Offset field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputRequest) SetOffset(offset *int) {
	b.Offset = offset
	b.require(bashOutputRequestFieldOffset)
}

// SetStderrOffset sets the StderrOffset field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputRequest) SetStderrOffset(stderrOffset *int) {
	b.StderrOffset = stderrOffset
	b.require(bashOutputRequestFieldStderrOffset)
}

// SetWait sets the Wait field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputRequest) SetWait(wait *bool) {
	b.Wait = wait
	b.require(bashOutputRequestFieldWait)
}

// SetWaitTimeout sets the WaitTimeout field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputRequest) SetWaitTimeout(waitTimeout *float64) {
	b.WaitTimeout = waitTimeout
	b.require(bashOutputRequestFieldWaitTimeout)
}

// Serializable command status info (for API responses).
var (
	bashCommandInfoFieldCommandId = big.NewInt(1 << 0)
	bashCommandInfoFieldCommand   = big.NewInt(1 << 1)
	bashCommandInfoFieldStatus    = big.NewInt(1 << 2)
	bashCommandInfoFieldExitCode  = big.NewInt(1 << 3)
)

type BashCommandInfo struct {
	// Unique command identifier
	CommandId string `json:"command_id" url:"command_id"`
	// The command string
	Command string `json:"command" url:"command"`
	// Command execution status
	Status CommandStatus `json:"status" url:"status"`
	// Exit code (when completed)
	ExitCode *int `json:"exit_code,omitempty" url:"exit_code,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (b *BashCommandInfo) GetCommandId() string {
	if b == nil {
		return ""
	}
	return b.CommandId
}

func (b *BashCommandInfo) GetCommand() string {
	if b == nil {
		return ""
	}
	return b.Command
}

func (b *BashCommandInfo) GetStatus() CommandStatus {
	if b == nil {
		return ""
	}
	return b.Status
}

func (b *BashCommandInfo) GetExitCode() *int {
	if b == nil {
		return nil
	}
	return b.ExitCode
}

func (b *BashCommandInfo) GetExtraProperties() map[string]interface{} {
	return b.extraProperties
}

func (b *BashCommandInfo) require(field *big.Int) {
	if b.explicitFields == nil {
		b.explicitFields = big.NewInt(0)
	}
	b.explicitFields.Or(b.explicitFields, field)
}

// SetCommandId sets the CommandId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashCommandInfo) SetCommandId(commandId string) {
	b.CommandId = commandId
	b.require(bashCommandInfoFieldCommandId)
}

// SetCommand sets the Command field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashCommandInfo) SetCommand(command string) {
	b.Command = command
	b.require(bashCommandInfoFieldCommand)
}

// SetStatus sets the Status field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashCommandInfo) SetStatus(status CommandStatus) {
	b.Status = status
	b.require(bashCommandInfoFieldStatus)
}

// SetExitCode sets the ExitCode field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashCommandInfo) SetExitCode(exitCode *int) {
	b.ExitCode = exitCode
	b.require(bashCommandInfoFieldExitCode)
}

func (b *BashCommandInfo) UnmarshalJSON(data []byte) error {
	type unmarshaler BashCommandInfo
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*b = BashCommandInfo(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *b)
	if err != nil {
		return err
	}
	b.extraProperties = extraProperties
	b.rawJSON = json.RawMessage(data)
	return nil
}

func (b *BashCommandInfo) MarshalJSON() ([]byte, error) {
	type embed BashCommandInfo
	var marshaler = struct {
		embed
	}{
		embed: embed(*b),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, b.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (b *BashCommandInfo) String() string {
	if len(b.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(b.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(b); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", b)
}

// Result of exec_command — returned by POST /v1/bash/exec.
var (
	bashExecResultFieldSessionId    = big.NewInt(1 << 0)
	bashExecResultFieldCommandId    = big.NewInt(1 << 1)
	bashExecResultFieldCommand      = big.NewInt(1 << 2)
	bashExecResultFieldStatus       = big.NewInt(1 << 3)
	bashExecResultFieldStdout       = big.NewInt(1 << 4)
	bashExecResultFieldStderr       = big.NewInt(1 << 5)
	bashExecResultFieldExitCode     = big.NewInt(1 << 6)
	bashExecResultFieldOffset       = big.NewInt(1 << 7)
	bashExecResultFieldStderrOffset = big.NewInt(1 << 8)
)

type BashExecResult struct {
	// Session identifier
	SessionId string `json:"session_id" url:"session_id"`
	// Unique command identifier
	CommandId string `json:"command_id" url:"command_id"`
	// The executed command
	Command string `json:"command" url:"command"`
	// Command status
	Status CommandStatus `json:"status" url:"status"`
	// Stdout output up to this point
	Stdout *string `json:"stdout,omitempty" url:"stdout,omitempty"`
	// Stderr output up to this point
	Stderr *string `json:"stderr,omitempty" url:"stderr,omitempty"`
	// Exit code (when completed)
	ExitCode *int `json:"exit_code,omitempty" url:"exit_code,omitempty"`
	// Current stdout offset for subsequent /output calls
	Offset *int `json:"offset,omitempty" url:"offset,omitempty"`
	// Current stderr offset
	StderrOffset *int `json:"stderr_offset,omitempty" url:"stderr_offset,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (b *BashExecResult) GetSessionId() string {
	if b == nil {
		return ""
	}
	return b.SessionId
}

func (b *BashExecResult) GetCommandId() string {
	if b == nil {
		return ""
	}
	return b.CommandId
}

func (b *BashExecResult) GetCommand() string {
	if b == nil {
		return ""
	}
	return b.Command
}

func (b *BashExecResult) GetStatus() CommandStatus {
	if b == nil {
		return ""
	}
	return b.Status
}

func (b *BashExecResult) GetStdout() *string {
	if b == nil {
		return nil
	}
	return b.Stdout
}

func (b *BashExecResult) GetStderr() *string {
	if b == nil {
		return nil
	}
	return b.Stderr
}

func (b *BashExecResult) GetExitCode() *int {
	if b == nil {
		return nil
	}
	return b.ExitCode
}

func (b *BashExecResult) GetOffset() *int {
	if b == nil {
		return nil
	}
	return b.Offset
}

func (b *BashExecResult) GetStderrOffset() *int {
	if b == nil {
		return nil
	}
	return b.StderrOffset
}

func (b *BashExecResult) GetExtraProperties() map[string]interface{} {
	return b.extraProperties
}

func (b *BashExecResult) require(field *big.Int) {
	if b.explicitFields == nil {
		b.explicitFields = big.NewInt(0)
	}
	b.explicitFields.Or(b.explicitFields, field)
}

// SetSessionId sets the SessionId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecResult) SetSessionId(sessionId string) {
	b.SessionId = sessionId
	b.require(bashExecResultFieldSessionId)
}

// SetCommandId sets the CommandId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecResult) SetCommandId(commandId string) {
	b.CommandId = commandId
	b.require(bashExecResultFieldCommandId)
}

// SetCommand sets the Command field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecResult) SetCommand(command string) {
	b.Command = command
	b.require(bashExecResultFieldCommand)
}

// SetStatus sets the Status field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecResult) SetStatus(status CommandStatus) {
	b.Status = status
	b.require(bashExecResultFieldStatus)
}

// SetStdout sets the Stdout field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecResult) SetStdout(stdout *string) {
	b.Stdout = stdout
	b.require(bashExecResultFieldStdout)
}

// SetStderr sets the Stderr field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecResult) SetStderr(stderr *string) {
	b.Stderr = stderr
	b.require(bashExecResultFieldStderr)
}

// SetExitCode sets the ExitCode field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecResult) SetExitCode(exitCode *int) {
	b.ExitCode = exitCode
	b.require(bashExecResultFieldExitCode)
}

// SetOffset sets the Offset field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecResult) SetOffset(offset *int) {
	b.Offset = offset
	b.require(bashExecResultFieldOffset)
}

// SetStderrOffset sets the StderrOffset field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashExecResult) SetStderrOffset(stderrOffset *int) {
	b.StderrOffset = stderrOffset
	b.require(bashExecResultFieldStderrOffset)
}

func (b *BashExecResult) UnmarshalJSON(data []byte) error {
	type unmarshaler BashExecResult
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*b = BashExecResult(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *b)
	if err != nil {
		return err
	}
	b.extraProperties = extraProperties
	b.rawJSON = json.RawMessage(data)
	return nil
}

func (b *BashExecResult) MarshalJSON() ([]byte, error) {
	type embed BashExecResult
	var marshaler = struct {
		embed
	}{
		embed: embed(*b),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, b.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (b *BashExecResult) String() string {
	if len(b.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(b.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(b); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", b)
}

// Result of get_output — returned by POST /v1/bash/output.
var (
	bashOutputResultFieldSessionId    = big.NewInt(1 << 0)
	bashOutputResultFieldStdout       = big.NewInt(1 << 1)
	bashOutputResultFieldStderr       = big.NewInt(1 << 2)
	bashOutputResultFieldOffset       = big.NewInt(1 << 3)
	bashOutputResultFieldStderrOffset = big.NewInt(1 << 4)
	bashOutputResultFieldCommand      = big.NewInt(1 << 5)
)

type BashOutputResult struct {
	// Session identifier
	SessionId string `json:"session_id" url:"session_id"`
	// New stdout data since last offset
	Stdout *string `json:"stdout,omitempty" url:"stdout,omitempty"`
	// New stderr data since last offset
	Stderr *string `json:"stderr,omitempty" url:"stderr,omitempty"`
	// Current stdout offset (use for next request)
	Offset *int `json:"offset,omitempty" url:"offset,omitempty"`
	// Current stderr offset (use for next request)
	StderrOffset *int `json:"stderr_offset,omitempty" url:"stderr_offset,omitempty"`
	// Current or most recent command status
	Command *BashCommandInfo `json:"command,omitempty" url:"command,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (b *BashOutputResult) GetSessionId() string {
	if b == nil {
		return ""
	}
	return b.SessionId
}

func (b *BashOutputResult) GetStdout() *string {
	if b == nil {
		return nil
	}
	return b.Stdout
}

func (b *BashOutputResult) GetStderr() *string {
	if b == nil {
		return nil
	}
	return b.Stderr
}

func (b *BashOutputResult) GetOffset() *int {
	if b == nil {
		return nil
	}
	return b.Offset
}

func (b *BashOutputResult) GetStderrOffset() *int {
	if b == nil {
		return nil
	}
	return b.StderrOffset
}

func (b *BashOutputResult) GetCommand() *BashCommandInfo {
	if b == nil {
		return nil
	}
	return b.Command
}

func (b *BashOutputResult) GetExtraProperties() map[string]interface{} {
	return b.extraProperties
}

func (b *BashOutputResult) require(field *big.Int) {
	if b.explicitFields == nil {
		b.explicitFields = big.NewInt(0)
	}
	b.explicitFields.Or(b.explicitFields, field)
}

// SetSessionId sets the SessionId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputResult) SetSessionId(sessionId string) {
	b.SessionId = sessionId
	b.require(bashOutputResultFieldSessionId)
}

// SetStdout sets the Stdout field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputResult) SetStdout(stdout *string) {
	b.Stdout = stdout
	b.require(bashOutputResultFieldStdout)
}

// SetStderr sets the Stderr field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputResult) SetStderr(stderr *string) {
	b.Stderr = stderr
	b.require(bashOutputResultFieldStderr)
}

// SetOffset sets the Offset field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputResult) SetOffset(offset *int) {
	b.Offset = offset
	b.require(bashOutputResultFieldOffset)
}

// SetStderrOffset sets the StderrOffset field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputResult) SetStderrOffset(stderrOffset *int) {
	b.StderrOffset = stderrOffset
	b.require(bashOutputResultFieldStderrOffset)
}

// SetCommand sets the Command field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashOutputResult) SetCommand(command *BashCommandInfo) {
	b.Command = command
	b.require(bashOutputResultFieldCommand)
}

func (b *BashOutputResult) UnmarshalJSON(data []byte) error {
	type unmarshaler BashOutputResult
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*b = BashOutputResult(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *b)
	if err != nil {
		return err
	}
	b.extraProperties = extraProperties
	b.rawJSON = json.RawMessage(data)
	return nil
}

func (b *BashOutputResult) MarshalJSON() ([]byte, error) {
	type embed BashOutputResult
	var marshaler = struct {
		embed
	}{
		embed: embed(*b),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, b.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (b *BashOutputResult) String() string {
	if len(b.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(b.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(b); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", b)
}

// Session info for listing — returned by GET /v1/bash/sessions.
var (
	bashSessionInfoFieldSessionId      = big.NewInt(1 << 0)
	bashSessionInfoFieldStatus         = big.NewInt(1 << 1)
	bashSessionInfoFieldWorkingDir     = big.NewInt(1 << 2)
	bashSessionInfoFieldCreatedAt      = big.NewInt(1 << 3)
	bashSessionInfoFieldLastUsedAt     = big.NewInt(1 << 4)
	bashSessionInfoFieldCurrentCommand = big.NewInt(1 << 5)
	bashSessionInfoFieldCommandCount   = big.NewInt(1 << 6)
)

type BashSessionInfo struct {
	// Session identifier
	SessionId string `json:"session_id" url:"session_id"`
	// Session status
	Status SessionStatus `json:"status" url:"status"`
	// Working directory
	WorkingDir string `json:"working_dir" url:"working_dir"`
	// Creation timestamp
	CreatedAt time.Time `json:"created_at" url:"created_at"`
	// Last used timestamp
	LastUsedAt time.Time `json:"last_used_at" url:"last_used_at"`
	// Currently executing command
	CurrentCommand *string `json:"current_command,omitempty" url:"current_command,omitempty"`
	// Total commands executed
	CommandCount *int `json:"command_count,omitempty" url:"command_count,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (b *BashSessionInfo) GetSessionId() string {
	if b == nil {
		return ""
	}
	return b.SessionId
}

func (b *BashSessionInfo) GetStatus() SessionStatus {
	if b == nil {
		return ""
	}
	return b.Status
}

func (b *BashSessionInfo) GetWorkingDir() string {
	if b == nil {
		return ""
	}
	return b.WorkingDir
}

func (b *BashSessionInfo) GetCreatedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.CreatedAt
}

func (b *BashSessionInfo) GetLastUsedAt() time.Time {
	if b == nil {
		return time.Time{}
	}
	return b.LastUsedAt
}

func (b *BashSessionInfo) GetCurrentCommand() *string {
	if b == nil {
		return nil
	}
	return b.CurrentCommand
}

func (b *BashSessionInfo) GetCommandCount() *int {
	if b == nil {
		return nil
	}
	return b.CommandCount
}

func (b *BashSessionInfo) GetExtraProperties() map[string]interface{} {
	return b.extraProperties
}

func (b *BashSessionInfo) require(field *big.Int) {
	if b.explicitFields == nil {
		b.explicitFields = big.NewInt(0)
	}
	b.explicitFields.Or(b.explicitFields, field)
}

// SetSessionId sets the SessionId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashSessionInfo) SetSessionId(sessionId string) {
	b.SessionId = sessionId
	b.require(bashSessionInfoFieldSessionId)
}

// SetStatus sets the Status field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashSessionInfo) SetStatus(status SessionStatus) {
	b.Status = status
	b.require(bashSessionInfoFieldStatus)
}

// SetWorkingDir sets the WorkingDir field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashSessionInfo) SetWorkingDir(workingDir string) {
	b.WorkingDir = workingDir
	b.require(bashSessionInfoFieldWorkingDir)
}

// SetCreatedAt sets the CreatedAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashSessionInfo) SetCreatedAt(createdAt time.Time) {
	b.CreatedAt = createdAt
	b.require(bashSessionInfoFieldCreatedAt)
}

// SetLastUsedAt sets the LastUsedAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashSessionInfo) SetLastUsedAt(lastUsedAt time.Time) {
	b.LastUsedAt = lastUsedAt
	b.require(bashSessionInfoFieldLastUsedAt)
}

// SetCurrentCommand sets the CurrentCommand field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashSessionInfo) SetCurrentCommand(currentCommand *string) {
	b.CurrentCommand = currentCommand
	b.require(bashSessionInfoFieldCurrentCommand)
}

// SetCommandCount sets the CommandCount field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashSessionInfo) SetCommandCount(commandCount *int) {
	b.CommandCount = commandCount
	b.require(bashSessionInfoFieldCommandCount)
}

func (b *BashSessionInfo) UnmarshalJSON(data []byte) error {
	type embed BashSessionInfo
	var unmarshaler = struct {
		embed
		CreatedAt  *internal.DateTime `json:"created_at"`
		LastUsedAt *internal.DateTime `json:"last_used_at"`
	}{
		embed: embed(*b),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*b = BashSessionInfo(unmarshaler.embed)
	b.CreatedAt = unmarshaler.CreatedAt.Time()
	b.LastUsedAt = unmarshaler.LastUsedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *b)
	if err != nil {
		return err
	}
	b.extraProperties = extraProperties
	b.rawJSON = json.RawMessage(data)
	return nil
}

func (b *BashSessionInfo) MarshalJSON() ([]byte, error) {
	type embed BashSessionInfo
	var marshaler = struct {
		embed
		CreatedAt  *internal.DateTime `json:"created_at"`
		LastUsedAt *internal.DateTime `json:"last_used_at"`
	}{
		embed:      embed(*b),
		CreatedAt:  internal.NewDateTime(b.CreatedAt),
		LastUsedAt: internal.NewDateTime(b.LastUsedAt),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, b.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (b *BashSessionInfo) String() string {
	if len(b.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(b.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(b); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", b)
}

// Status of a bash command execution.
type CommandStatus string

const (
	CommandStatusPending   CommandStatus = "pending"
	CommandStatusRunning   CommandStatus = "running"
	CommandStatusCompleted CommandStatus = "completed"
	CommandStatusTimedOut  CommandStatus = "timed_out"
	CommandStatusKilled    CommandStatus = "killed"
)

func NewCommandStatusFromString(s string) (CommandStatus, error) {
	switch s {
	case "pending":
		return CommandStatusPending, nil
	case "running":
		return CommandStatusRunning, nil
	case "completed":
		return CommandStatusCompleted, nil
	case "timed_out":
		return CommandStatusTimedOut, nil
	case "killed":
		return CommandStatusKilled, nil
	}
	var t CommandStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (c CommandStatus) Ptr() *CommandStatus {
	return &c
}

var (
	responseBashExecResultFieldSuccess = big.NewInt(1 << 0)
	responseBashExecResultFieldMessage = big.NewInt(1 << 1)
	responseBashExecResultFieldData    = big.NewInt(1 << 2)
	responseBashExecResultFieldHint    = big.NewInt(1 << 3)
)

type ResponseBashExecResult struct {
	// Whether the operation was successful
	Success *bool `json:"success,omitempty" url:"success,omitempty"`
	// Operation result message
	Message *string `json:"message,omitempty" url:"message,omitempty"`
	// Data returned from the operation
	Data *BashExecResult `json:"data,omitempty" url:"data,omitempty"`
	// Context hint for AI agents (e.g. tab changes)
	Hint *string `json:"hint,omitempty" url:"hint,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *ResponseBashExecResult) GetSuccess() *bool {
	if r == nil {
		return nil
	}
	return r.Success
}

func (r *ResponseBashExecResult) GetMessage() *string {
	if r == nil {
		return nil
	}
	return r.Message
}

func (r *ResponseBashExecResult) GetData() *BashExecResult {
	if r == nil {
		return nil
	}
	return r.Data
}

func (r *ResponseBashExecResult) GetHint() *string {
	if r == nil {
		return nil
	}
	return r.Hint
}

func (r *ResponseBashExecResult) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *ResponseBashExecResult) require(field *big.Int) {
	if r.explicitFields == nil {
		r.explicitFields = big.NewInt(0)
	}
	r.explicitFields.Or(r.explicitFields, field)
}

// SetSuccess sets the Success field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashExecResult) SetSuccess(success *bool) {
	r.Success = success
	r.require(responseBashExecResultFieldSuccess)
}

// SetMessage sets the Message field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashExecResult) SetMessage(message *string) {
	r.Message = message
	r.require(responseBashExecResultFieldMessage)
}

// SetData sets the Data field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashExecResult) SetData(data *BashExecResult) {
	r.Data = data
	r.require(responseBashExecResultFieldData)
}

// SetHint sets the Hint field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashExecResult) SetHint(hint *string) {
	r.Hint = hint
	r.require(responseBashExecResultFieldHint)
}

func (r *ResponseBashExecResult) UnmarshalJSON(data []byte) error {
	type unmarshaler ResponseBashExecResult
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = ResponseBashExecResult(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *ResponseBashExecResult) MarshalJSON() ([]byte, error) {
	type embed ResponseBashExecResult
	var marshaler = struct {
		embed
	}{
		embed: embed(*r),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, r.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (r *ResponseBashExecResult) String() string {
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}

var (
	responseBashOutputResultFieldSuccess = big.NewInt(1 << 0)
	responseBashOutputResultFieldMessage = big.NewInt(1 << 1)
	responseBashOutputResultFieldData    = big.NewInt(1 << 2)
	responseBashOutputResultFieldHint    = big.NewInt(1 << 3)
)

type ResponseBashOutputResult struct {
	// Whether the operation was successful
	Success *bool `json:"success,omitempty" url:"success,omitempty"`
	// Operation result message
	Message *string `json:"message,omitempty" url:"message,omitempty"`
	// Data returned from the operation
	Data *BashOutputResult `json:"data,omitempty" url:"data,omitempty"`
	// Context hint for AI agents (e.g. tab changes)
	Hint *string `json:"hint,omitempty" url:"hint,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *ResponseBashOutputResult) GetSuccess() *bool {
	if r == nil {
		return nil
	}
	return r.Success
}

func (r *ResponseBashOutputResult) GetMessage() *string {
	if r == nil {
		return nil
	}
	return r.Message
}

func (r *ResponseBashOutputResult) GetData() *BashOutputResult {
	if r == nil {
		return nil
	}
	return r.Data
}

func (r *ResponseBashOutputResult) GetHint() *string {
	if r == nil {
		return nil
	}
	return r.Hint
}

func (r *ResponseBashOutputResult) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *ResponseBashOutputResult) require(field *big.Int) {
	if r.explicitFields == nil {
		r.explicitFields = big.NewInt(0)
	}
	r.explicitFields.Or(r.explicitFields, field)
}

// SetSuccess sets the Success field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashOutputResult) SetSuccess(success *bool) {
	r.Success = success
	r.require(responseBashOutputResultFieldSuccess)
}

// SetMessage sets the Message field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashOutputResult) SetMessage(message *string) {
	r.Message = message
	r.require(responseBashOutputResultFieldMessage)
}

// SetData sets the Data field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashOutputResult) SetData(data *BashOutputResult) {
	r.Data = data
	r.require(responseBashOutputResultFieldData)
}

// SetHint sets the Hint field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashOutputResult) SetHint(hint *string) {
	r.Hint = hint
	r.require(responseBashOutputResultFieldHint)
}

func (r *ResponseBashOutputResult) UnmarshalJSON(data []byte) error {
	type unmarshaler ResponseBashOutputResult
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = ResponseBashOutputResult(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *ResponseBashOutputResult) MarshalJSON() ([]byte, error) {
	type embed ResponseBashOutputResult
	var marshaler = struct {
		embed
	}{
		embed: embed(*r),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, r.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (r *ResponseBashOutputResult) String() string {
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}

var (
	responseBashSessionInfoFieldSuccess = big.NewInt(1 << 0)
	responseBashSessionInfoFieldMessage = big.NewInt(1 << 1)
	responseBashSessionInfoFieldData    = big.NewInt(1 << 2)
	responseBashSessionInfoFieldHint    = big.NewInt(1 << 3)
)

type ResponseBashSessionInfo struct {
	// Whether the operation was successful
	Success *bool `json:"success,omitempty" url:"success,omitempty"`
	// Operation result message
	Message *string `json:"message,omitempty" url:"message,omitempty"`
	// Data returned from the operation
	Data *BashSessionInfo `json:"data,omitempty" url:"data,omitempty"`
	// Context hint for AI agents (e.g. tab changes)
	Hint *string `json:"hint,omitempty" url:"hint,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *ResponseBashSessionInfo) GetSuccess() *bool {
	if r == nil {
		return nil
	}
	return r.Success
}

func (r *ResponseBashSessionInfo) GetMessage() *string {
	if r == nil {
		return nil
	}
	return r.Message
}

func (r *ResponseBashSessionInfo) GetData() *BashSessionInfo {
	if r == nil {
		return nil
	}
	return r.Data
}

func (r *ResponseBashSessionInfo) GetHint() *string {
	if r == nil {
		return nil
	}
	return r.Hint
}

func (r *ResponseBashSessionInfo) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *ResponseBashSessionInfo) require(field *big.Int) {
	if r.explicitFields == nil {
		r.explicitFields = big.NewInt(0)
	}
	r.explicitFields.Or(r.explicitFields, field)
}

// SetSuccess sets the Success field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashSessionInfo) SetSuccess(success *bool) {
	r.Success = success
	r.require(responseBashSessionInfoFieldSuccess)
}

// SetMessage sets the Message field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashSessionInfo) SetMessage(message *string) {
	r.Message = message
	r.require(responseBashSessionInfoFieldMessage)
}

// SetData sets the Data field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashSessionInfo) SetData(data *BashSessionInfo) {
	r.Data = data
	r.require(responseBashSessionInfoFieldData)
}

// SetHint sets the Hint field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseBashSessionInfo) SetHint(hint *string) {
	r.Hint = hint
	r.require(responseBashSessionInfoFieldHint)
}

func (r *ResponseBashSessionInfo) UnmarshalJSON(data []byte) error {
	type unmarshaler ResponseBashSessionInfo
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = ResponseBashSessionInfo(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *ResponseBashSessionInfo) MarshalJSON() ([]byte, error) {
	type embed ResponseBashSessionInfo
	var marshaler = struct {
		embed
	}{
		embed: embed(*r),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, r.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (r *ResponseBashSessionInfo) String() string {
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}

var (
	responseListBashSessionInfoFieldSuccess = big.NewInt(1 << 0)
	responseListBashSessionInfoFieldMessage = big.NewInt(1 << 1)
	responseListBashSessionInfoFieldData    = big.NewInt(1 << 2)
	responseListBashSessionInfoFieldHint    = big.NewInt(1 << 3)
)

type ResponseListBashSessionInfo struct {
	// Whether the operation was successful
	Success *bool `json:"success,omitempty" url:"success,omitempty"`
	// Operation result message
	Message *string `json:"message,omitempty" url:"message,omitempty"`
	// Data returned from the operation
	Data []*BashSessionInfo `json:"data,omitempty" url:"data,omitempty"`
	// Context hint for AI agents (e.g. tab changes)
	Hint *string `json:"hint,omitempty" url:"hint,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *ResponseListBashSessionInfo) GetSuccess() *bool {
	if r == nil {
		return nil
	}
	return r.Success
}

func (r *ResponseListBashSessionInfo) GetMessage() *string {
	if r == nil {
		return nil
	}
	return r.Message
}

func (r *ResponseListBashSessionInfo) GetData() []*BashSessionInfo {
	if r == nil {
		return nil
	}
	return r.Data
}

func (r *ResponseListBashSessionInfo) GetHint() *string {
	if r == nil {
		return nil
	}
	return r.Hint
}

func (r *ResponseListBashSessionInfo) GetExtraProperties() map[string]interface{} {
	return r.extraProperties
}

func (r *ResponseListBashSessionInfo) require(field *big.Int) {
	if r.explicitFields == nil {
		r.explicitFields = big.NewInt(0)
	}
	r.explicitFields.Or(r.explicitFields, field)
}

// SetSuccess sets the Success field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseListBashSessionInfo) SetSuccess(success *bool) {
	r.Success = success
	r.require(responseListBashSessionInfoFieldSuccess)
}

// SetMessage sets the Message field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseListBashSessionInfo) SetMessage(message *string) {
	r.Message = message
	r.require(responseListBashSessionInfoFieldMessage)
}

// SetData sets the Data field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseListBashSessionInfo) SetData(data []*BashSessionInfo) {
	r.Data = data
	r.require(responseListBashSessionInfoFieldData)
}

// SetHint sets the Hint field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ResponseListBashSessionInfo) SetHint(hint *string) {
	r.Hint = hint
	r.require(responseListBashSessionInfoFieldHint)
}

func (r *ResponseListBashSessionInfo) UnmarshalJSON(data []byte) error {
	type unmarshaler ResponseListBashSessionInfo
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = ResponseListBashSessionInfo(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *ResponseListBashSessionInfo) MarshalJSON() ([]byte, error) {
	type embed ResponseListBashSessionInfo
	var marshaler = struct {
		embed
	}{
		embed: embed(*r),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, r.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (r *ResponseListBashSessionInfo) String() string {
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}

// Status of a pipe bash session.
type SessionStatus string

const (
	SessionStatusReady  SessionStatus = "ready"
	SessionStatusClosed SessionStatus = "closed"
)

func NewSessionStatusFromString(s string) (SessionStatus, error) {
	switch s {
	case "ready":
		return SessionStatusReady, nil
	case "closed":
		return SessionStatusClosed, nil
	}
	var t SessionStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (s SessionStatus) Ptr() *SessionStatus {
	return &s
}

var (
	bashWriteRequestFieldSessionId = big.NewInt(1 << 0)
	bashWriteRequestFieldCommandId = big.NewInt(1 << 1)
	bashWriteRequestFieldInput     = big.NewInt(1 << 2)
)

type BashWriteRequest struct {
	// Target session ID
	SessionId string `json:"session_id" url:"-"`
	// Target a specific async command. If not set, writes to current command.
	CommandId *string `json:"command_id,omitempty" url:"-"`
	// Content to write to the process stdin
	Input string `json:"input" url:"-"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`
}

func (b *BashWriteRequest) require(field *big.Int) {
	if b.explicitFields == nil {
		b.explicitFields = big.NewInt(0)
	}
	b.explicitFields.Or(b.explicitFields, field)
}

// SetSessionId sets the SessionId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashWriteRequest) SetSessionId(sessionId string) {
	b.SessionId = sessionId
	b.require(bashWriteRequestFieldSessionId)
}

// SetCommandId sets the CommandId field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashWriteRequest) SetCommandId(commandId *string) {
	b.CommandId = commandId
	b.require(bashWriteRequestFieldCommandId)
}

// SetInput sets the Input field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (b *BashWriteRequest) SetInput(input string) {
	b.Input = input
	b.require(bashWriteRequestFieldInput)
}