api

type BrowseMemoriesParams struct {
	Limit  *Limit  `form:"limit,omitempty" json:"limit,omitempty"`
	Cursor *Cursor `form:"cursor,omitempty" json:"cursor,omitempty"`
}

type BrowseMemoriesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *MemoryPage
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *Error
}

type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

type ClientInterface interface {

	// GetLiveness Check whether the process is alive
	//
	// Corresponds with GET /livez (the `GetLiveness` operationId).
	GetLiveness(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// BrowseMemories Browse committed Memories
	//
	// Corresponds with GET /memories (the `BrowseMemories` operationId).
	BrowseMemories(ctx context.Context, params *BrowseMemoriesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ImportMemoryWithBody Durably import one Blob as a Memory
	//
	// Upload one Blob and return after its bytes are durably published and
	// the Memory is committed. A Blob may contain at most 100 MiB
	// (104857600 bytes). The server permits bounded multipart protocol
	// overhead in addition to that Blob limit. Duplicate content is rejected
	// with HTTP 409. Document Understanding is not performed by this request.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /memories/import (the `ImportMemory` operationId).
	ImportMemoryWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SearchMemories Search committed Memories
	//
	// Search results are returned in ranked pages. Supply the returned cursor
	// with the same trimmed query to continue. Cursors do not snapshot Vault
	// mutations between requests.
	//
	// Corresponds with GET /memories/search (the `SearchMemories` operationId).
	SearchMemories(ctx context.Context, params *SearchMemoriesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteMemory Delete one Memory and its Blob
	//
	// Permanently deletes the Memory, its Understanding Runs, and the
	// immutable Blob referenced by it. The Vault reuses the Blob only when
	// its content is imported again.
	//
	// Corresponds with DELETE /memories/{memoryId} (the `DeleteMemory` operationId).
	DeleteMemory(ctx context.Context, memoryId MemoryId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetMemory Get committed Memory details
	//
	// Corresponds with GET /memories/{memoryId} (the `GetMemory` operationId).
	GetMemory(ctx context.Context, memoryId MemoryId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetMemoryContent Download and verify a Memory's immutable Blob
	//
	// Corresponds with GET /memories/{memoryId}/content (the `GetMemoryContent` operationId).
	GetMemoryContent(ctx context.Context, memoryId MemoryId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RebuildMemoryWithBody Request a Memory Rebuild
	//
	// Accept process-local work using current Document Understanding methods.
	// An optional user_note replaces the saved Memory guidance; absent or
	// null user_note reuses the saved note, and an empty string clears it.
	// The original Blob and previous active Run remain unchanged. Acceptance
	// is best effort: queued/running work and polling handles are lost on
	// restart. Competing queued/running work returns 409 without scheduling
	// or changing the saved note.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /memories/{memoryId}/rebuild (the `RebuildMemory` operationId).
	RebuildMemoryWithBody(ctx context.Context, memoryId MemoryId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RebuildMemory Request a Memory Rebuild
	//
	// Accept process-local work using current Document Understanding methods.
	// An optional user_note replaces the saved Memory guidance; absent or
	// null user_note reuses the saved note, and an empty string clears it.
	// The original Blob and previous active Run remain unchanged. Acceptance
	// is best effort: queued/running work and polling handles are lost on
	// restart. Competing queued/running work returns 409 without scheduling
	// or changing the saved note.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /memories/{memoryId}/rebuild (the `RebuildMemory` operationId).
	RebuildMemory(ctx context.Context, memoryId MemoryId, body RebuildMemoryJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetReadiness Check whether the server can accept requests
	//
	// Corresponds with GET /readyz (the `GetReadiness` operationId).
	GetReadiness(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetRebuildStatus Poll a retained process-local Rebuild
	//
	// Retained until superseded by a newly accepted attempt, Memory deletion,
	// or restart. Terminal handles remain readable; no artifacts are returned.
	//
	// Corresponds with GET /rebuild-status/{rebuildId} (the `GetRebuildStatus` operationId).
	GetRebuildStatus(ctx context.Context, rebuildId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {

	// GetLivenessWithResponse Check whether the process is alive
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /livez (the `GetLiveness` operationId).
	GetLivenessWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetLivenessResponse, error)

	// BrowseMemoriesWithResponse Browse committed Memories
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /memories (the `BrowseMemories` operationId).
	BrowseMemoriesWithResponse(ctx context.Context, params *BrowseMemoriesParams, reqEditors ...RequestEditorFn) (*BrowseMemoriesResponse, error)

	// ImportMemoryWithBodyWithResponse Durably import one Blob as a Memory
	//
	// Upload one Blob and return after its bytes are durably published and
	// the Memory is committed. A Blob may contain at most 100 MiB
	// (104857600 bytes). The server permits bounded multipart protocol
	// overhead in addition to that Blob limit. Duplicate content is rejected
	// with HTTP 409. Document Understanding is not performed by this request.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /memories/import (the `ImportMemory` operationId).
	ImportMemoryWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ImportMemoryResponse, error)

	// SearchMemoriesWithResponse Search committed Memories
	//
	// Search results are returned in ranked pages. Supply the returned cursor
	// with the same trimmed query to continue. Cursors do not snapshot Vault
	// mutations between requests.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /memories/search (the `SearchMemories` operationId).
	SearchMemoriesWithResponse(ctx context.Context, params *SearchMemoriesParams, reqEditors ...RequestEditorFn) (*SearchMemoriesResponse, error)

	// DeleteMemoryWithResponse Delete one Memory and its Blob
	//
	// Permanently deletes the Memory, its Understanding Runs, and the
	// immutable Blob referenced by it. The Vault reuses the Blob only when
	// its content is imported again.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /memories/{memoryId} (the `DeleteMemory` operationId).
	DeleteMemoryWithResponse(ctx context.Context, memoryId MemoryId, reqEditors ...RequestEditorFn) (*DeleteMemoryResponse, error)

	// GetMemoryWithResponse Get committed Memory details
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /memories/{memoryId} (the `GetMemory` operationId).
	GetMemoryWithResponse(ctx context.Context, memoryId MemoryId, reqEditors ...RequestEditorFn) (*GetMemoryResponse, error)

	// GetMemoryContentWithResponse Download and verify a Memory's immutable Blob
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /memories/{memoryId}/content (the `GetMemoryContent` operationId).
	GetMemoryContentWithResponse(ctx context.Context, memoryId MemoryId, reqEditors ...RequestEditorFn) (*GetMemoryContentResponse, error)

	// RebuildMemoryWithBodyWithResponse Request a Memory Rebuild
	//
	// Accept process-local work using current Document Understanding methods.
	// An optional user_note replaces the saved Memory guidance; absent or
	// null user_note reuses the saved note, and an empty string clears it.
	// The original Blob and previous active Run remain unchanged. Acceptance
	// is best effort: queued/running work and polling handles are lost on
	// restart. Competing queued/running work returns 409 without scheduling
	// or changing the saved note.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /memories/{memoryId}/rebuild (the `RebuildMemory` operationId).
	RebuildMemoryWithBodyWithResponse(ctx context.Context, memoryId MemoryId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RebuildMemoryResponse, error)

	// RebuildMemoryWithResponse Request a Memory Rebuild
	//
	// Accept process-local work using current Document Understanding methods.
	// An optional user_note replaces the saved Memory guidance; absent or
	// null user_note reuses the saved note, and an empty string clears it.
	// The original Blob and previous active Run remain unchanged. Acceptance
	// is best effort: queued/running work and polling handles are lost on
	// restart. Competing queued/running work returns 409 without scheduling
	// or changing the saved note.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /memories/{memoryId}/rebuild (the `RebuildMemory` operationId).
	RebuildMemoryWithResponse(ctx context.Context, memoryId MemoryId, body RebuildMemoryJSONRequestBody, reqEditors ...RequestEditorFn) (*RebuildMemoryResponse, error)

	// GetReadinessWithResponse Check whether the server can accept requests
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /readyz (the `GetReadiness` operationId).
	GetReadinessWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetReadinessResponse, error)

	// GetRebuildStatusWithResponse Poll a retained process-local Rebuild
	//
	// Retained until superseded by a newly accepted attempt, Memory deletion,
	// or restart. Terminal handles remain readable; no artifacts are returned.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /rebuild-status/{rebuildId} (the `GetRebuildStatus` operationId).
	GetRebuildStatusWithResponse(ctx context.Context, rebuildId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetRebuildStatusResponse, error)
}

type CostEstimate struct {
	AmountUsd   float64 `json:"amount_usd"`
	Basis       string  `json:"basis"`
	PricingDate *string `json:"pricing_date,omitempty"`
	PricingUrl  *string `json:"pricing_url,omitempty"`
}

type Cursor = string

type DeleteMemoryResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *Error
}

type DerivedContent struct {
	BlobHash string `json:"blob_hash"`
	ByteSize int64  `json:"byte_size"`

	// Content Literal UTF-8 text content.
	Content     string             `json:"content"`
	ContentType string             `json:"content_type"`
	Id          openapi_types.UUID `json:"id"`

	// Provenance Optional opaque plugin-defined JSON metadata.
	Provenance interface{} `json:"provenance,omitempty"`

	// Scope Optional opaque plugin-defined JSON metadata.
	Scope interface{} `json:"scope,omitempty"`
}

type DuplicateMemory struct {
	Id openapi_types.UUID `json:"id"`
}

type Error struct {
	// Code Example: memory_not_found
	Code    string                  `json:"code"`
	Details *map[string]interface{} `json:"details,omitempty"`

	// ExistingMemory Present on a duplicate import conflict so clients can recover.
	ExistingMemory *DuplicateMemory `json:"existing_memory,omitempty"`
	Message        string           `json:"message"`
}

type GetLivenessResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *HealthResponse
}

type GetMemoryContentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *Error
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *Error
	// JSON507 the response for an HTTP 507 `application/json` response
	JSON507 *Error
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *GetMemoryContentResponse200Headers
}

type GetMemoryContentResponse200Headers struct {
	ContentDisposition *string
	ETag               *string
}

type GetMemoryResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *MemoryDetail
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *Error
}

type GetReadinessResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *HealthResponse
}

type GetRebuildStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *RebuildStatus
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *Error
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *GetRebuildStatusResponse200Headers
	// Headers404 the parsed response headers for an HTTP 404 response
	Headers404 *GetRebuildStatusResponse404Headers
}

type GetRebuildStatusResponse200Headers struct {
	CacheControl *string
}

type GetRebuildStatusResponse404Headers struct {
	CacheControl *string
}

type HealthResponse struct {
	Status  HealthResponseStatus `json:"status"`
	Version *string              `json:"version,omitempty"`
}

type HealthResponseStatus string

type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

type ImportContext struct {
	FilesystemCreatedAt  *time.Time `json:"filesystem_created_at,omitempty"`
	FilesystemModifiedAt *time.Time `json:"filesystem_modified_at,omitempty"`
	FullPath             *string    `json:"full_path,omitempty"`
	OriginalFilename     string     `json:"original_filename"`
	RelativePath         *string    `json:"relative_path,omitempty"`
}

type ImportContextInput struct {
	FilesystemCreatedAt  *time.Time `json:"filesystem_created_at,omitempty"`
	FilesystemModifiedAt *time.Time `json:"filesystem_modified_at,omitempty"`
	FullPath             *string    `json:"full_path,omitempty"`
	RelativePath         *string    `json:"relative_path,omitempty"`
}

type ImportMemoryMultipartRequestBody = ImportMultipart

type ImportMemoryResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *MemorySummary
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *Error
	// JSON409 the response for an HTTP 409 `application/json` response
	JSON409 *Error
	// JSON413 the response for an HTTP 413 `application/json` response
	JSON413 *Error
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *Error
}

type ImportMultipart struct {
	// File One Blob of at most 100 MiB with a nonblank filename in
	// Content-Disposition. The server detects its Media Type from content
	// first and may fall back to a valid, specific part Content-Type.
	File openapi_types.File `json:"file"`

	// ImportContext Optional client-observed provenance sent as one application/json
	// multipart part. The original filename comes from the Blob part. Omitted
	// values remain unknown; malformed timestamps reject the import.
	ImportContext *ImportContextInput `json:"import_context,omitempty"`
}

type Limit = int32

type MemoryDetail struct {
	// ContentUrl Relative URL of the content download endpoint.
	ContentUrl *string `json:"content_url,omitempty"`

	// ImportContext Stored provenance from the first successful import.
	ImportContext ImportContext        `json:"import_context"`
	Memory        MemorySummary        `json:"memory"`
	Understanding UnderstandingDetails `json:"understanding"`
}

type MemoryId = openapi_types.UUID

type MemoryPage struct {
	Items      []MemorySummary `json:"items"`
	NextCursor *string         `json:"next_cursor,omitempty"`
}

type MemorySummary struct {
	// BlobHash Canonical SHA-256 Blobref of the immutable Blob.
	BlobHash           string             `json:"blob_hash"`
	ByteSize           int64              `json:"byte_size"`
	Id                 openapi_types.UUID `json:"id"`
	ImportedAt         time.Time          `json:"imported_at"`
	MediaType          string             `json:"media_type"`
	OriginalCreatedAt  *time.Time         `json:"original_created_at,omitempty"`
	OriginalFilename   string             `json:"original_filename"`
	OriginalModifiedAt *time.Time         `json:"original_modified_at,omitempty"`
}

type RebuildMemoryJSONRequestBody = RebuildRequest

type RebuildMemoryResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON202 the response for an HTTP 202 `application/json` response
	JSON202 *RebuildStatus
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *Error
	// JSON409 the response for an HTTP 409 `application/json` response
	JSON409 *RebuildStatus
	// JSON503 the response for an HTTP 503 `application/json` response
	JSON503 *Error
	// Headers202 the parsed response headers for an HTTP 202 response
	Headers202 *RebuildMemoryResponse202Headers
	// Headers409 the parsed response headers for an HTTP 409 response
	Headers409 *RebuildMemoryResponse409Headers
}

