common

type App struct {
	// Experimental gates preview-stage commands and MCP tools. Read once from
	// TIGER_EXPERIMENTAL at startup; see CLAUDE.md's "Experimental Feature
	// Gating".
	Experimental bool
	// contains filtered or unexported fields
}

type CPUMemoryConfig struct {
	Shared    bool // Shared CPU/Memory
	CPUMillis int  // CPU in millicores
	MemoryGBs int  // Memory in GB
}

type CPUMemoryConfigs []CPUMemoryConfig

type CheckConstraint struct {
	Name       string   `json:"name"`
	Columns    []string `json:"columns,omitempty"` // columns involved in the check (from conkey)
	Expression string   `json:"expression"`        // full constraint def from pg_get_constraintdef, e.g. "CHECK ((age > 0))"
}

type ClientFactory func(ctx context.Context, cfg *config.Config) (api.ClientWithResponsesInterface, string, error)

type Column struct {
	Name string `json:"name"`
	Type string `json:"type"`
}

type ConnectionDetails struct {
	Role     string `json:"role,omitempty"`
	Password string `json:"password,omitempty"`
	Host     string `json:"host,omitempty"`
	Port     int    `json:"port,omitempty"`
	Database string `json:"database,omitempty"`
	IsPooler bool   `json:"is_pooler,omitempty"`
	// contains filtered or unexported fields
}

type ConnectionDetailsOptions struct {
	// Pooled determines whether to use the pooler endpoint (if available)
	Pooled bool

	// Role is the database role/username to use (e.g., "tsdbadmin")
	Role string

	// WithPassword determines whether to include the password in the output
	WithPassword bool

	// InitialPassword is an optional password to use directly (e.g., from service creation response)
	// If provided and WithPassword is true, this password will be used
	// instead of fetching from password storage. This is useful when password_storage=none.
	InitialPassword string

	// ReadOnly forces the connection into Tiger Cloud's immutable read-only
	// mode by injecting the tsdb_admin.read_only_connection GUC as a startup
	// parameter. The GUC cannot be disabled with SET for the duration of the
	// session, so this is safe to use even when the LLM controls the SQL.
	ReadOnly bool
}

type ConnectionTarget struct {
	Kind TargetKind
	ID   string
	Name string

	// Status decides whether the target accepts connections (see CheckReady).
	Status api.DeployStatus

	// Environment alone decides a session's read-only verdict, so a replica is
	// judged on its own tag rather than its primary's, and a branch, which has
	// none, counts as DEV.
	Environment api.EnvironmentTag

	Endpoint *api.Endpoint
	Pooler   *api.ConnectionPooler

	// Credentials is whose passwords the connection uses: the target itself
	// for a service or a branch, the primary for a read replica, which shares
	// them.
	Credentials CredentialOwner
}

type ConstraintType string

type ContinuousAggregateInfo struct {
	CompressionEnabled bool `json:"compression_enabled"`
	// MaterializedOnly reports whether queries against the view return only
	// already-materialized data (true) or also combine the not-yet-
	// materialized recent data in real time (false).
	MaterializedOnly bool `json:"materialized_only"`
}

type CredentialOwner struct {
	PasswordTarget

	// Name names the owner in messages.
	Name string

	// BranchServiceID is the parent service of an owner that is a branch,
	// whose password endpoint is nested under it. It is empty for a service.
	BranchServiceID string

	// Environment is the owner's own tag, which decides whether read-only mode
	// lets its passwords be changed.
	Environment api.EnvironmentTag
}

type DatabaseSchema struct {
	ID      string             `json:"id"`
	Name    string             `json:"name"`
	Schemas []NamespacedSchema `json:"schemas"`
}

type EnumSchema struct {
	Name string `json:"name"`
	// Comment is the type's COMMENT ON TYPE text. Only populated when
	// comments are requested.
	Comment string   `json:"comment,omitempty"`
	Values  []string `json:"values,omitempty"`
}

type ExclusionConstraint struct {
	Name       string `json:"name"`
	Definition string `json:"definition"` // full constraint def from pg_get_constraintdef, e.g. "EXCLUDE USING gist (circle WITH &&)"
}

