types

type ArrowTable interface {
	SetInfo(info string)
	Info() string
	// SetGeometryInfo attaches per-field geometry metadata to this table.
	// Populated by the query planner (engine side) or the IPC client reader
	// (client side). Idempotent — last call wins. Not safe for concurrent
	// set + read; the contract is "populate once before handing to consumers".
	SetGeometryInfo(info map[string]GeometryInfo)
	// GeometryInfo returns the attached per-field geometry metadata, or an
	// empty non-nil map if none was set. Consumers use it to decide how to
	// render / decode nested utf8 geometry columns on the JSON path, and
	// (optionally) to dispatch the scanner without a byte-peek heuristic.
	GeometryInfo() map[string]GeometryInfo
	Retain()
	Release()
	MarshalJSON() ([]byte, error)
	DecodeMsgpack(dec *msgpack.Decoder) error
	EncodeMsgpack(enc *msgpack.Encoder) error
	Records() ([]arrow.RecordBatch, error)
	Reader(retain bool) (array.RecordReader, error)
	// Rows returns a cursor over this table. The cursor retains the underlying
	// Arrow resources; callers MUST call Close on the returned Rows.
	Rows() (Rows, error)
}

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

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

type CatalogSource struct {
	Name        string            `json:"name"`
	Type        CatalogSourceType `json:"type"`
	Path        string            `json:"path"`
	Description string            `json:"description"`
}

type CatalogSourceType string

type DataSource struct {
	Name        string          `json:"name"`
	Description string          `json:"description"`
	Type        DataSourceType  `json:"type"`
	Prefix      string          `json:"prefix"`
	Path        string          `json:"path"`
	AsModule    bool            `json:"as_module"`
	SelfDefined bool            `json:"self_defined"`
	ReadOnly    bool            `json:"read_only"`
	Disabled    bool            `json:"disabled"`
	Sources     []CatalogSource `json:"catalogs"`
}

type DataSourceType string

type DateTime time.Time

type EmbeddingResult struct {
	Vector       Vector `json:"vector"`
	PromptTokens int    `json:"prompt_tokens"`
	TokenCount   int    `json:"token_count"`
}

type EmbeddingsResult struct {
	Vectors      []Vector `json:"vectors"`
	TokenCount   int      `json:"token_count"`
	PromptTokens int      `json:"prompt_tokens"`
}

type GeometryDecoder func(arr arrow.Array, row int, fieldMeta arrow.Metadata) (orb.Geometry, error)

type GeometryInfo struct {
	SRID   string `json:"srid" msgpack:"srid"`
	Format string `json:"format" msgpack:"format"`
}

type JQRequest struct {
	JQ    string  `json:"jq"`
	Query Request `json:"query"`
}

type JsonValue string

type LLMMessage struct {
	Role             string        `json:"role"`
	Content          string        `json:"content"`
	ToolCalls        []LLMToolCall `json:"tool_calls,omitempty"`
	ToolCallID       string        `json:"tool_call_id,omitempty"`
	ThoughtSignature string        `json:"thought_signature,omitempty"` // Gemini 2.5+ / Anthropic: encrypted signature for multi-turn continuity
	Thinking         string        `json:"thinking,omitempty"`          // Anthropic thinking text / OpenAI reasoning summary
}

type LLMOptions struct {
	MaxTokens      int       `json:"max_tokens,omitempty"`
	Temperature    float64   `json:"temperature,omitempty"`
	TopP           float64   `json:"top_p,omitempty"`
	Stop           []string  `json:"stop,omitempty"`
	Tools          []LLMTool `json:"tools,omitempty"`
	ToolChoice     string    `json:"tool_choice,omitempty"`
	ThinkingBudget int       `json:"thinking_budget,omitempty"` // Token budget for reasoning/thinking (Anthropic, Gemini)
}

type LLMResult struct {
	Content          string        `json:"content"`
	Model            string        `json:"model"`
	FinishReason     string        `json:"finish_reason"`
	PromptTokens     int           `json:"prompt_tokens"`
	CompletionTokens int           `json:"completion_tokens"`
	TotalTokens      int           `json:"total_tokens"`
	Provider         string        `json:"provider"`
	LatencyMs        int           `json:"latency_ms"`
	ToolCalls        []LLMToolCall `json:"tool_calls"`
	ThoughtSignature string        `json:"thought_signature,omitempty"` // Gemini 2.5+ / Anthropic: encrypted signature
	Thinking         string        `json:"thinking,omitempty"`          // Anthropic thinking text / OpenAI reasoning summary
}