type RebuildMemoryResponse202Headers struct {
	CacheControl *string
}

type RebuildMemoryResponse409Headers struct {
	CacheControl *string
}

type RebuildRequest struct {
	// UserNote Optional owner guidance; null reuses the saved note, empty string clears it.
	UserNote *string `json:"user_note,omitempty"`
}

type RebuildStatus struct {
	Attempt   UnderstandingAttempt `json:"attempt"`
	MemoryId  openapi_types.UUID   `json:"memory_id"`
	StatusUrl string               `json:"status_url"`
}

type RequestEditorFn func(ctx context.Context, req *http.Request) error

type SearchExcerptPart struct {
	Match bool   `json:"match"`
	Text  string `json:"text"`
}

type SearchHit struct {
	Excerpt []SearchExcerptPart `json:"excerpt"`

	// MatchTier 0 for complete whole-word/stem matches; 1 for fragment-dependent matches. Lower tiers sort first.
	MatchTier int           `json:"match_tier"`
	Memory    MemorySummary `json:"memory"`

	// Score SQLite BM25 from the word index for tier 0 and trigram index for tier 1. When no indexed fragments match, tier 1 falls back to word-index BM25 or 0. Lower scores sort first within each match tier; ties sort by Memory ID. Scores from different indexes are not comparable across tiers.
	Score float64 `json:"score"`
}

