models

type APIConfig struct {
	// Endpoint sets API endpoint related parameters
	Endpoint EndpointConfig `mapstructure:"endPoint" json:"endPoint" validate:"required"`
	// RequestLogging sets API request logging parameters
	RequestLogging HTTPRequestLogging `mapstructure:"requestLogging" json:"requestLogging" validate:"required"`
	// EnableMCP enable the MCP endpoint
	EnableMCP bool `mapstructure:"enableMCP" json:"enableMCP"`
}

type APIServerConfig struct {
	// Server defines HTTP server parameters
	Server HTTPServerConfig `mapstructure:"service" json:"service" validate:"required"`
	// APIs defines API settings for a submodule
	APIs APIConfig `mapstructure:"apis" json:"apis" validate:"required"`
}

type ApplicationConfig struct {
	// Metrics metrics framework configuration
	Metrics MetricsConfig `mapstructure:"metrics" json:"metrics" validate:"required"`

	// API server config
	API APIServerConfig `mapstructure:"api" json:"api" validate:"required"`

	// Persistence application persistence config
	Persistence PersistenceConfig `mapstructure:"persistence" json:"persistence" validate:"required"`

	// Redis connection parameter
	Redis RedisConnectionConfig `mapstructure:"redis" json:"redis" validate:"required"`

	// Cairn cairn service integration config.
	//
	// Deliberately not `required`: that means "not the zero value", and a CairnConfig with
	// Enable false and both pointers nil IS the zero value - which is the ordinary
	// cairn-disabled deployment, not an invalid one.
	Cairn CairnConfig `mapstructure:"cairn" json:"cairn"`
}

type BaseIPCMessage struct {
	// RequestID the ID of the request
	RequestID string `json:"req_id" validate:"required"`
	// Type message type
	Type IPCMessageTypeEnumType `json:"type" validate:"required,ipc_msg_type"`
	// Sender name of the sending entity
	Sender string `json:"sender" validate:"required"`
	// Timestamp message timestamp
	Timestamp time.Time `json:"timestamp"`
}

type BootStrapError struct{ goutils.BaseError }

type CairnConfig struct {
	// Enable whether to enable the cairn integration
	Enable bool `mapstructure:"enable" json:"enable"`

	// BaseURL cairn API server base URL. rest-pty builds its endpoint paths from this.
	//
	// `omitempty` is load bearing, not decoration: `required_with` is one of the tags that
	// runs even against a nil pointer, so when Enable is false it passes and hands off to the
	// next tag — and `url` panics on any kind that is not a string. `omitempty` is what stops
	// the chain there.
	BaseURL *string `mapstructure:"baseURL" json:"baseURL,omitempty" validate:"required_with=Enable,omitempty,url"`

	// Client HTTP client configuration used when connecting to cairn
	Client *HTTPClientConfig `mapstructure:"client" json:"client,omitempty" validate:"required_with=Enable"`
}

type EndpointConfig struct {
	// PathPrefix is the end-point path prefix for the APIs
	PathPrefix string `mapstructure:"pathPrefix" json:"pathPrefix" validate:"required"`
}

type HTTPClientAuthConfig struct {
	// IssuerURL OpenID provider issuer URL
	IssuerURL string `mapstructure:"issuerURL" json:"issuerURL" validate:"required,url"`
	// ClientID OAuth client ID
	ClientID string `mapstructure:"clientID" json:"clientID" validate:"required"`
	// ClientSecret OAuth client secret
	ClientSecret string `mapstructure:"clientSecret" json:"clientSecret" validate:"required"`
	// TargetAudience target audience `aud` to acquire a token for
	TargetAudience string `mapstructure:"targetAudience" json:"targetAudience" validate:"required,url"`
}

type HTTPClientConfig struct {
	// OAuth OAuth middleware integration configuration
	OAuth *HTTPClientAuthConfig `mapstructure:"oauth,omitempty" json:"oauth,omitempty" validate:"omitempty"`
	// Retry client retry configuration. See https://github.com/go-resty/resty#retries for details
	Retry HTTPClientRetryConfig `mapstructure:"retry" json:"retry" validate:"required"`
}

type HTTPClientRetryConfig struct {
	// MaxAttempts max number of retry attempts
	MaxAttempts int `mapstructure:"maxAttempts" json:"maxAttempts" validate:"gte=0"`
	// InitWaitTimeInSec wait time before the first wait retry
	InitWaitTimeInSec uint32 `mapstructure:"initialWaitTimeInSec" json:"initialWaitTimeInSec" validate:"gte=1"`
	// MaxWaitTimeInSec max wait time
	MaxWaitTimeInSec uint32 `mapstructure:"maxWaitTimeInSec" json:"maxWaitTimeInSec" validate:"gte=1"`
}