type ExecuteQueryArgs struct {
	Query      string
	Parameters []string
	Role       string
	Pooled     bool

	// ReadOnly opens the session in Tiger Cloud's immutable read-only mode.
	ReadOnly bool

	// MaxRows caps the rows returned per result set and MaxBytes caps the
	// approximate serialized size of all rows returned. Zero means no cap.
	// Only the MCP tool sets them, to bound how much data reaches an agent's
	// context; the CLI returns everything the query produced.
	MaxRows  int
	MaxBytes int
}

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

type Extension struct {
	Name        string `json:"name"`
	Version     string `json:"version"`
	Schema      string `json:"schema"`
	Description string `json:"description,omitempty"`
}

type FetchServiceLogsArgs struct {
	Client    api.ClientWithResponsesInterface
	ProjectID string
	ServiceID string
	Tail      int
	Since     *time.Time
	Until     *time.Time

	// Node selects a specific service node to fetch logs from, for services
	// with HA replicas. If nil, the backend returns logs for the primary.
	Node *int
}

type FetchServiceSchemaArgs struct {
	Role   string
	Pooled bool

	// Schema, if non-empty, limits the fetch to a single namespace.
	Schema string
	// IncludeInternal disables the exclusion filters, adding catalog (pg_*)
	// and extension-owned objects.
	IncludeInternal bool
	// IncludeDefinitions fetches full object definitions (view SELECTs and
	// routine bodies), omitted by default since they can be large and may
	// embed secrets.
	IncludeDefinitions bool
	// IncludeComments fetches object comments (COMMENT ON text), omitted by
	// default to keep the output concise.
	IncludeComments bool
}

type ForeignTableInfo struct {
	Server  string   `json:"server"`            // pg_foreign_server.srvname
	Wrapper string   `json:"wrapper"`           // pg_foreign_data_wrapper.fdwname
	Options []string `json:"options,omitempty"` // ftoptions as "key=value" strings
}

type HypertableInfo struct {
	CompressionEnabled bool `json:"compression_enabled"`
	NumChunks          int  `json:"num_chunks"`
}

type IndexSchema struct {
	Name        string `json:"name"`
	Columns     string `json:"columns"` // column expressions, e.g. "status" or "created_at DESC"
	Definition  string `json:"definition,omitempty"`
	IsUnique    bool   `json:"is_unique,omitempty"`
	WhereClause string `json:"where_clause,omitempty"` // for partial indexes, empty if not partial
}

type KeyringStorage struct{}

type NamespacedSchema struct {
	Name string `json:"name"`
	// Comment is the schema's COMMENT ON SCHEMA text. Only populated when
	// comments are requested. A schema with a comment but no visible objects
	// is not surfaced just for its comment.
	Comment           string        `json:"comment,omitempty"`
	Tables            []TableSchema `json:"tables,omitempty"`
	Views             []ViewSchema  `json:"views,omitempty"`
	MaterializedViews []ViewSchema  `json:"materialized_views,omitempty"`
	Enums             []EnumSchema  `json:"enums,omitempty"`
	Functions         []Routine     `json:"functions,omitempty"`
	Procedures        []Routine     `json:"procedures,omitempty"`
}

type NoStorage struct{}

type PartitionInfo struct {
	Name string `json:"name"`
	// Schema is the partition child's schema. It is only populated when the
	// partition lives in a different schema than its parent table (PostgreSQL
	// allows this), so that callers can schema-qualify the partition
	// correctly. When empty, the partition shares its parent's schema.
	Schema string `json:"schema,omitempty"`
	// Bound is the partition's bound expression (from pg_get_expr on
	// relpartbound), e.g. "FOR VALUES FROM ('2024-01-01') TO ('2025-01-01')".
	Bound string `json:"bound,omitempty"`
}

type PasswordStorage interface {
	Save(target PasswordTarget, password string, role string) error
	Get(target PasswordTarget, role string) (string, error)
	Remove(target PasswordTarget, role string) error
	GetStorageResult(err error, password string) PasswordStorageResult
}

type PasswordStorageResult struct {
	Success bool   `json:"success"`
	Method  string `json:"method"`  // "keyring", "pgpass", or "none"
	Message string `json:"message"` // Human-readable message
}

type PasswordTarget struct {
	ProjectID string
	ID        string
	Endpoint  *api.Endpoint
}

type PgpassStorage struct{}