type SearchLimit = int64

type SearchMemoriesParams struct {
	Query  SearchQuery  `form:"query" json:"query"`
	Limit  *SearchLimit `form:"limit,omitempty" json:"limit,omitempty"`
	Cursor *Cursor      `form:"cursor,omitempty" json:"cursor,omitempty"`
}

type SearchMemoriesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *SearchPage
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *Error
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *SearchMemoriesResponse200Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *SearchMemoriesResponse400Headers
}

type SearchMemoriesResponse200Headers struct {
	CacheControl *string
}

type SearchMemoriesResponse400Headers struct {
	CacheControl *string
}

type SearchPage struct {
	Items      []SearchHit     `json:"items"`
	NextCursor *string         `json:"next_cursor,omitempty"`
	QueryPlan  SearchQueryPlan `json:"query_plan"`
	Total      int64           `json:"total"`
}

type SearchQuery = string

type SearchQueryPlan struct {
	Query string   `json:"query"`
	Terms []string `json:"terms"`
}

type Statistics struct {
	Usage *TokenUsage `json:"usage,omitempty"`
}

type TokenUsage struct {
	CacheWriteInputTokens *int64 `json:"cache_write_input_tokens,omitempty"`
	CachedInputTokens     *int64 `json:"cached_input_tokens,omitempty"`
	InputTokens           *int64 `json:"input_tokens,omitempty"`
	OutputTokens          *int64 `json:"output_tokens,omitempty"`
	ReasoningOutputTokens *int64 `json:"reasoning_output_tokens,omitempty"`
	TotalTokens           *int64 `json:"total_tokens,omitempty"`
}