type HTTPRequestLogging struct {
	// LogLevel output request logs at this level
	LogLevel goutils.HTTPRequestLogLevel `mapstructure:"logLevel" json:"logLevel" validate:"oneof=warn info debug"`
	// HealthLogLevel output health check logs at this level
	HealthLogLevel goutils.HTTPRequestLogLevel `mapstructure:"healthLogLevel" json:"healthLogLevel" validate:"oneof=warn info debug"`
	// RequestIDHeader is the HTTP header containing the API request ID
	RequestIDHeader string `mapstructure:"requestIDHeader" json:"requestIDHeader"`
	// DoNotLogHeaders is the list of headers to not include in logging metadata
	DoNotLogHeaders []string `mapstructure:"skipHeaders" json:"skipHeaders"`
	// LogRequestPayload whether to log request payload
	LogRequestPayload bool `mapstructure:"logRequestPayload" json:"logRequestPayload"`
}

type HTTPServerConfig struct {
	// ListenOn is the interface the HTTP server will listen on
	ListenOn string `mapstructure:"listenOn" json:"listenOn" validate:"required,ip"`
	// Port is the port the HTTP server will listen on
	Port uint16 `mapstructure:"appPort" json:"appPort" validate:"required,gt=0,lt=65536"`
	// Timeouts sets the HTTP timeout settings
	Timeouts HTTPServerTimeoutConfig `mapstructure:"timeoutSecs" json:"timeoutSecs" validate:"required"`
}

type HTTPServerTimeoutConfig struct {
	// ReadTimeout is the maximum duration for reading the entire
	// request, including the body in seconds. A zero or negative
	// value means there will be no timeout.
	ReadTimeout int `mapstructure:"read" json:"read" validate:"gte=0"`
	// WriteTimeout is the maximum duration before timing out
	// writes of the response in seconds. A zero or negative value
	// means there will be no timeout.
	WriteTimeout int `mapstructure:"write" json:"write" validate:"gte=0"`
	// IdleTimeout is the maximum amount of time to wait for the
	// next request when keep-alives are enabled in seconds. If
	// IdleTimeout is zero, the value of ReadTimeout is used. If
	// both are zero, there is no timeout.
	IdleTimeout int `mapstructure:"idle" json:"idle" validate:"gte=0"`
}

type IPCMessageEnvelope interface {
	// StringPayload return its payload as a string
	StringPayload() (string, error)
}

type IPCMessageReqRunCommands struct {
	BaseIPCMessage
	// Commands the list of commands to send to the session
	Commands []SessionInputCommand `json:"commands" validate:"required,gte=1,dive"`
}

type IPCMessageReqStopSession struct {
	BaseIPCMessage
	// Blocking whether the request is a blocking request
	Blocking bool `json:"blocking"`
}

type IPCMessageRespUniversal struct {
	BaseIPCMessage
	// Success whether the request is processed successfully
	Success bool `json:"success"`
	// ErrorMsg in case of failure, an accompanying error message
	ErrorMsg *string `json:"error,omitempty"`
}

type IPCMessageTypeEnumType string

type MetricsConfig struct {
	// Server defines HTTP server parameters
	Server HTTPServerConfig `mapstructure:"service" json:"service" validate:"required"`
	// MetricsEndpoint path to host the Prometheus metrics endpoint
	MetricsEndpoint string `mapstructure:"metricsEndpoint" json:"metricsEndpoint" validate:"required"`
	// MaxRequests max number of metrics requests in parallel to support
	MaxRequests int `mapstructure:"maxRequests" json:"maxRequests" validate:"gte=1"`
	// Features metrics framework features to enable
	Features MetricsFeatureConfig `mapstructure:"features" json:"features" validate:"required"`
}

type MetricsFeatureConfig struct {
	// EnableAppMetrics whether to enable Golang application metrics
	EnableAppMetrics bool `mapstructure:"enableAppMetrics" json:"enableAppMetrics"`
	// EnableHTTPMetrics whether to enable HTTP request tracking metrics
	EnableHTTPMetrics bool `mapstructure:"enableHTTPMetrics" json:"enableHTTPMetrics"`
}

type PTYError struct{ goutils.BaseError }

type PersistenceConfig struct {
	// SQLite persistence config
	SQLite *SQLiteConfig `mapstructure:"sqlite,omitempty" json:"sqlite,omitempty" validate:"required_without=Postgres"`

	// Postgres persistence config
	Postgres *PostgresConfig `mapstructure:"postgres,omitempty" json:"postgres,omitempty" validate:"required_without=SQLite"`
}

type PersistenceError struct{ goutils.BaseError }

type PostgresConfig struct {
	// DebugLog whether to output ORM layer debug logs
	DebugLog bool `mapstructure:"debugLog" json:"debugLog"`
	// Host Postgres server host
	Host string `mapstructure:"host" json:"host" validate:"required"`
	// Port Postgres server port
	Port uint16 `mapstructure:"port" json:"port" validate:"lte=65535,gte=0"`
	// Database the specific database to use
	Database string `mapstructure:"db" json:"db" validate:"required"`
	// User the user to connect with
	User string `mapstructure:"user" json:"user" validate:"required"`
	// Password the user password
	Password *string `json:"-" validate:"-"`
	// SSL the connection SSL settings
	SSL PostgresSSLConfig `mapstructure:"ssl" json:"ssl" validate:"required"`
}