type QueryResult struct {
	ResultSets    []ResultSet
	ExecutionTime time.Duration
	Truncated     bool
}

type Resolved struct {
	Service        *api.Service
	Branch         *api.Branch
	ReadReplicaSet *api.ReadReplicaSet
}

type ResultSet struct {
	CommandTag   string      `json:"command_tag"`
	Columns      []Column    `json:"columns,omitempty"`
	Rows         [][]*string `json:"rows,omitzero"`
	RowsAffected int64       `json:"rows_affected"`
	Truncated    bool        `json:"truncated,omitempty"`
}

type Routine struct {
	Name string `json:"name"`
	// Arguments is the identity argument list (e.g. "integer, text"),
	// which distinguishes overloaded routines that share a name. Empty for
	// a routine that takes no arguments.
	Arguments string      `json:"arguments,omitempty"`
	Type      RoutineType `json:"type"`
	// Comment is the routine's COMMENT ON FUNCTION/PROCEDURE text. Only
	// populated when comments are requested.
	Comment    string `json:"comment,omitempty"`
	Definition string `json:"definition,omitempty"`
}

type RoutineType string

type SchemaIdent struct {
	ID   string
	Name string
}

type SchemaNotFoundError struct {
	// Schema is the requested namespace that was not found.
	Schema string
	// Available lists the schemas the connecting user can access (i.e. holds
	// USAGE on), minus the internal namespaces a default browse hides unless
	// --internal is set. It is a best-effort suggestion list, not a guarantee
	// that each schema would produce non-empty results (a schema whose
	// contents are entirely extension-owned still renders empty on a default
	// browse). It is nil when enumeration failed (in which case ListErr is
	// set).
	Available []string
	// ListErr is non-nil when listing the available schemas failed.
	ListErr error
}

type Spinner interface {
	// Update changes the spinner's displayed message.
	Update(message string)

	// Stop terminates the spinner program and waits for it to finish.
	Stop()
}

type SpinnerArgs struct {
	// Input is read so the animated spinner can see Ctrl+C. BubbleTea asks the
	// terminal for keyboard disambiguation, and terminals that honor it deliver
	// Ctrl+C as an escape sequence on stdin instead of as a SIGINT — so without
	// stdin attached the keypress has nowhere to go and Ctrl+C does nothing.
	Input io.Reader

	Output io.Writer

	Message string

	// Cancel is called when the user presses Ctrl+C. It lets the caller's
	// polling loop unwind through its own context rather than being torn down
	// from underneath.
	//
	// Set it whenever the animated spinner might be chosen: BubbleTea leaves
	// Ctrl+C as a key press rather than a SIGINT, so a spinner without a Cancel
	// gives the user no way at all to interrupt the wait.
	Cancel context.CancelFunc
}

type TableColumnSchema struct {
	Name string `json:"name"`
	Type string `json:"type"`
	// Comment is the column's COMMENT ON COLUMN text. Only populated when
	// comments are requested.
	Comment      string `json:"comment,omitempty"`
	NotNull      bool   `json:"not_null,omitempty"`
	Default      string `json:"default,omitempty"`       // empty if no default
	IsSerial     bool   `json:"is_serial,omitempty"`     // true if SERIAL/BIGSERIAL/SMALLSERIAL (has sequence, not identity)
	IdentityType string `json:"identity_type,omitempty"` // 'a' = ALWAYS, 'd' = BY DEFAULT, ” = not identity
}

type TableConstraint struct {
	Type       ConstraintType `json:"type"`
	Name       string         `json:"name"`
	Columns    []string       `json:"columns,omitempty"`
	RefTable   string         `json:"ref_table,omitempty"`   // for FK
	RefColumns []string       `json:"ref_columns,omitempty"` // for FK
}