type UnderstandingAttempt struct {
	CompletedAt *time.Time                `json:"completed_at,omitempty"`
	Diagnostics *UnderstandingDiagnostics `json:"diagnostics,omitempty"`
	Id          openapi_types.UUID        `json:"id"`

	// PluginId Configured plugin ID; empty when no plugin is selected.
	PluginId  string                    `json:"plugin_id"`
	QueuedAt  time.Time                 `json:"queued_at"`
	StartedAt *time.Time                `json:"started_at,omitempty"`
	Status    UnderstandingAttemptState `json:"status"`
}

type UnderstandingAttemptState string

type UnderstandingDetails struct {
	// ActiveRun The last complete successful Run; failed attempts do not replace it.
	ActiveRun     *UnderstandingRun          `json:"active_run"`
	LatestAttempt *UnderstandingAttempt      `json:"latest_attempt"`
	Status        UnderstandingDetailsStatus `json:"status"`

	// StatusUrl Process-local polling URL; absent for durable history after restart.
	StatusUrl *string `json:"status_url,omitempty"`

	// UserNote Latest saved owner guidance for this Memory; empty when absent or cleared.
	UserNote string `json:"user_note"`
}

type UnderstandingDetailsStatus string

type UnderstandingDiagnostics struct {
	Error    string `json:"error"`
	ExitCode *int   `json:"exit_code,omitempty"`

	// Stderr Captured plugin diagnostics; may contain private source content.
	Stderr string `json:"stderr"`

	// Stdout Captured plugin stdout, including invalid protocol output.
	Stdout string `json:"stdout"`
}

type UnderstandingRun struct {
	Artifacts   []DerivedContent   `json:"artifacts"`
	AttemptId   openapi_types.UUID `json:"attempt_id"`
	CompletedAt time.Time          `json:"completed_at"`

	// CostEstimate Optional API-equivalent estimate, not subscription charges.
	CostEstimate  *CostEstimate      `json:"cost_estimate,omitempty"`
	CreatedAt     time.Time          `json:"created_at"`
	Id            openapi_types.UUID `json:"id"`
	PluginId      string             `json:"plugin_id"`
	PluginVersion string             `json:"plugin_version"`
	SourceBlobref string             `json:"source_blobref"`

	// Statistics Optional plugin-reported Run totals.
	Statistics *Statistics `json:"statistics,omitempty"`

	// UserNote Owner guidance captured by this successful Run; empty when absent.
	UserNote string   `json:"user_note"`
	Warnings []string `json:"warnings"`
}