domain

type APIKeyCredentials struct {
	APIKey   string `json:"api_key"`
	APIToken string `json:"api_token"`
}

type AnthropicKeyCredentials struct {
	ApiKey  string `json:"api_key"`
	BaseUrl string `json:"base_url,omitempty"` // optional override, e.g. a proxy/regional endpoint
}

type ArtelIdentity struct {
	Email        string
	PasswordHash string
}

type BodyMatcher struct {
	Path   string
	Equals string
}

type CouchAccount struct {
	Uuid              uuid.UUID
	UserUuid          uuid.UUID
	CouchInstanceUuid uuid.UUID
	CouchUsername     string
	CouchPassword     string
	CreatedAt         time.Time
}

type CouchDBKeyCredentials struct {
	URL      string `json:"url"`
	Username string `json:"username"`
	Password string `json:"password"`
}

type CouchInstance struct {
	Uuid      uuid.UUID
	Url       string
	Username  string
	Password  string
	CreatedAt time.Time
}

type CouchInstanceWithAccount struct {
	Instance CouchInstance
	Account  *CouchAccount
}

type DockerHost struct {
	Uuid      uuid.UUID
	Url       string
	CreatedAt time.Time

	// CaCert/ClientCert/ClientKey are the decrypted, in-memory PEM blobs used to build a
	// TLS-configured Docker client (internal/clients/workbenchdocker). They are never populated
	// by Get/List (creds-free, admin list/view queries) — only by DockerHosts.GetWithCreds,
	// mirroring the S3Instances Get vs GetWithCreds split. Empty means "no TLS configured".
	CaCert     string
	ClientCert string
	ClientKey  string
}

type DocsSource string

type EffectiveSubscription struct {
	UserUuid         uuid.UUID
	Active           bool
	PlanKey          string
	Features         FeatureSet
	CouchQuotaBytes  int64
	S3QuotaBytes     int64
	MaxHotPlugSkills int
	MaxTotalSkills   int
}

type EmailCredentials struct {
	ImapHost string `json:"imap_host"`
	ImapPort int    `json:"imap_port"`
	SmtpHost string `json:"smtp_host"`
	SmtpPort int    `json:"smtp_port"`
	Username string `json:"username"`
	Password string `json:"password"`
}

type EmailMessage struct {
	Id      string
	From    string
	To      string
	Subject string
	Date    string
	Body    string
}

type EmailMeta struct {
	Id      string
	From    string
	Subject string
	Date    string
}

type ExternalConnection struct {
	Uuid            uuid.UUID
	UserUuid        uuid.UUID
	Provider        string
	ProviderType    artel_q.ExternalProviderType
	CredentialsJSON json.RawMessage
	Metadata        json.RawMessage
	CreatedAt       time.Time
	UpdatedAt       time.Time
}

type ExternalConnectionMeta struct {
	Uuid         uuid.UUID
	Provider     string
	ProviderType artel_q.ExternalProviderType
	DisplayName  string
	Metadata     json.RawMessage
	CreatedAt    time.Time
	UpdatedAt    time.Time
}

type FeatureSet struct {
	Emails       bool `json:"emails"`
	TaskTrackers bool `json:"task_trackers"`
	Notes        bool `json:"notes"`
	Spreadsheets bool `json:"spreadsheets"`
	Connectors   bool `json:"connectors"`
	Tract        bool `json:"tract"`
	Postgres     bool `json:"postgres"`
}

type GitlabCredentials struct {
	PersonalAccessToken string `json:"personal_access_token"`
	InstanceUrl         string `json:"instance_url"`
	WebhookSecret       string `json:"webhook_secret,omitempty"`
}

type GoogleConnectionMeta struct {
	Email  string `json:"email"`
	Scopes string `json:"scopes"`
}

type GoogleOAuthCredentials struct {
	AccessToken  string    `json:"access_token"`
	RefreshToken string    `json:"refresh_token"`
	Expiry       time.Time `json:"expiry"`
	Scope        string    `json:"scope"`
	TokenType    string    `json:"token_type"`
}