type TableSchema struct {
	Name string `json:"name"`
	// Comment is the table's COMMENT ON TABLE text. Only populated when
	// comments are requested.
	Comment     string                `json:"comment,omitempty"`
	Columns     []TableColumnSchema   `json:"columns,omitempty"`
	Constraints []TableConstraint     `json:"constraints,omitempty"` // PK, UK, FK constraints (single and multi-column)
	Indexes     []IndexSchema         `json:"indexes,omitempty"`
	Checks      []CheckConstraint     `json:"checks,omitempty"`
	Exclusions  []ExclusionConstraint `json:"exclusions,omitempty"`
	Triggers    []TriggerSchema       `json:"triggers,omitempty"`
	// Partitions lists the direct child partitions of a partitioned table.
	// Only populated for partitioned tables (relkind 'p'). Leaf partitions
	// are normally hidden as standalone tables, but in a multi-level hierarchy
	// an intermediate partitioned table is shown both as an entry here (under
	// its parent) and as its own table carrying its sub-partitions. When a
	// single schema is requested, a leaf whose parent lives in a different
	// schema is shown as a standalone table instead (see leafPartitionExclusion).
	Partitions []PartitionInfo `json:"partitions,omitempty"`
	Hypertable *HypertableInfo `json:"hypertable,omitempty"`
	// Foreign is the FDW binding of a foreign table (relkind 'f'). Nil for
	// regular tables. Foreign tables are modeled as tables because they
	// behave like them (columns, CHECK constraints, triggers, partition
	// membership); this field is what distinguishes them.
	Foreign *ForeignTableInfo `json:"foreign,omitempty"`
}

type TargetKind int

type TriggerSchema struct {
	Name         string `json:"name"`
	Timing       string `json:"timing"`
	Manipulation string `json:"manipulation"`
	Statement    string `json:"statement"`
}

type ViewColumnSchema struct {
	Name string `json:"name"`
	Type string `json:"type"`
	// Comment is the column's COMMENT ON COLUMN text. Only populated when
	// comments are requested.
	Comment string `json:"comment,omitempty"`
}

type ViewSchema struct {
	Name string `json:"name"`
	// Comment is the view's COMMENT ON (MATERIALIZED) VIEW text. Only
	// populated when comments are requested.
	Comment string             `json:"comment,omitempty"`
	Columns []ViewColumnSchema `json:"columns,omitempty"`
	// Definition is the view's defining SELECT (from pg_get_viewdef).
	Definition string `json:"definition,omitempty"`
	// Indexes are only populated for materialized views.
	Indexes []IndexSchema `json:"indexes,omitempty"`
	// Triggers lists triggers defined on the view (e.g. INSTEAD OF
	// triggers on a regular view). Not applicable to materialized views.
	Triggers []TriggerSchema `json:"triggers,omitempty"`
	// ContinuousAggregate is TimescaleDB continuous aggregate metadata. Nil
	// for ordinary views. A continuous aggregate is a regular view (relkind
	// 'v') over an internal materialization hypertable, so it appears under
	// Views; this field is what distinguishes it. When set and definitions
	// were requested, Definition holds the user's original defining query
	// rather than the rewritten SELECT over the internal materialization
	// hypertable that pg_get_viewdef returns.
	ContinuousAggregate *ContinuousAggregateInfo `json:"continuous_aggregate,omitempty"`
}

type WaitForBranchArgs struct {
	Client    api.ClientWithResponsesInterface
	ProjectID string
	ServiceID string // the branch's parent
	BranchID  string

	// Branch is the branch as last returned by the API. Unlike
	// WaitForServiceArgs.Service, the whole branch is replaced on every poll,
	// so fields that only appear once the branch is provisioned (its endpoint)
	// are there for the caller afterwards.
	Branch *api.Branch

	// TargetStatus, Input, Output, Timeout, and TimeoutMsg work as in
	// WaitForServiceArgs.
	TargetStatus api.DeployStatus
	Input        io.Reader
	Output       io.Writer
	Timeout      time.Duration
	TimeoutMsg   string
}

type WaitForServiceArgs struct {
	Client    api.ClientWithResponsesInterface
	ProjectID string
	ServiceID string

	// Service is the service as last returned by the API. Its status decides
	// whether polling is needed at all, and it is updated in place as polling
	// proceeds so the caller can output the final state afterwards.
	Service *api.Service

	// TargetStatus ends the wait once the service reports it. Every other
	// status, including UNSTABLE, keeps polling: transitional states pass and
	// unstable services often recover on their own.
	TargetStatus api.DeployStatus

	// Input lets the spinner pick up a Ctrl+C and cancel the wait. See
	// [SpinnerArgs.Input] for why the spinner needs stdin at all.
	Input      io.Reader
	Output     io.Writer
	Timeout    time.Duration
	TimeoutMsg string
}