type LLMStreamEvent struct {
	Type             string `json:"type"`              // content_delta, reasoning, tool_use, finish, error
	Content          string `json:"content"`           // Token content (content_delta, reasoning)
	Model            string `json:"model"`             // Model identifier
	FinishReason     string `json:"finish_reason"`     // stop, length, tool_use (finish only)
	ToolCalls        string `json:"tool_calls"`        // JSON-encoded tool calls (tool_use only)
	PromptTokens     int    `json:"prompt_tokens"`     // Input token count (finish only)
	CompletionTokens int    `json:"completion_tokens"` // Output token count (finish only)
	ThoughtSignature string `json:"thought_signature"` // Gemini 2.5+ / Anthropic: encrypted signature (finish only)
	Thinking         string `json:"thinking"`          // Anthropic thinking text / OpenAI reasoning summary (finish only)
}

type LLMTool struct {
	Name        string `json:"name"`
	Description string `json:"description"`
	Parameters  any    `json:"parameters"`
}

type LLMToolCall struct {
	ID        string `json:"id"`
	Name      string `json:"name"`
	Arguments any    `json:"arguments"`
}

type ModelInfo struct {
	Name     string `json:"name"`
	Type     string `json:"type"`     // "llm" or "embedding"
	Provider string `json:"provider"` // "openai", "anthropic", "gemini"
	Model    string `json:"model"`
}

type OperationResult struct {
	Succeed bool   `json:"success"`
	Msg     string `json:"message"`
	Rows    int    `json:"affected_rows"`
	LastId  int    `json:"last_id"`
}

type Querier interface {
	Query(ctx context.Context, query string, vars map[string]any) (*Response, error)
	Subscribe(ctx context.Context, query string, vars map[string]any) (*Subscription, error)
	RegisterDataSource(ctx context.Context, ds DataSource) error
	LoadDataSource(ctx context.Context, name string) error
	UnloadDataSource(ctx context.Context, name string, opts ...UnloadOpt) error
	DataSourceStatus(ctx context.Context, name string) (string, error)
	DescribeDataSource(ctx context.Context, name string, self bool) (string, error)
}

type Request struct {
	Query         string         `json:"query"`
	Variables     map[string]any `json:"variables"`
	OperationName string         `json:"operationName,omitempty"`
	ValidateOnly  bool           `json:"validateOnly,omitempty"`
}

type Response struct {
	Data       map[string]any `json:"data,omitempty"`
	Extensions map[string]any `json:"extensions,omitempty"`
	Errors     gqlerror.List  `json:"errors,omitempty"`
}

type Rows interface {
	// Next advances the cursor to the next row. Returns false at end-of-stream
	// or on error; inspect Err() to distinguish. Calling Next after it returned
	// false is safe and returns false.
	Next() bool

	// Scan copies the current row into dest. dest MUST be a non-nil pointer to
	// a struct, a map[string]any, a slice []any, or interface{}.
	// Struct fields are resolved by `json` tag (matching Response.ScanData).
	Scan(dest any) error

	// Err returns the first error encountered during iteration, if any.
	Err() error

	// Close releases any Arrow resources held by the cursor. Idempotent.
	// Reaching end-of-stream via Next auto-releases the last retained batch;
	// explicit Close is required only for early exit from the iteration.
	Close() error

	// Columns returns the Arrow schema column names in positional order
	// (matches the []any Scan destination order).
	Columns() []string
}

type Subscription struct {
	Events <-chan SubscriptionEvent
	Cancel func()
	// contains filtered or unexported fields
}

type SubscriptionEvent struct {
	Path   string             // Data object path (e.g. "core.data_sources"). Empty for native subscriptions.
	Reader array.RecordReader // Data reader. Transport decides how to consume: graphql-ws reads all → JSON next; IPC streams batches.
}

type UnloadOpt func(*UnloadOpts)

type UnloadOpts struct {
	Hard bool
}

type UserIdentity struct {
	UserId   string
	UserName string
	Role     string
}

type Vector []float64