type HeaderMatcher struct {
	Header string
	Equals string
}

type HttpAction struct {
	Method  string            // GET | POST | PUT | PATCH | DELETE
	Url     string            // may contain ${{params.name}} placeholders
	Headers map[string]string // values may be static or __secrets.*
	Query   map[string]string // values may be static, ${{params.*}}, or __secrets.*
	// Body is a JSON template sent as the request body (Content-Type: application/json).
	// String leaves are interpolated the same way as Headers/Query values: whole-value
	// "__secrets.field" replacement, otherwise ${{params.*}} substitution.
	Body json.RawMessage
	// TODO: replace with a typed enum once external_connections.provider is constrained in the DB schema.
	Credentials string // external_connections.provider to resolve __secrets.*
}

type ImapAction struct {
	Operation ImapOperation
}

type ImapOperation string

type ImportAction int

type ImportResolution struct {
	Path     string // conflicting destination path, as reported by CheckImportConflicts
	Action   ImportAction
	RenameTo string // vault-relative rename target; only used when Action == ImportActionRename
}

type ListUsersReq struct {
	Paging Paging
	Search string
}

type MailServerSuggestion struct {
	Domain         string
	Smtp           string
	SmtpPort       int
	Imap           string
	ImapPort       int
	AppPasswordUrl string
}

type McpConnector struct {
	Uuid                   uuid.UUID
	McpKeyUuid             uuid.UUID
	McpName                string
	ExternalConnectionUuid uuid.UUID
	CreatedAt              time.Time
}

type McpDefinition struct {
	Name        string
	Author      string
	Description string
	Tools       []McpToolDef
	CreatedAt   time.Time

	// OwnerUserUuid is nil for a system/built-in MoM (seeded via migration), non-nil for the
	// admin who created a community connector.
	OwnerUserUuid *uuid.UUID
	IsCommunity   bool
}

type McpKey struct {
	Uuid           uuid.UUID
	VaultUuid      uuid.UUID
	UserUuid       uuid.UUID
	Name           string
	KeyHash        []byte
	KeyPreview     string
	CreatedAt      time.Time
	RevokedAt      *time.Time
	LastAccessedAt *time.Time
}

type McpKeyContext struct {
	KeyUuid   uuid.UUID
	VaultUuid uuid.UUID
	UserUuid  uuid.UUID
	CouchURL  string
	CouchDb   string
	CouchUser string
	CouchPass string
	S3        *McpKeyS3Context // nil if the vault has no linked bucket

	UseCouchDBForBinaries bool

	// Postgres is nil unless the vault has an enabled (status=ready) Postgres database.
	Postgres *McpKeyPostgresContext
}

type McpKeyPostgresContext struct {
	Host     string
	Port     int
	Database string
	Username string
	Password string
	SSLMode  string
}

type McpKeyS3Context struct {
	Endpoint  string
	Region    string
	AccessKey string
	SecretKey string
	UseSSL    bool
	PathStyle bool
	Bucket    string
}

type McpSpreadsheet struct {
	Uuid                 uuid.UUID
	UserUuid             uuid.UUID
	ExternalConnectionId uuid.UUID
	SpreadsheetId        string
	Name                 string
	CreatedAt            time.Time
}

type McpToolDef struct {
	ApiDescription ToolApiDescription
	OutputSchema   ToolSchema
	Action         ToolAction
}

type McpToolRef struct {
	McpName string
	Tool    McpToolDef
}

type MomCandidate struct {
	Name          string
	Author        string
	Description   string
	Connections   []ExternalConnectionMeta
	Tools         []McpToolDef
	OwnerUserUuid *uuid.UUID
	// ViewerIsOwner reports whether the caller is OwnerUserUuid — computed in the service layer
	// (which has access to the caller's identity via user_context) so transport handlers never
	// need to inspect auth context themselves.
	ViewerIsOwner bool
}