type PostgresSSLConfig struct {
	// Enabled whether to enable SSL when connecting to Postgres
	Enabled bool `mapstructure:"enabled" json:"enabled"`
	// CAFile the CA cert file to challenge remote with
	CAFile *string `mapstructure:"caFile" json:"caFile,omitempty" validate:"omitempty,file"`
}

type RedisConnectionConfig struct {
	// Host of the server
	Host string `mapstructure:"host" json:"host" validate:"required"`
	// Port of the server
	Port uint16 `mapstructure:"port" json:"port"`
	// DBNumber number of the REDIS database
	DBNumber uint32 `mapstructure:"dbNumber" json:"dbNumber" validate:"lte=15"`
}

type SQLiteConfig struct {
	// DBFile the SQLite DB file path
	DBFile string `mapstructure:"file" json:"file" validate:"required"`
}

type Session struct {
	// ID PTY session ID
	ID string `json:"id" gorm:"column:id;primaryKey;unique" validate:"required"`

	// Name for the session, can only contain alphanumeric characters and -
	Name string `` /* 166-byte string literal not displayed */

	// Description an optional description for the session
	Description *string `json:"description" gorm:"column:description;default:null" jsonschema:"an optional description for the session"`

	// Command being executed by the session
	Command SessionCommand `json:"command" gorm:"column:command;not null" validate:"required" jsonschema:"command being executed by the session"`

	// State of the session
	State SessionStateENUMType `` /* 128-byte string literal not displayed */

	// DriverType indicate which driver the session uses
	DriverType SessionDriverTypeENUMType `` /* 135-byte string literal not displayed */

	// DriverMetadata metadata relating to the session driver
	DriverMetadata datatypes.JSON `json:"driver_metadata,omitempty" gorm:"column:driver_metadata;default:null" swaggertype:"string"`

	// WorkspaceName the cairn workspace assigned to the session. Only valid for DOCKER driver
	// sessions - a PTY session runs against the host filesystem, so there is no container to
	// mount a workspace volume into. Nil when no workspace is assigned.
	//
	// This is the name cairn holds, not a resolved workspace: rest-pty is a mount-only cairn
	// client, so it stores the name it was given and never derives the volume name or touches
	// the workspace lifecycle itself.
	WorkspaceName *string `` /* 206-byte string literal not displayed */

	// OutputBufferCapacity buffering capacity for holding command output history
	OutputBufferCapacity int64 `` /* 148-byte string literal not displayed */

	// SessionRunnerModeTypeENUMType session runner operating mode
	RunnerMode SessionRunnerModeTypeENUMType `` /* 141-byte string literal not displayed */

	// CreatedAt entry creation timestamp
	CreatedAt time.Time `json:"created_at"`
	// UpdatedAt entry update timestamp
	UpdatedAt time.Time `json:"updated_at"`
}

type SessionCommand struct {
	// Command the command being run
	Command string `json:"cmd" validate:"required" jsonschema:"the command being run"`
	// Arguments the arguments passed to the command
	Arguments []string `json:"args" jsonschema:"the arguments passed to the command"`
}

type SessionDriverDockerParams goutilsRuntime.DockerRuntimeParams

type SessionDriverPTYParams struct {
	// DisplayRows PTY number of rows (in cells).
	DisplayRows uint16 `json:"display_rows" validate:"gte=30" jsonschema:"PTY number of rows (in cells)"`

	// DisplayCol PTY number of columns (in cells).
	DisplayCols uint16 `json:"display_cols" validate:"gte=80" jsonschema:"PTY number of columns (in cells)"`
}

type SessionDriverTypeENUMType string

type SessionInputCommand struct {
	// Type session input command type
	Type SessionInputCommandTypeENUMType `` /* 857-byte string literal not displayed */

	/*
		Content command content if needed

		For `TEXT` type, the content is the text to write to STDIN.

		For `CTRL` type, the content is the control character (e.g. C for CTRL+C, etc.).

		For `ENTRY` type, the content is ignored

		For `RAW` type, the content is the raw input byte slice (direct capture of
		keyboard presses, including ANSI characters, escape sequences, and control
		characters) in Base64 encoding.
	*/
	Content *string `` /* 603-byte string literal not displayed */
}

type SessionInputCommandTypeENUMType string

type SessionManagerChangeOutputBufferCapError struct{ goutils.BaseError }

type SessionManagerStartSessionError struct{ goutils.BaseError }

type SessionManagerStopAllSessionsError struct{ goutils.BaseError }

type SessionManagerStopSessionError struct{ goutils.BaseError }

type SessionRunnerIPCProcessError struct{ goutils.BaseError }

type SessionRunnerModeTypeENUMType string

type SessionRunnerShutdownError struct{ goutils.BaseError }

type SessionRunnerStartUpError struct{ goutils.BaseError }

type SessionRunnerSubmitCommandError struct{ goutils.BaseError }

type SessionStateENUMType string

type ShutdownError struct{ goutils.BaseError }