@naturali/sdk 0.136.0 → 0.137.0

package/dist/index.cjs

@@ -625,6 +625,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: "/v1/projects/{project_id}/activity/export",
+			...options
+		});
+	}
 };
 var Actors = class {
 	/**
@@ -2004,6 +2015,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: "/v1/projects/{project_id}/documents/export",
+			...options
+		});
+	}
+	/**
 	* Delete a document
 	*
 	* Deletes a document and its underlying file
@@ -2041,6 +2063,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: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/documents/{document_id}/relations/{relation_id}",
+			...options
+		});
+	}
+	/**
 	* Get document ingestion status
 	*
 	* Returns a lightweight ingestion status payload for polling — `status`,
@@ -2058,6 +2119,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 /v1/projects/{project_id}/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: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/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
@@ -3102,6 +3227,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: "/v1/projects/{project_id}/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.
@@ -3295,6 +3440,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: "/v1/projects/{project_id}/memory-stores/{memory_store_id}/export",
+			...options
+		});
+	}
+	/**
 	* Get memory store tags
 	*
 	* Returns all tags attached to the memory store
@@ -3336,6 +3492,92 @@ 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: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/metadata-schemas/{metadata_schema_id}",
+			...options
+		});
+	}
+	/**
+	* Get a metadata schema
+	*
+	* Returns one declaration by id.
+	*/
+	static getMetadataSchema(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/metadata-schemas/{metadata_schema_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
 var ModelRoutes = class {
 	/**
 	* List model routes
@@ -4973,6 +5215,7 @@ var NaturaliClient = class {
 	memories;
 	memoryRules;
 	memoryStores;
+	metadataSchemas;
 	modelRoutes;
 	quotas;
 	models;
@@ -5024,6 +5267,7 @@ var NaturaliClient = class {
 		this.memories = bindResource(Memories, this.http);
 		this.memoryRules = bindResource(MemoryRules, this.http);
 		this.memoryStores = bindResource(MemoryStores, this.http);
+		this.metadataSchemas = bindResource(MetadataSchemas, this.http);
 		this.modelRoutes = bindResource(ModelRoutes, this.http);
 		this.quotas = bindResource(Quotas, this.http);
 		this.models = bindResource(Models, this.http);
@@ -5068,6 +5312,7 @@ exports.Knowledge = Knowledge;
 exports.Memories = Memories;
 exports.MemoryRules = MemoryRules;
 exports.MemoryStores = MemoryStores;
+exports.MetadataSchemas = MetadataSchemas;
 exports.ModelRoutes = ModelRoutes;
 exports.Models = Models;
 exports.NaturaliClient = NaturaliClient;