type OpenAIKeyCredentials struct {
	ApiKey  string `json:"api_key"`
	BaseUrl string `json:"base_url,omitempty"` // optional override, e.g. a proxy/regional endpoint
}

type Paging struct {
	Limit  uint32
	Offset uint32
}

type PendingAuthCode struct {
	Code          string
	RawToken      string
	CodeChallenge string
	RedirectUri   string
	ClientId      string
	ExpiresAt     time.Time
}

type PostgresInstance struct {
	Uuid          uuid.UUID
	Host          string
	Port          int
	AdminDatabase string
	Username      string
	Password      string
	SSLMode       string
	// OwnerUserUuid is nil for an admin-pool instance, non-nil for a BYOK instance owned by that
	// user — mirrors CouchInstance/S3Instance owner_user_id scoping (migrations/066).
	OwnerUserUuid *uuid.UUID
	CreatedAt     time.Time
}

type PostgresKeyCredentials struct {
	Host     string `json:"host"`
	Port     int    `json:"port"`
	Database string `json:"database"`
	Username string `json:"username"`
	Password string `json:"password"`
	SSLMode  string `json:"ssl_mode"`
}

type Prompt struct {
	Id   string
	Text string
}

type RegistrationMode string

type S3Instance struct {
	Uuid      uuid.UUID
	Endpoint  string
	Region    string
	AccessKey string
	SecretKey string
	UseSSL    bool
	PathStyle bool
	CreatedAt time.Time
}

type S3KeyCredentials struct {
	Endpoint  string `json:"endpoint"`
	Region    string `json:"region,omitempty"`
	AccessKey string `json:"access_key"`
	SecretKey string `json:"secret_key"`
	UseSSL    bool   `json:"use_ssl"`
	PathStyle bool   `json:"path_style"`
}

type ScriptLanguage string

type ScriptParam struct {
	Name     string
	Property ToolProperty
}

type Session struct {
	Uuid             uuid.UUID
	UserUuid         uuid.UUID
	Token            string
	ExpiresAt        time.Time
	RefreshToken     string
	RefreshExpiresAt time.Time
	CreatedAt        time.Time
}

type SimpleChat struct {
	Uuid      uuid.UUID
	VaultUuid uuid.UUID
	UserUuid  uuid.UUID
	// Title is nil until the engine (or the user) names the chat — a nil title is rendered as
	// e.g. "New chat" / the first user message by the frontend, not stored as such here.
	Title          *string
	Model          string
	VaultAccess    bool
	CreatedAt      time.Time
	UpdatedAt      time.Time
	LastActivityAt time.Time
}

type SimpleChatFile struct {
	Header   SimpleChatHeader
	Messages []SimpleChatMessage
}

type SimpleChatHeader struct {
	Type      simpleChatLineType `json:"type"`
	Uuid      uuid.UUID          `json:"id"`
	VaultUuid uuid.UUID          `json:"vault_id"`
	UserUuid  uuid.UUID          `json:"user_id"`
	// Title is nil until the engine (or the user) names the chat — see SimpleChat.Title.
	Title          *string   `json:"title,omitempty"`
	Model          string    `json:"model"`
	VaultAccess    bool      `json:"vault_access"`
	CreatedAt      time.Time `json:"created_at"`
	UpdatedAt      time.Time `json:"updated_at"`
	LastActivityAt time.Time `json:"last_activity_at"`
	// ToolAllowances remembers a chat's "allow always" answers, keyed by tool name.
	ToolAllowances map[string]string `json:"tool_allowances,omitempty"`
}

type SimpleChatMessage struct {
	Uuid        uuid.UUID
	ChatUuid    uuid.UUID
	Role        string
	Content     string
	ToolCallID  *string
	ToolName    *string
	ToolInput   json.RawMessage
	IsError     bool
	Model       *string
	Attachments []string
	Seq         int64
	CreatedAt   time.Time
}

