rest

type AnswerQuestionJSONRequestBody = AnswerRequest

type AnswerQuestionParams struct {
	// XMeminiNamespace Tenant/agent namespace; falls back to the server default.
	XMeminiNamespace *Namespace `json:"X-Memini-Namespace,omitempty"`
}

type AnswerRequest struct {
	// Limit Caps how many recalled memories ground the answer.
	Limit *int    `json:"limit,omitempty"`
	Query string  `json:"query"`
	Tiers *[]Tier `json:"tiers,omitempty"`
}

type AnswerResponse struct {
	Answer  string         `json:"answer"`
	Sources []ScoredMemory `json:"sources"`
}

type AuthConfig struct {
	// APIKey, when non-empty, is required as "Authorization: Bearer <key>".
	APIKey string
	// NamespaceHeader names the request header carrying the tenant namespace.
	NamespaceHeader string
	// DefaultNamespace is used when the header is absent.
	DefaultNamespace string
}

type ChiServerOptions struct {
	BaseURL          string
	BaseRouter       chi.Router
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

type Error struct {
	Error *string `json:"error,omitempty"`
}

type ForgetMemoryParams struct {
	// XMeminiNamespace Tenant/agent namespace; falls back to the server default.
	XMeminiNamespace *Namespace `json:"X-Memini-Namespace,omitempty"`
}

type FsckReport struct {
	DuplicateGroups  *[][]string `json:"duplicate_groups,omitempty"`
	ExpiredPurged    int         `json:"expired_purged"`
	Namespaces       int         `json:"namespaces"`
	ShortTermEvicted int         `json:"short_term_evicted"`
}

type GetMemoryParams struct {
	// XMeminiNamespace Tenant/agent namespace; falls back to the server default.
	XMeminiNamespace *Namespace `json:"X-Memini-Namespace,omitempty"`
}

type GetStatsParams struct {
	// XMeminiNamespace Tenant/agent namespace; falls back to the server default.
	XMeminiNamespace *Namespace `json:"X-Memini-Namespace,omitempty"`
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type ListMemoriesParams struct {
	// Tier Repeatable and/or comma-separated tier filter; omitted means all tiers.
	Tier              *[]Tier `form:"tier,omitempty" json:"tier,omitempty"`
	IncludeExpired    *bool   `form:"include_expired,omitempty" json:"include_expired,omitempty"`
	IncludeSuperseded *bool   `form:"include_superseded,omitempty" json:"include_superseded,omitempty"`

	// Limit Caps the result count; 0 or absent returns all matches.
	Limit *int `form:"limit,omitempty" json:"limit,omitempty"`

	// XMeminiNamespace Tenant/agent namespace; falls back to the server default.
	XMeminiNamespace *Namespace `json:"X-Memini-Namespace,omitempty"`
}

type ListResponse struct {
	Memories []Memory `json:"memories"`
}

type Memory struct {
	AccessCount    int                     `json:"access_count"`
	Content        string                  `json:"content"`
	CreatedAt      time.Time               `json:"created_at"`
	ExpiresAt      *time.Time              `json:"expires_at,omitempty"`
	Id             string                  `json:"id"`
	Importance     float64                 `json:"importance"`
	LastAccessedAt time.Time               `json:"last_accessed_at"`
	Metadata       *map[string]interface{} `json:"metadata,omitempty"`
	Namespace      string                  `json:"namespace"`
	Summary        *string                 `json:"summary,omitempty"`
	SupersededBy   *string                 `json:"superseded_by,omitempty"`
	Tags           *[]string               `json:"tags,omitempty"`
	Tier           Tier                    `json:"tier"`
	UpdatedAt      time.Time               `json:"updated_at"`
}

type MiddlewareFunc func(http.Handler) http.Handler

type Namespace = string

type NamespacesResponse struct {
	Namespaces []string `json:"namespaces"`
}

type RememberMemoryJSONRequestBody = RememberRequest

type RememberMemoryParams struct {
	// XMeminiNamespace Tenant/agent namespace; falls back to the server default.
	XMeminiNamespace *Namespace `json:"X-Memini-Namespace,omitempty"`
}

type RememberRequest struct {
	Content string `json:"content"`

	// Id Upserts an existing memory when provided.
	Id         *string                 `json:"id,omitempty"`
	Importance *float64                `json:"importance,omitempty"`
	Metadata   *map[string]interface{} `json:"metadata,omitempty"`
	Summary    *string                 `json:"summary,omitempty"`
	Tags       *[]string               `json:"tags,omitempty"`
	Tier       *Tier                   `json:"tier,omitempty"`

	// TtlSeconds Overrides the tier default TTL; negative means never expire.
	TtlSeconds *int `json:"ttl_seconds,omitempty"`
}

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

type RequiredParamError struct {
	ParamName string
}

type RunFsckParams struct {
	// XMeminiNamespace Tenant/agent namespace; falls back to the server default.
	XMeminiNamespace *Namespace `json:"X-Memini-Namespace,omitempty"`
}

type ScoredMemory struct {
	Memory Memory  `json:"memory"`
	Score  float64 `json:"score"`
}

type SearchMemoriesJSONRequestBody = SearchRequest

type SearchMemoriesParams struct {
	// XMeminiNamespace Tenant/agent namespace; falls back to the server default.
	XMeminiNamespace *Namespace `json:"X-Memini-Namespace,omitempty"`
}

type SearchRequest struct {
	IncludeExpired    *bool   `json:"include_expired,omitempty"`
	IncludeSuperseded *bool   `json:"include_superseded,omitempty"`
	Limit             *int    `json:"limit,omitempty"`
	Query             string  `json:"query"`
	Tiers             *[]Tier `json:"tiers,omitempty"`
}

type SearchResponse struct {
	Results []ScoredMemory `json:"results"`
}

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

type ServerInterface interface {
	// Recall memories and answer a question grounded on them (requires an LLM)
	// (POST /v1/answer)
	AnswerQuestion(w http.ResponseWriter, r *http.Request, params AnswerQuestionParams)
	// Run a consistency sweep (purge expired, enforce short-term cap, audit duplicates)
	// (POST /v1/fsck)
	RunFsck(w http.ResponseWriter, r *http.Request, params RunFsckParams)
	// List memories in a namespace (backs the admin UI browser)
	// (GET /v1/memories)
	ListMemories(w http.ResponseWriter, r *http.Request, params ListMemoriesParams)
	// Remember (store) a memory
	// (POST /v1/memories)
	RememberMemory(w http.ResponseWriter, r *http.Request, params RememberMemoryParams)
	// Forget (delete) a memory
	// (DELETE /v1/memories/{id})
	ForgetMemory(w http.ResponseWriter, r *http.Request, id string, params ForgetMemoryParams)
	// Fetch a memory by ID
	// (GET /v1/memories/{id})
	GetMemory(w http.ResponseWriter, r *http.Request, id string, params GetMemoryParams)
	// List the distinct namespaces holding memories
	// (GET /v1/namespaces)
	ListNamespaces(w http.ResponseWriter, r *http.Request)
	// Recall memories via hybrid (vector + keyword) search
	// (POST /v1/search)
	SearchMemories(w http.ResponseWriter, r *http.Request, params SearchMemoriesParams)
	// Per-namespace overview (counts by tier, accesses, importance)
	// (GET /v1/stats)
	GetStats(w http.ResponseWriter, r *http.Request, params GetStatsParams)
}

type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type Stats struct {
	AvgImportance float64        `json:"avg_importance"`
	ByTier        map[string]int `json:"by_tier"`
	Expired       int            `json:"expired"`
	LastWriteAt   *time.Time     `json:"last_write_at,omitempty"`
	Namespace     string         `json:"namespace"`
	Superseded    int            `json:"superseded"`

	// Total Live memories (excludes expired/superseded)
	Total         int `json:"total"`
	TotalAccesses int `json:"total_accesses"`
}

type Tier string

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

type Unimplemented struct{}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}