@soat/sdk 0.57.0 → 0.58.0

package/dist/index.cjs

@@ -631,6 +631,17 @@ var Activity = class {
 			...options
 		});
 	}
+	/**
+	* Export the activity feed as NDJSON
+	*
+	* Streams a project's activity entries as newline-delimited JSON — one entry object per line, **oldest first**, where the feed itself reads newest first: a feed answers what just happened, and a file is read start to end. `project_id` is required: the export is per-project by design. Filters behave exactly as they do on the list endpoint.
+	*/
+	static exportActivity(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/activity/export",
+			...options
+		});
+	}
 };
 var Actors = class {
 	/**
@@ -1553,6 +1564,17 @@ var Documents = class {
 		});
 	}
 	/**
+	* Export documents as NDJSON
+	*
+	* Streams a project's documents as newline-delimited JSON — one document object per line, oldest first — for archiving the corpus or shipping it into another system. `project_id` is required: the export is per-project by design. The rows are the rows the listing returns for the same caller, so a policy that hides a document hides it here too, and withdrawn documents and the reserved `/.system/` root are left out.
+	*/
+	static exportDocuments(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/documents/export",
+			...options
+		});
+	}
+	/**
 	* Delete a document
 	*
 	* Deletes a document and its underlying file
@@ -1590,6 +1612,45 @@ var Documents = class {
 		});
 	}
 	/**
+	* List a document's relations
+	*
+	* Returns the typed edges this document asserts about others, oldest first. An edge is owned by the document it leaves, so this is what the document claims — use `?related_to=` on the listing to find what claims something about it.
+	*/
+	static listDocumentRelations(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/documents/{document_id}/relations",
+			...options
+		});
+	}
+	/**
+	* Assert a relation
+	*
+	* Asserts a typed edge from this document to another in the same project. Asserting the same edge twice is `409`: an edge is a fact, and the second assertion is the same fact.
+	*
+	* Writing an edge is a write of the asserting document (`documents:UpdateDocument`); the document it points at is unchanged, which is what lets an agent record what its own report derives from without being able to make another report claim anything.
+	*/
+	static createDocumentRelation(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/documents/{document_id}/relations",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Retract a relation
+	*
+	* Removes an edge this document asserts. Both documents are left as they are — retracting a claim is not a change to what it was about.
+	*/
+	static deleteDocumentRelation(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/documents/{document_id}/relations/{relation_id}",
+			...options
+		});
+	}
+	/**
 	* Get document ingestion status
 	*
 	* Returns a lightweight ingestion status payload for polling — `status`,
@@ -1607,6 +1668,70 @@ var Documents = class {
 		});
 	}
 	/**
+	* Withdraw a document
+	*
+	* Takes a document out of every default read while keeping its history. The withdrawal is archived as a **tombstone version**, so one mechanism answers what a document holds now and there is no second lifecycle flag for a reader to miss.
+	*
+	* Its chunks are dropped from the knowledge index, so a withdrawn document costs a live search nothing. The content is not lost with them: it is in the version before the tombstone, which [`POST /api/v1/documents/{document_id}/versions/{version}/restore`](/docs/api/documents/restore-document-version) re-chunks from.
+	*
+	* `DELETE` stays what it is — permanent, and it removes the backing file. Withdrawal is the reversible act. It does not apply under `/.system/`: a platform-written document keeps the owning module's lifecycle.
+	*
+	*/
+	static withdrawDocument(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/documents/{document_id}/withdraw",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List a document's content versions
+	*
+	* Returns the document's archived states, newest first. A version is written on create and on every subsequent write that changes the content or its annotations, and a withdrawal is archived as a version carrying no content.
+	*
+	*/
+	static listDocumentVersions(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/documents/{document_id}/versions",
+			...options
+		});
+	}
+	/**
+	* Fetch an archived document version
+	*
+	* Returns the exact content and annotations the document held at a given version, which is what lets a run that cited a version read what it read.
+	*
+	*/
+	static getDocumentVersion(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/documents/{document_id}/versions/{version}",
+			...options
+		});
+	}
+	/**
+	* Restore an archived document version
+	*
+	* Writes an archived version's content and annotations back as the document's live state, which archives them again as a **new** version rather than rewinding the counter — so a run citing any version in between still resolves.
+	*
+	* The restore runs through the ordinary update path, so the content is re-chunked and re-embedded; restoring the state the document already holds is a no-op and archives nothing. Restoring any content version of a withdrawn document brings it back into listings and search.
+	*
+	* A tombstone version has no content, so naming one is `400 VALIDATION_FAILED`: restore the version before it instead.
+	*
+	*/
+	static restoreDocumentVersion(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/documents/{document_id}/versions/{version}/restore",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
 	* Re-ingest an existing document
 	*
 	* Re-runs ingestion for an existing document against its already-stored
@@ -2705,6 +2830,26 @@ var Memories = class {
 		});
 	}
 	/**
+	* Retract a memory
+	*
+	* Retires a fact that stopped holding with nothing replacing it. The memory leaves the default listing, [knowledge search](/docs/api/knowledge/search-knowledge) and write deduplication, so restating the fact later lands as a new memory.
+	*
+	* It is an invalidation with no successor, which is what tells it apart from a supersede: `invalidated_at` is set and `superseded_by_memory_id` stays null. The retraction is appended to the assertion ledger with outcome `retracted`, so who withdrew the fact is part of the record.
+	*
+	* The memory stays readable by id, with its text and its assertions. `DELETE` remains the way to remove it outright.
+	*
+	*/
+	static retractMemory(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/memories/{memory_id}/retract",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
 	* List a memory's assertions
 	*
 	* Returns every write that resolved into this memory, oldest first: the one that created it, the duplicates it absorbed, and the assertion that superseded another memory in its favour. A superseded memory keeps its own assertions, so the chain can be walked in both directions.
@@ -2898,6 +3043,17 @@ var MemoryStores = class {
 		});
 	}
 	/**
+	* Export a memory store's memories as NDJSON
+	*
+	* Streams one store's memories as newline-delimited JSON — one memory object per line, oldest first. Invalidated memories (retracted or superseded) are left out unless `include_invalidated` asks for them, so the file holds what the store currently asserts. The rows are the rows the listing returns for the same caller.
+	*/
+	static exportMemories(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/memory-stores/{memory_store_id}/export",
+			...options
+		});
+	}
+	/**
 	* Get memory store tags
 	*
 	* Returns all tags attached to the memory store
@@ -2939,6 +3095,90 @@ var MemoryStores = class {
 		});
 	}
 };
+var MetadataSchemas = class {
+	/**
+	* List metadata schemas
+	*
+	* Returns the declarations in scope, oldest first. `resource_type` narrows them to one governed resource.
+	*/
+	static listMetadataSchemas(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/metadata-schemas",
+			...options
+		});
+	}
+	/**
+	* Declare a metadata schema
+	*
+	* Declares what `metadata` must satisfy for one resource type under one selector. A document is selected by `path_prefix`, matched on a path boundary: `/reports` covers `/reports/q1.txt` and never `/reports-archive/q1.txt`.
+	*
+	* The schema is compiled here, so one JSON Schema cannot parse is refused rather than stored — a stored one would be a rule that silently governs nothing. One selector has one schema per resource type; a second declaration of the same one is `409 NAME_CONFLICT`. The reserved root `/.system` cannot be governed: a platform-written document carries no caller metadata.
+	*
+	*/
+	static createMetadataSchema(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/metadata-schemas",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Check metadata against what is declared
+	*
+	* Answers what a write would be told, without writing: a caller preparing a batch learns which declaration would refuse it, and why, before it sends anything.
+	*
+	* It reports; it does not enforce. The refusal itself lives in each resource's own write path, because a check a writer has to call is advisory and the writer who skips it is the one the rule exists for.
+	*
+	*/
+	static validateMetadata(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/metadata-schemas/validate",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a metadata schema
+	*
+	* Removes the declaration. Documents already stored keep the metadata they hold — the rule governed writes, not rows.
+	*/
+	static deleteMetadataSchema(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/metadata-schemas/{metadata_schema_id}",
+			...options
+		});
+	}
+	/**
+	* Get a metadata schema
+	*/
+	static getMetadataSchema(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/metadata-schemas/{metadata_schema_id}",
+			...options
+		});
+	}
+	/**
+	* Update a metadata schema
+	*
+	* Changes the schema, the selector, or both. `resource_type` is fixed at creation: it decides the selector's spelling and which write path reads the row, so changing it would silently repoint the declaration at a different door — delete it and declare again instead.
+	*/
+	static updateMetadataSchema(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/metadata-schemas/{metadata_schema_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
 var ModelRoutes = class {
 	/**
 	* List model routes
@@ -4627,6 +4867,7 @@ var SoatClient = class {
 	memories;
 	memoryRules;
 	memoryStores;
+	metadataSchemas;
 	modelRoutes;
 	orchestrations;
 	policies;
@@ -4675,6 +4916,7 @@ var SoatClient = class {
 		this.memories = bindResource(Memories, httpClient);
 		this.memoryRules = bindResource(MemoryRules, httpClient);
 		this.memoryStores = bindResource(MemoryStores, httpClient);
+		this.metadataSchemas = bindResource(MetadataSchemas, httpClient);
 		this.modelRoutes = bindResource(ModelRoutes, httpClient);
 		this.orchestrations = bindResource(Orchestrations, httpClient);
 		this.policies = bindResource(Policies, httpClient);
@@ -4717,6 +4959,7 @@ exports.Knowledge = Knowledge;
 exports.Memories = Memories;
 exports.MemoryRules = MemoryRules;
 exports.MemoryStores = MemoryStores;
+exports.MetadataSchemas = MetadataSchemas;
 exports.ModelRoutes = ModelRoutes;
 exports.Orchestrations = Orchestrations;
 exports.Policies = Policies;