type SimpleChatRole string

type Skill struct {
	Slug        string
	Name        string
	Description string
	StorageMode SkillStorageMode
	Body        string
	IsHotPlug   bool
	IsSystem    bool
}

type SkillStorageMode string

type SmtpAction struct {
	Operation SmtpOperation
}

type SmtpOperation string

type StorageUsage struct {
	CouchBytes int64
	S3Bytes    int64
}

type Subscription struct {
	UserUuid                 uuid.UUID
	Active                   bool
	PlanKey                  string
	FeatureOverrides         map[SubscriptionFeature]bool
	CouchQuotaOverrideBytes  *int64
	S3QuotaOverrideBytes     *int64
	MaxHotPlugSkillsOverride *int
	MaxTotalSkillsOverride   *int
}

type SubscriptionFeature string

type SubscriptionPlan struct {
	PlanKey          string
	CouchQuotaBytes  int64
	S3QuotaBytes     int64
	MaxHotPlugSkills int
	MaxTotalSkills   int
	Features         FeatureSet
	CreatedAt        time.Time
	UpdatedAt        time.Time
}

type SystemSettings struct {
	SystemPrompt        string
	SetupCompleted      bool
	PasswordAuthEnabled bool
	TelegramAuthEnabled bool
	RegistrationMode    RegistrationMode

	// SetupTokenHash/SetupTokenIssuedAt back the one-time setup token minted on first run to
	// authorize the initial admin creation. Empty/zero once CompleteSetup has cleared them.
	SetupTokenHash     string
	SetupTokenIssuedAt time.Time

	// DefaultDocsVaultID is the admin-configured vault an unauthenticated visitor hitting
	// `/docs` (no slug) is redirected to. Nil when unset — see public_docs.Service.GetDefaultVault.
	DefaultDocsVaultID *uuid.UUID

	// DefaultDocsSource selects between DefaultDocsVaultID and the built-in GitHub quick-start
	// guide for that same `/docs` redirect — see public_docs.Service.GetDefaultVault.
	DefaultDocsSource DocsSource

	CreatedAt time.Time
	UpdatedAt time.Time
}

type TaskTracker struct {
	Uuid      uuid.UUID
	UserUuid  uuid.UUID
	Type      string
	Name      string
	CreatedAt time.Time
}

type TelegramCredentials struct {
	BotToken string `json:"bot_token"`
	// ChatID is captured from the first inbound webhook update once the user messages their
	// linked bot; zero until then.
	ChatID int64 `json:"chat_id,omitempty"`
	// WebhookSecret is generated when the connection is created and passed to Telegram's
	// setWebhook as secret_token, then compared against the X-Telegram-Bot-Api-Secret-Token
	// header on each inbound webhook request (mirrors GitlabCredentials.WebhookSecret).
	WebhookSecret string `json:"webhook_secret,omitempty"`
}

type TelegramIdentity struct {
	UserUuid   uuid.UUID
	TelegramId string
}

type TerminalTab struct {
	ID     string
	Name   string
	Active bool
}

type ToolAction struct {
	Imap *ImapAction
	Smtp *SmtpAction
	Http *HttpAction
}

type ToolApiDescription struct {
	Name        string
	Description string
	Properties  map[string]ToolProperty
	Required    []string
}

type ToolExecResult struct {
	Text         string
	Data         []byte
	MimeType     string
	ResourcePath string
}

type ToolProperty struct {
	Type        string // "string" | "integer" | "number" | "boolean" | "array" | "object"
	Description string
	Enum        []string                // non-empty when the param is constrained to a fixed set of values
	Properties  map[string]ToolProperty // nested fields when Type == "object"
	Items       *ToolProperty           // element schema when Type == "array"
	Required    []string                // required nested field names when Type == "object"
}

type ToolSchema struct {
	Properties map[string]ToolProperty
	Required   []string
	IsArray    bool
	Items      *ToolProperty
}

type Tract struct {
	Uuid        uuid.UUID
	UserUuid    uuid.UUID
	Name        string
	Description string
	Enabled     bool
	Definition  TractDefinition
	CreatedAt   time.Time
	UpdatedAt   time.Time
}

type TractCondition struct {
	Left  string `json:"left"`
	Op    string `json:"op"`
	Right string `json:"right"`
}

type TractDefinition struct {
	Steps []TractStep `json:"steps"`
}

type TractRun struct {
	Uuid           uuid.UUID
	TractUuid      uuid.UUID
	TriggerUuid    uuid.UUID
	StartedBy      string // "webhook" | "manual" | "mcp"
	Status         TractRunStatus
	TriggerPayload json.RawMessage // normalized payload / manual form values
	Error          string
	CreatedAt      time.Time
	UpdatedAt      time.Time
}

type TractRunStatus string

type TractRunStep struct {
	Uuid       uuid.UUID
	RunUuid    uuid.UUID
	StepId     string
	StepName   string
	StepType   string
	Input      json.RawMessage
	Output     json.RawMessage
	Status     TractRunStepStatus
	Error      string
	StartedAt  time.Time
	FinishedAt time.Time // zero value = not finished yet
}

type TractRunStepStatus string

type TractStep struct {
	Id                string            `json:"id"`
	Name              string            `json:"name,omitempty"`
	Description       string            `json:"description,omitempty"`
	Type              string            `json:"type"`
	Mcp               string            `json:"mcp,omitempty"`
	Tool              string            `json:"tool,omitempty"`
	ConnectionUuid    uuid.UUID         `json:"connection_uuid,omitempty"`
	Params            map[string]string `json:"params,omitempty"`
	Conditions        []TractCondition  `json:"conditions,omitempty"`
	Then              []TractStep       `json:"then,omitempty"`
	Else              []TractStep       `json:"else,omitempty"`
	Steps             []TractStep       `json:"steps,omitempty"`
	Language          ScriptLanguage    `json:"language,omitempty"`
	Code              string            `json:"code,omitempty"`
	InputParams       []ScriptParam     `json:"input_params,omitempty"`
	OutputParams      []ScriptParam     `json:"output_params,omitempty"`
	LlmConnectionUuid uuid.UUID         `json:"llm_connection_uuid,omitempty"`
	LlmModel          string            `json:"llm_model,omitempty"`
	Prompt            string            `json:"prompt,omitempty"`
	SystemPrompt      string            `json:"system_prompt,omitempty"`
	MaxTokens         int               `json:"max_tokens,omitempty"`
}

type TractTemplate struct {
	Uuid            uuid.UUID
	SourceTractUuid uuid.UUID
	OwnerUuid       uuid.UUID
	Name            string
	Description     string
	Definition      TractDefinition
	Category        string
	InstallCount    int
	PublishedAt     time.Time
	UpdatedAt       time.Time
}

type TrelloBoard struct {
	Id   string
	Name string
}

type TrelloMember struct {
	FullName string
}

type Trigger struct {
	Uuid          uuid.UUID
	TriggerUuid   uuid.UUID
	UserUuid      uuid.UUID
	Name          string
	Kind          string // "webhook" | "manual"
	Source        string // "gitlab_push" | "generic"
	Config        json.RawMessage
	PayloadSchema ToolSchema
	SecretHash    []byte
	// TokenSuffix is the last 4 hex chars of the raw webhook token, kept in plaintext (unlike
	// SecretHash) purely so the UI can render a persistent "••••1234" reminder; never enough to
	// reconstruct the token. Empty for manual/provider-linked triggers.
	TokenSuffix string
	// Matchers gates which triggers (among possibly several sharing one provider link, see
	// trigger_provider_links) actually fire for a given inbound delivery. Seeded from the chosen
	// TriggerPreset's DefaultMatchers at creation time; empty always matches (standalone
	// triggers, which are the only recipient of their own webhook URL anyway).
	Matchers  TriggerMatchers
	Enabled   bool
	CreatedAt time.Time
}

type TriggerMatchers struct {
	CheckHeaders []HeaderMatcher
	CheckBody    []BodyMatcher
}

type TriggerPreset struct {
	Key             string
	Category        string
	Label           string
	Description     string
	Provider        string
	PayloadSchema   ToolSchema
	DefaultMatchers TriggerMatchers
}

type TriggerTractLink struct {
	TriggerUuid uuid.UUID
	TractUuid   uuid.UUID
	Filters     []TractCondition
}

type User struct {
	Uuid         uuid.UUID
	Email        string
	Username     string
	PhotoUrl     string
	PasswordHash string
	Roles        []string
	Identities   UserIdentities
	CreatedAt    time.Time
	UpdatedAt    time.Time
}

type UserDetails struct {
	User
	Permissions           UserPermissions
	EffectiveSubscription EffectiveSubscription
}

type UserIdentities struct {
	Telegram *TelegramIdentity
	Artel    *ArtelIdentity
}

type UserPermissions struct {
	UserUuid        uuid.UUID
	IsAdministrator bool
}

type UserSettings struct {
	UserUuid   uuid.UUID
	UserPrompt string
}

type Vault struct {
	Uuid                  uuid.UUID
	UserUuid              uuid.UUID
	CouchInstanceUuid     uuid.UUID
	Name                  string
	CouchDBName           string
	CouchDBURL            string
	LiveSyncPassphrase    string
	Status                string
	S3InstanceUuid        *uuid.UUID // nil when vault has no linked bucket
	S3BucketName          string     // "" when S3InstanceUuid is nil
	UseCouchDBForBinaries bool
	CreatedAt             time.Time
	IsPublic              bool
	Slug                  string // "" when vault has never been published
	Prompt                string
	UseSystemPrompt       bool

	// MyRole is the calling user's membership role on this vault ("owner"/"reader"/"maintainer"),
	// or "" if they have no membership row. Only populated by ListByMembership — every other
	// repo method (GetByID, CreateVault, etc.) has no "calling user" concept and leaves it "".
	MyRole string
}

type VaultInvite struct {
	Uuid      uuid.UUID
	VaultUuid uuid.UUID
	CreatedBy uuid.UUID
	Role      artel_q.VaultRole
	Token     string
	RevokedAt *time.Time
	CreatedAt time.Time
}

type VaultMember struct {
	Uuid      uuid.UUID
	VaultUuid uuid.UUID
	UserUuid  uuid.UUID
	Role      artel_q.VaultRole
	CreatedAt time.Time
}

type VaultMemberInfo struct {
	VaultMember
	Email    string
	Username string
}

type VaultPostgresDatabase struct {
	VaultUuid            uuid.UUID
	PostgresInstanceUuid uuid.UUID
	DatabaseName         string
	RoleUsername         string
	RolePassword         string
	Status               VaultPostgresStatus
	ErrorMessage         string
	CreatedAt            time.Time
	UpdatedAt            time.Time
}

type VaultPostgresStatus string

type Workbench struct {
	Uuid        uuid.UUID
	VaultUuid   uuid.UUID
	UserUuid    uuid.UUID
	Status      WorkbenchStatus
	AuthMode    WorkbenchAuthMode // "" when not yet started
	ContainerId string            // "" only in the creation-failed/retry edge case
	VolumeName  string
	CreatedAt   time.Time
	StartedAt   *time.Time // nil until started
	StoppedAt   *time.Time // nil until stopped
	// DockerHostUuid is the docker_hosts row this workbench's container/volume live on, assigned
	// at CreateWorkbench time by picking the least-loaded host — see
	// internal/service/v1/workbench/workbench.go's resolveClient. nil only for rows created
	// before the docker_hosts pool existed.
	DockerHostUuid *uuid.UUID
}

type WorkbenchAuthMode string

type WorkbenchStatus string