@onesi/genesis 0.1.13 → 0.2.1

package/dist/minds-agent.js

@@ -1,6 +1,9 @@
 import { envelopeExtrasValid, ENVELOPE_EXTRA_FIELDS, GenesisError } from './errors.js';
 export const mindsAgentOperations = ['minds_agentInsertEpisodicMemory', 'minds_agentGetEpisodicMemory', 'minds_agentSearchMemory'];
-export const isMindsAgentOperation = (id) => mindsAgentOperations.includes(id);
+/** Agent Mind creation: an approved agent-create token with DPoP, default-off at the gateway (MINDS_AGENT_CREATE_ENABLED). */
+export const mindsAgentCreateOperations = ['minds_agentCreateMind', 'minds_agentGetCreateOperation'];
+export const isMindsAgentCreateOperation = (id) => mindsAgentCreateOperations.includes(id);
+export const isMindsAgentOperation = (id) => mindsAgentOperations.includes(id) || isMindsAgentCreateOperation(id);
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 const UUID4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const GROUP = /^agp_[0-7][0-9A-HJKMNP-TV-Z]{25}$/;
@@ -35,24 +38,43 @@ function validStoredEvent(value) {
     return row(value) && text(value.id, 36) && UUID.test(value.id) && text(value.content, 1_000_000)
         && date(value.timestamp) && eventType(value.event_type) && Array.isArray(value.tags) && value.tags.every(tag => typeof tag === 'string');
 }
+function validCreation(value) {
+    if (!row(value) || !exact(value, ['schemaVersion', 'approvalId', 'approvalVersion', 'operationId', 'spec']) || value.schemaVersion !== 1
+        || typeof value.approvalId !== 'string' || !UUID4.test(value.approvalId) || typeof value.operationId !== 'string' || !UUID4.test(value.operationId)
+        || !Number.isSafeInteger(value.approvalVersion) || Number(value.approvalVersion) < 1)
+        return false;
+    const spec = value.spec, capacity = row(spec) ? spec.capacity : undefined;
+    return row(spec) && row(capacity) && exact(spec, ['name', 'region', 'plan', 'capacity', 'services'])
+        && exact(capacity, ['profile_id', 'cpus', 'memory_mb', 'volume_size_gb']) && typeof spec.name === 'string' && spec.name.trim() === spec.name
+        && [...spec.name].length <= 80 && (spec.name === 'Sandbox' || spec.name.startsWith('Sandbox ')) && !/[\u0000-\u001f\u007f-\u009f]/.test(spec.name)
+        && spec.region === 'us-central1-a' && spec.plan === 'free' && capacity.profile_id === 'F1' && capacity.cpus === 1 && capacity.memory_mb === 512
+        && capacity.volume_size_gb === 1 && JSON.stringify(spec.services) === '["kv","memory"]';
+}
 /** A single agent request: no human context selection, credential exchange or automatic retry. */
 export async function mindsAgentTransport(options) {
     const { operationId: id, input } = options;
-    const write = id === 'minds_agentInsertEpisodicMemory', read = id === 'minds_agentGetEpisodicMemory';
+    const create = id === 'minds_agentCreateMind', status = id === 'minds_agentGetCreateOperation', creation = create || status;
+    const write = id === 'minds_agentInsertEpisodicMemory' || create, read = id === 'minds_agentGetEpisodicMemory' || status;
     let dispatched = false;
     const fail = (status, type, details = {}) => new MindsAgentError({
         status, type, operationId: id, code: details.code, requestId: details.requestId, dpopNonce: details.dpopNonce,
-        message: 'Agent memory request was not confirmed. Inspect the error before an explicit retry.',
+        message: creation ? (details.code === 'SERVICE_UNAVAILABLE' ? 'Agent Mind creation is not enabled on this gateway (MINDS_AGENT_CREATE_ENABLED).'
+            : 'Agent Mind creation was not confirmed. Read the operation status with the same operationId before an explicit retry.')
+            : 'Agent memory request was not confirmed. Inspect the error before an explicit retry.',
         ...(details.unknown || write && dispatched && (status === 0 || status >= 500 || type === 'invalid_response' && status >= 200 && status < 300)
             ? { body: { outcome: 'unknown' } } : {}),
     });
+    if (creation && (options.routing !== 'gateway' || !exact(input, status ? ['operation_id'] : ['body'])
+        || (status ? typeof input.operation_id !== 'string' || !UUID4.test(input.operation_id) : !validCreation(input.body))
+        || !options.headers || !Object.keys(options.headers).some(name => name.toLowerCase() === 'dpop')))
+        throw fail(0, 'invalid_request');
     const fields = read ? ['mind', 'storage_id'] : ['mind', 'body'];
-    if (options.routing !== 'gateway' || !isMindsAgentOperation(id) || !exact(input, fields, ['group'])
+    if (!creation && (options.routing !== 'gateway' || !isMindsAgentOperation(id) || !exact(input, fields, ['group'])
         || typeof input.mind !== 'string' || !UUID.test(input.mind)
         || input.group !== undefined && (typeof input.group !== 'string' || !GROUP.test(input.group))
-        || read && (typeof input.storage_id !== 'string' || !UUID.test(input.storage_id)))
+        || read && (typeof input.storage_id !== 'string' || !UUID.test(input.storage_id))))
         throw fail(0, 'invalid_request');
-    if (!read && (!row(input.body) || (write ? !exact(input.body, ['event']) || !validEvent(input.body.event)
+    if (!creation && !read && (!row(input.body) || (write ? !exact(input.body, ['event']) || !validEvent(input.body.event)
         : !exact(input.body, ['text'], ['limit']) || !text(input.body.text, 1_000) || !input.body.text.trim()
             || input.body.limit !== undefined && (!Number.isInteger(input.body.limit) || Number(input.body.limit) < 1 || Number(input.body.limit) > 100))))
         throw fail(0, 'invalid_request');
@@ -98,7 +120,7 @@ export async function mindsAgentTransport(options) {
             dispatched = true;
             return options.fetch(options.url, { method: read ? 'GET' : 'POST', redirect: 'error', cache: 'no-store', signal: controller.signal,
                 headers: { authorization: `Bearer ${credential}`, accept: 'application/json', ...(body === undefined ? {} : { 'content-type': 'application/json' }),
-                    ...(headerEntries.length ? { dpop: headerEntries[0][1] } : {}) }, ...(body === undefined ? {} : { body }) }).then(response => {
+                    ...(headerEntries.length ? { dpop: headerEntries[0][1] } : {}), ...(create ? { 'idempotency-key': input.body.operationId } : {}) }, ...(body === undefined ? {} : { body }) }).then(response => {
                 if (controller.signal.aborted) {
                     void response.body?.cancel().catch(() => { });
                     throw fail(0, 'transport_error');
@@ -149,14 +171,23 @@ export async function mindsAgentTransport(options) {
             if (!row(value) || !exact(value, ['error']) || !row(value.error) || !exact(value.error, ['code', 'request_id'], ['outcome', ...ENVELOPE_EXTRA_FIELDS]) || !envelopeExtrasValid(value.error)
                 || !text(value.error.code, 128) || !/^[A-Z][A-Z0-9_]*$/.test(value.error.code)
                 || !text(value.error.request_id, 256) || /[^\x21-\x7e]/.test(value.error.request_id)
-                || value.error.outcome !== undefined && value.error.outcome !== 'unknown')
+                || value.error.outcome !== undefined && value.error.outcome !== 'unknown') {
+                // Controller refusals pass through the agent-create route verbatim; keep the status, never invent a code.
+                if (creation)
+                    throw fail(response.status, 'minds_agent_error', { unknown: create && response.status >= 500 });
                 throw fail(response.status, 'invalid_response');
+            }
             const nonce = response.headers.get('dpop-nonce');
             if (value.error.code === 'DPOP_NONCE_REQUIRED' && (response.status !== 401 || !nonce || !/^[A-Za-z0-9_-]{1,512}$/.test(nonce)))
                 throw fail(response.status, 'invalid_response');
             throw fail(response.status, 'minds_agent_error', { code: value.error.code, requestId: value.error.request_id,
                 ...(value.error.code === 'DPOP_NONCE_REQUIRED' ? { dpopNonce: nonce } : {}), unknown: write && value.error.outcome === 'unknown' });
         }
+        if (creation) {
+            if (response.status !== (create ? 202 : 200) || !row(value) || typeof value.mind_id !== 'string' || !UUID.test(value.mind_id) || typeof value.status !== 'string')
+                throw fail(response.status, 'invalid_response');
+            return Response.json(value, { status: response.status, headers: { 'cache-control': 'private, no-store' } });
+        }
         if (response.status !== 200 || (write ? !row(value) || !exact(value, ['id']) || !text(value.id, 36) || !UUID.test(value.id)
             : read ? !row(value) || !exact(value, ['item']) || value.item !== null && !validStoredEvent(value.item)
                 : !Array.isArray(value) || value.length > Number(input.body.limit ?? 20) || !value.every(validStoredEvent)))
@@ -182,9 +213,21 @@ export function mindsAgentModule(client) {
         return { signal: options.signal, ...(options.dpopProof === undefined ? {} : { headers: { dpop: options.dpopProof } }) };
     };
     const query = (mind, options) => ({ mind, ...(options.group === undefined ? {} : { group: options.group }) });
-    return { memory: {
+    const proof = (options) => {
+        if (!row(options) || !exact(options, ['dpopProof'], ['signal']) || typeof options.dpopProof !== 'string')
+            throw new MindsAgentError({ status: 0, type: 'invalid_request', message: 'Agent Mind creation requires an explicit DPoP proof.' });
+        return { signal: options.signal, headers: { dpop: options.dpopProof } };
+    };
+    return {
+        /** Free/F1 Sandbox only; the fixed spec is the only shape the gateway admits. */
+        create: (input, options) => client.request('minds_agentCreateMind', { body: { schemaVersion: 1,
+                approvalId: input.approvalId, approvalVersion: input.approvalVersion, operationId: input.operationId,
+                spec: { name: input.name, region: 'us-central1-a', plan: 'free', capacity: { profile_id: 'F1', cpus: 1, memory_mb: 512, volume_size_gb: 1 }, services: ['kv', 'memory'] } } }, proof(options)),
+        createStatus: (operation_id, options) => client.request('minds_agentGetCreateOperation', { operation_id }, proof(options)),
+        memory: {
             insert: (mind, event, options = {}) => client.request('minds_agentInsertEpisodicMemory', { ...query(mind, options), body: { event } }, init(options)),
             get: (mind, storage_id, options = {}) => client.request('minds_agentGetEpisodicMemory', { ...query(mind, options), storage_id }, init(options)),
             search: (mind, text, limit = 20, options = {}) => client.request('minds_agentSearchMemory', { ...query(mind, options), body: { text, limit } }, init(options)),
-        } };
+        }
+    };
 }

package/dist/minds-engine.d.ts

@@ -0,0 +1,394 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Every Minds engine operation (Akasha daemon routes on a selected Sandbox Mind). */
+export declare const mindsEngineOperations: readonly ["minds_engineKeyValuePostKeyspace", "minds_engineKeyValueDeleteKeyspaceId", "minds_engineKeyValueGetKeyspaceId", "minds_engineKeyValuePostKeyspaceQuery", "minds_engineAnalyticsPostAnalyticsSourcesCore", "minds_engineAnalyticsPostAnalyticsSql", "minds_engineAnalyticsGetAnalyticsViews", "minds_engineAnalyticsPostAnalyticsViews", "minds_engineAnalyticsDeleteAnalyticsViewsName", "minds_engineAssociativeMemoryPostAssocMhnClear", "minds_engineAssociativeMemoryPostAssocMhnConfig", "minds_engineAssociativeMemoryPostAssocMhnList", "minds_engineAssociativeMemoryPostAssocMhnNew", "minds_engineAssociativeMemoryPostAssocMhnRetrieve", "minds_engineAssociativeMemoryPostAssocMhnRetrieveByKey", "minds_engineAssociativeMemoryPostAssocMhnRetrieveByVector", "minds_engineAssociativeMemoryPostAssocMhnStats", "minds_engineAssociativeMemoryPostAssocMhnStore", "minds_engineAssociativeMemoryPostAssocMhnSystemInfo", "minds_engineCognitiveCycleGetCognitiveCycles", "minds_engineCognitiveCyclePostCognitiveCycles", "minds_engineCognitiveCycleGetCognitiveCyclesId", "minds_engineCognitiveCycleGetCognitiveStats", "minds_engineContinualLearningGetContinualCheckpointsStatus", "minds_engineContinualLearningPostContinualComponents", "minds_engineContinualLearningPostContinualComponentsDelete", "minds_engineContinualLearningPostContinualTaskConsolidate", "minds_engineContinualLearningPostContinualTaskDelete", "minds_engineContinualLearningPostContinualTaskEvaluate", "minds_engineContinualLearningPostContinualTaskNew", "minds_engineContinualLearningPostContinualTaskPause", "minds_engineContinualLearningPostContinualTaskResume", "minds_engineContinualLearningPostContinualTaskStats", "minds_engineContinualLearningPostContinualTaskTrain", "minds_engineForgettingGetForgettingPolicies", "minds_engineForgettingPostForgettingPoliciesIdToggle", "minds_engineForgettingGetForgettingProofId", "minds_engineForgettingGetForgettingRequests", "minds_engineForgettingPostForgettingRequests", "minds_engineForgettingPostForgettingRequestsIdApprove", "minds_engineForgettingGetForgettingStats", "minds_engineKnowledgeGraphPostGraphAlgComponents", "minds_engineKnowledgeGraphPostGraphAlgPagerank", "minds_engineKnowledgeGraphPostGraphAlgShortestPath", "minds_engineKnowledgeGraphPostGraphCypher", "minds_engineKnowledgeGraphPostGraphCypherLite", "minds_engineKnowledgeGraphPostGraphFulltextSearch", "minds_engineKnowledgeGraphPostGraphIndexEnsureComposite", "minds_engineKnowledgeGraphPostGraphIndexEnsureProperty", "minds_engineKnowledgeGraphGetGraphIndexStats", "minds_engineKnowledgeGraphPostGraphMicrotheoryKeyspace", "minds_engineKnowledgeGraphPostGraphMicrotheorySwitch", "minds_engineKnowledgeGraphGetGraphSchema", "minds_engineKnowledgeGraphPostGraphSubdomainQuery", "minds_engineKnowledgeGraphPostGraphTxBegin", "minds_engineKnowledgeGraphPostGraphTxCommit", "minds_engineKnowledgeGraphPostGraphTxRollback", "minds_engineInferencePostInferenceModelId", "minds_engineInferenceGetInferenceJobs", "minds_engineInferenceGetInferenceJobsJobId", "minds_engineInferencePostInferenceJobsJobIdCancel", "minds_engineInferencePostInferenceJobsJobIdRetry", "minds_engineAnalyticsPostIngest", "minds_engineKeyValueGetKeyspaces", "minds_engineKeyValuePostKeyspaces", "minds_engineKeyValueDeleteKeyspacesName", "minds_engineKeyValueGetKeyspacesName", "minds_engineLineagePostLineageGraph", "minds_engineLineagePostLineageImpact", "minds_engineLineageGetLineageNodesId", "minds_engineLineageGetLineageStats", "minds_engineLineagePostLineageVerify", "minds_engineMcpPostMcpToolsCall", "minds_engineMcpPostMcpToolsList", "minds_engineCognitiveMemoryPostMemoryCognitiveDecision", "minds_engineCognitiveMemoryPostMemoryCognitiveInteraction", "minds_engineCognitiveMemoryPostMemoryCognitiveQuery", "minds_engineCognitiveMemoryPostMemoryCognitiveResource", "minds_engineCognitiveMemoryPostMemoryCognitiveResources", "minds_engineCognitiveMemoryPostMemoryCognitiveResourcesUsage", "minds_engineCognitiveMemoryPostMemoryCognitiveSession", "minds_engineCognitiveMemoryPostMemoryCognitiveThought", "minds_engineCognitiveMemoryPostMemoryCognitiveUsage", "minds_engineEpisodicMemoryPostMemoryEpisodic", "minds_engineEpisodicMemoryDeleteMemoryEpisodicId", "minds_engineEpisodicMemoryGetMemoryEpisodicId", "minds_engineEpisodicMemoryPutMemoryEpisodicId", "minds_engineEpisodicMemoryPostMemoryEpisodicSearch", "minds_engineProceduralMemoryPostMemoryProcedures", "minds_engineProceduralMemoryPostMemoryProceduresDelete", "minds_engineProceduralMemoryPostMemoryProceduresGet", "minds_engineProceduralMemoryGetMemoryProceduresList", "minds_engineProceduralMemoryPostMemoryProceduresSearch", "minds_engineProceduralMemoryPostMemoryProceduresUpdate", "minds_engineMemoryGetMemoryReindexStatus", "minds_engineResourceMemoryPostMemoryResources", "minds_engineResourceMemoryPostMemoryResourcesAccess", "minds_engineResourceMemoryPostMemoryResourcesChunks", "minds_engineResourceMemoryPostMemoryResourcesData", "minds_engineResourceMemoryPostMemoryResourcesDataExists", "minds_engineResourceMemoryPostMemoryResourcesDataSize", "minds_engineResourceMemoryPostMemoryResourcesGet", "minds_engineResourceMemoryGetMemoryResourcesList", "minds_engineResourceMemoryPostMemoryResourcesType", "minds_engineResourceMemoryPostMemoryResourcesUsage", "minds_engineMemoryPostMemoryRetrievalHybrid", "minds_engineMemoryGetMemoryStats", "minds_engineVaultPostMemoryVault", "minds_engineVaultPostMemoryVaultAccessLog", "minds_engineVaultPostMemoryVaultDelete", "minds_engineVaultPostMemoryVaultGet", "minds_engineVaultPostMemoryVaultSearch", "minds_engineVaultGetMemoryVaultStats", "minds_engineVaultPostMemoryVaultUpdate", "minds_engineMachineLearningPostMlEmbed", "minds_engineMachineLearningPostMlGenerate", "minds_engineMachineLearningPostMlMetrics", "minds_engineMachineLearningGetMlModels", "minds_engineMachineLearningPostMlModelsLoad", "minds_engineMachineLearningPostMlModelsUnload", "minds_engineMachineLearningPostMlTokenizersLoad", "minds_engineMachineLearningPostMlTrainHrm", "minds_engineMachineLearningPostMlTrainSupervised", "minds_engineVectorsGetMlVector", "minds_engineVectorsPostMlVectorAdd", "minds_engineVectorsPostMlVectorCreate", "minds_engineVectorsPostMlVectorSave", "minds_engineVectorsPostMlVectorSearch", "minds_engineReasoningGetNsCacheStats", "minds_engineReasoningGetNsHistory", "minds_engineReasoningPostNsPathsFind", "minds_engineReasoningPostNsPrefetchStart", "minds_engineReasoningPostNsPrefetchStop", "minds_engineReasoningPostNsRetrieve", "minds_engineReasoningPostNsRetrieveWithMode", "minds_engineReasoningGetNsRules", "minds_engineReasoningGetNsStats", "minds_engineKeyValuePostPrimitivesExport", "minds_engineKeyValuePostPrimitivesImport", "minds_engineLearningIsolationGetQuarantineItems", "minds_engineLearningIsolationGetQuarantineItemsId", "minds_engineLearningIsolationPostQuarantineItemsIdApprove", "minds_engineLearningIsolationPostQuarantineItemsIdReject", "minds_engineLearningIsolationGetQuarantinePolicies", "minds_engineLearningIsolationGetQuarantineStats", "minds_engineLearningIsolationPostQuarantineTestGate", "minds_engineMaintenancePostSearchText", "minds_engineSpikingNetworksPostSnnNetworkBuild", "minds_engineSpikingNetworksPostSnnNetworkCompile", "minds_engineSpikingNetworksPostSnnNetworkState", "minds_engineSpikingNetworksPostSnnNetworkStep", "minds_engineSpikingNetworksPostSnnNeurons", "minds_engineSpikingNetworksGetSnnStats", "minds_engineSpikingNetworksPostSnnTrainBptt", "minds_engineKeyValueGetStats", "minds_engineTextChunkingPostTextChunk", "minds_engineTextChunkingGetTextChunkConfig", "minds_engineTransactionsPostTxAbort", "minds_engineTransactionsPostTxBegin", "minds_engineTransactionsPostTxCommit", "minds_engineWorkingMemoryGetWorkingMemorySlots", "minds_engineWorkingMemoryPostWorkingMemorySlotsClear", "minds_engineWorkingMemoryPostWorkingMemorySlotsInject", "minds_engineWorkingMemoryGetWorkingMemoryStats"];
+export type MindsEngineOperation = typeof mindsEngineOperations[number];
+export declare const isMindsEngineOperation: (id: string) => id is MindsEngineOperation;
+/** `genesis minds engine <family> <verb>` -> operation id (CLI and coverage). */
+export declare const mindsEngineCommands: Readonly<Record<string, MindsEngineOperation>>;
+type Rest<K extends MindsEngineOperation> = Omit<In<K>, 'mind_id'>;
+export interface MindsEngineOptions {
+    signal?: AbortSignal;
+}
+/** genesis.minds.engine.<family>.<verb>(mindId, input): the Mind's engine routes, one capability per call. */
+export declare function mindsEngineModule(client: GenesisClient): {
+    keyValue: {
+        /** POST /v1/:keyspace (minds:instances:update). */
+        post: (mindId: string, input: Rest<"minds_engineKeyValuePostKeyspace">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** DELETE /v1/:keyspace/:id (minds:instances:update). */
+        delete: (mindId: string, input: Rest<"minds_engineKeyValueDeleteKeyspaceId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/:keyspace/:id (minds:instances:read). */
+        get: (mindId: string, input: Rest<"minds_engineKeyValueGetKeyspaceId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/:keyspace/query (minds:instances:read). */
+        postQuery: (mindId: string, input: Rest<"minds_engineKeyValuePostKeyspaceQuery">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/keyspaces (minds:instances:read). */
+        getKeyspaces: (mindId: string, input?: Rest<"minds_engineKeyValueGetKeyspaces">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/keyspaces (minds:instances:manage, refused until manage is mintable). */
+        postKeyspaces: (mindId: string, input: Rest<"minds_engineKeyValuePostKeyspaces">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** DELETE /v1/keyspaces/:name (minds:instances:manage, refused until manage is mintable). */
+        deleteKeyspaces: (mindId: string, input: Rest<"minds_engineKeyValueDeleteKeyspacesName">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/keyspaces/:name (minds:instances:read). */
+        getKeyspacesByName: (mindId: string, input: Rest<"minds_engineKeyValueGetKeyspacesName">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/primitives/export (minds:instances:read). */
+        postPrimitivesExport: (mindId: string, input: Rest<"minds_engineKeyValuePostPrimitivesExport">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/primitives/import (minds:instances:update). */
+        postPrimitivesImport: (mindId: string, input: Rest<"minds_engineKeyValuePostPrimitivesImport">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/stats (minds:instances:read). */
+        getStats: (mindId: string, input?: Rest<"minds_engineKeyValueGetStats">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    analytics: {
+        /** POST /v1/analytics/sources/core (minds:instances:manage, refused until manage is mintable). */
+        postAnalyticsSourcesCore: (mindId: string, input: Rest<"minds_engineAnalyticsPostAnalyticsSourcesCore">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/analytics/sql (minds:instances:manage, refused until manage is mintable). */
+        postAnalyticsSql: (mindId: string, input: Rest<"minds_engineAnalyticsPostAnalyticsSql">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/analytics/views (minds:instances:manage, refused until manage is mintable). */
+        getAnalyticsViews: (mindId: string, input?: Rest<"minds_engineAnalyticsGetAnalyticsViews">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/analytics/views (minds:instances:manage, refused until manage is mintable). */
+        postAnalyticsViews: (mindId: string, input: Rest<"minds_engineAnalyticsPostAnalyticsViews">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** DELETE /v1/analytics/views/:name (minds:instances:manage, refused until manage is mintable). */
+        deleteAnalyticsViews: (mindId: string, input: Rest<"minds_engineAnalyticsDeleteAnalyticsViewsName">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ingest (minds:instances:manage, refused until manage is mintable). */
+        postIngest: (mindId: string, input: Rest<"minds_engineAnalyticsPostIngest">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    associativeMemory: {
+        /** POST /v1/assoc/mhn/clear (minds:instances:manage, refused until manage is mintable). */
+        postClear: (mindId: string, input: Rest<"minds_engineAssociativeMemoryPostAssocMhnClear">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/assoc/mhn/config (minds:instances:read). */
+        postConfig: (mindId: string, input: Rest<"minds_engineAssociativeMemoryPostAssocMhnConfig">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/assoc/mhn/list (minds:instances:read). */
+        postList: (mindId: string, input: Rest<"minds_engineAssociativeMemoryPostAssocMhnList">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/assoc/mhn/new (minds:instances:manage, refused until manage is mintable). */
+        postNew: (mindId: string, input: Rest<"minds_engineAssociativeMemoryPostAssocMhnNew">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/assoc/mhn/retrieve (minds:instances:read). */
+        postRetrieve: (mindId: string, input: Rest<"minds_engineAssociativeMemoryPostAssocMhnRetrieve">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/assoc/mhn/retrieve_by_key (minds:instances:read). */
+        postRetrieveByKey: (mindId: string, input: Rest<"minds_engineAssociativeMemoryPostAssocMhnRetrieveByKey">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/assoc/mhn/retrieve_by_vector (minds:instances:read). */
+        postRetrieveByVector: (mindId: string, input: Rest<"minds_engineAssociativeMemoryPostAssocMhnRetrieveByVector">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/assoc/mhn/stats (minds:instances:read). */
+        postStats: (mindId: string, input: Rest<"minds_engineAssociativeMemoryPostAssocMhnStats">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/assoc/mhn/store (minds:instances:update). */
+        postStore: (mindId: string, input: Rest<"minds_engineAssociativeMemoryPostAssocMhnStore">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/assoc/mhn/system_info (minds:instances:read). */
+        postSystemInfo: (mindId: string, input: Rest<"minds_engineAssociativeMemoryPostAssocMhnSystemInfo">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    cognitiveCycle: {
+        /** GET /v1/cognitive/cycles (minds:instances:read). */
+        getCycles: (mindId: string, input?: Rest<"minds_engineCognitiveCycleGetCognitiveCycles">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/cognitive/cycles (minds:instances:update). */
+        postCycles: (mindId: string, input: Rest<"minds_engineCognitiveCyclePostCognitiveCycles">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/cognitive/cycles/:id (minds:instances:read). */
+        getCyclesById: (mindId: string, input: Rest<"minds_engineCognitiveCycleGetCognitiveCyclesId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/cognitive/stats (minds:instances:read). */
+        getStats: (mindId: string, input?: Rest<"minds_engineCognitiveCycleGetCognitiveStats">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    continualLearning: {
+        /** GET /v1/continual/checkpoints/status (minds:instances:manage, refused until manage is mintable). */
+        getCheckpointsStatus: (mindId: string, input?: Rest<"minds_engineContinualLearningGetContinualCheckpointsStatus">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/continual/components (minds:instances:manage, refused until manage is mintable). */
+        postComponents: (mindId: string, input: Rest<"minds_engineContinualLearningPostContinualComponents">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/continual/components/delete (minds:instances:manage, refused until manage is mintable). */
+        postComponentsDelete: (mindId: string, input: Rest<"minds_engineContinualLearningPostContinualComponentsDelete">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/continual/task/consolidate (minds:instances:manage, refused until manage is mintable). */
+        postTaskConsolidate: (mindId: string, input: Rest<"minds_engineContinualLearningPostContinualTaskConsolidate">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/continual/task/delete (minds:instances:manage, refused until manage is mintable). */
+        postTaskDelete: (mindId: string, input: Rest<"minds_engineContinualLearningPostContinualTaskDelete">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/continual/task/evaluate (minds:instances:manage, refused until manage is mintable). */
+        postTaskEvaluate: (mindId: string, input: Rest<"minds_engineContinualLearningPostContinualTaskEvaluate">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/continual/task/new (minds:instances:manage, refused until manage is mintable). */
+        postTaskNew: (mindId: string, input: Rest<"minds_engineContinualLearningPostContinualTaskNew">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/continual/task/pause (minds:instances:manage, refused until manage is mintable). */
+        postTaskPause: (mindId: string, input: Rest<"minds_engineContinualLearningPostContinualTaskPause">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/continual/task/resume (minds:instances:manage, refused until manage is mintable). */
+        postTaskResume: (mindId: string, input: Rest<"minds_engineContinualLearningPostContinualTaskResume">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/continual/task/stats (minds:instances:manage, refused until manage is mintable). */
+        postTaskStats: (mindId: string, input: Rest<"minds_engineContinualLearningPostContinualTaskStats">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/continual/task/train (minds:instances:manage, refused until manage is mintable). */
+        postTaskTrain: (mindId: string, input: Rest<"minds_engineContinualLearningPostContinualTaskTrain">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    forgetting: {
+        /** GET /v1/forgetting/policies (minds:instances:read). */
+        getPolicies: (mindId: string, input?: Rest<"minds_engineForgettingGetForgettingPolicies">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/forgetting/policies/:id/toggle (minds:instances:read). */
+        postPoliciesToggle: (mindId: string, input: Rest<"minds_engineForgettingPostForgettingPoliciesIdToggle">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/forgetting/proof/:id (minds:instances:read). */
+        getProof: (mindId: string, input: Rest<"minds_engineForgettingGetForgettingProofId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/forgetting/requests (minds:instances:read). */
+        getRequests: (mindId: string, input?: Rest<"minds_engineForgettingGetForgettingRequests">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/forgetting/requests (minds:instances:read). */
+        postRequests: (mindId: string, input: Rest<"minds_engineForgettingPostForgettingRequests">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/forgetting/requests/:id/approve (minds:instances:read). */
+        postRequestsApprove: (mindId: string, input: Rest<"minds_engineForgettingPostForgettingRequestsIdApprove">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/forgetting/stats (minds:instances:read). */
+        getStats: (mindId: string, input?: Rest<"minds_engineForgettingGetForgettingStats">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    knowledgeGraph: {
+        /** POST /v1/graph/alg/components (minds:instances:manage, refused until manage is mintable). */
+        postAlgComponents: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphAlgComponents">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/alg/pagerank (minds:instances:manage, refused until manage is mintable). */
+        postAlgPagerank: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphAlgPagerank">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/alg/shortest_path (minds:instances:manage, refused until manage is mintable). */
+        postAlgShortestPath: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphAlgShortestPath">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/cypher (minds:instances:manage, refused until manage is mintable). */
+        postCypher: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphCypher">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/cypher-lite (minds:instances:manage, refused until manage is mintable). */
+        postCypherLite: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphCypherLite">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/fulltext/search (minds:instances:manage, refused until manage is mintable). */
+        postFulltextSearch: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphFulltextSearch">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/index/ensure/composite (minds:instances:manage, refused until manage is mintable). */
+        postIndexEnsureComposite: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphIndexEnsureComposite">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/index/ensure/property (minds:instances:manage, refused until manage is mintable). */
+        postIndexEnsureProperty: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphIndexEnsureProperty">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/graph/index/stats (minds:instances:manage, refused until manage is mintable). */
+        getIndexStats: (mindId: string, input?: Rest<"minds_engineKnowledgeGraphGetGraphIndexStats">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/microtheory/keyspace (minds:instances:manage, refused until manage is mintable). */
+        postMicrotheoryKeyspace: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphMicrotheoryKeyspace">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/microtheory/switch (minds:instances:manage, refused until manage is mintable). */
+        postMicrotheorySwitch: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphMicrotheorySwitch">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/graph/schema (minds:instances:manage, refused until manage is mintable). */
+        getSchema: (mindId: string, input?: Rest<"minds_engineKnowledgeGraphGetGraphSchema">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/subdomain/query (minds:instances:manage, refused until manage is mintable). */
+        postSubdomainQuery: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphSubdomainQuery">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/tx/begin (minds:instances:manage, refused until manage is mintable). */
+        postTxBegin: (mindId: string, input?: Rest<"minds_engineKnowledgeGraphPostGraphTxBegin">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/tx/commit (minds:instances:manage, refused until manage is mintable). */
+        postTxCommit: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphTxCommit">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/graph/tx/rollback (minds:instances:manage, refused until manage is mintable). */
+        postTxRollback: (mindId: string, input: Rest<"minds_engineKnowledgeGraphPostGraphTxRollback">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    inference: {
+        /** POST /v1/inference/:model_id (minds:instances:manage, refused until manage is mintable). */
+        post: (mindId: string, input: Rest<"minds_engineInferencePostInferenceModelId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/inference/jobs (minds:instances:manage, refused until manage is mintable). */
+        getJobs: (mindId: string, input?: Rest<"minds_engineInferenceGetInferenceJobs">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/inference/jobs/:job_id (minds:instances:manage, refused until manage is mintable). */
+        getJobsByJobId: (mindId: string, input: Rest<"minds_engineInferenceGetInferenceJobsJobId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/inference/jobs/:job_id/cancel (minds:instances:manage, refused until manage is mintable). */
+        postJobsCancel: (mindId: string, input: Rest<"minds_engineInferencePostInferenceJobsJobIdCancel">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/inference/jobs/:job_id/retry (minds:instances:manage, refused until manage is mintable). */
+        postJobsRetry: (mindId: string, input: Rest<"minds_engineInferencePostInferenceJobsJobIdRetry">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    lineage: {
+        /** POST /v1/lineage/graph (minds:instances:manage, refused until manage is mintable). */
+        postGraph: (mindId: string, input: Rest<"minds_engineLineagePostLineageGraph">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/lineage/impact (minds:instances:manage, refused until manage is mintable). */
+        postImpact: (mindId: string, input: Rest<"minds_engineLineagePostLineageImpact">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/lineage/nodes/:id (minds:instances:manage, refused until manage is mintable). */
+        getNodes: (mindId: string, input: Rest<"minds_engineLineageGetLineageNodesId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/lineage/stats (minds:instances:manage, refused until manage is mintable). */
+        getStats: (mindId: string, input?: Rest<"minds_engineLineageGetLineageStats">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/lineage/verify (minds:instances:manage, refused until manage is mintable). */
+        postVerify: (mindId: string, input: Rest<"minds_engineLineagePostLineageVerify">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    mcp: {
+        /** POST /v1/mcp/tools/call (minds:instances:manage, refused until manage is mintable). */
+        postCall: (mindId: string, input: Rest<"minds_engineMcpPostMcpToolsCall">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/mcp/tools/list (minds:instances:read). */
+        postList: (mindId: string, input: Rest<"minds_engineMcpPostMcpToolsList">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    cognitiveMemory: {
+        /** POST /v1/memory/cognitive/decision (minds:instances:update). */
+        postDecision: (mindId: string, input: Rest<"minds_engineCognitiveMemoryPostMemoryCognitiveDecision">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/cognitive/interaction (minds:instances:update). */
+        postInteraction: (mindId: string, input: Rest<"minds_engineCognitiveMemoryPostMemoryCognitiveInteraction">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/cognitive/query (minds:instances:read). */
+        postQuery: (mindId: string, input: Rest<"minds_engineCognitiveMemoryPostMemoryCognitiveQuery">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/cognitive/resource (minds:instances:read). */
+        postResource: (mindId: string, input: Rest<"minds_engineCognitiveMemoryPostMemoryCognitiveResource">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/cognitive/resources (minds:instances:update). */
+        postResources: (mindId: string, input: Rest<"minds_engineCognitiveMemoryPostMemoryCognitiveResources">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/cognitive/resources/usage (minds:instances:read). */
+        postResourcesUsage: (mindId: string, input: Rest<"minds_engineCognitiveMemoryPostMemoryCognitiveResourcesUsage">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/cognitive/session (minds:instances:update). */
+        postSession: (mindId: string, input: Rest<"minds_engineCognitiveMemoryPostMemoryCognitiveSession">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/cognitive/thought (minds:instances:update). */
+        postThought: (mindId: string, input: Rest<"minds_engineCognitiveMemoryPostMemoryCognitiveThought">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/cognitive/usage (minds:instances:read). */
+        postUsage: (mindId: string, input: Rest<"minds_engineCognitiveMemoryPostMemoryCognitiveUsage">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    episodicMemory: {
+        /** POST /v1/memory/episodic (minds:instances:update). */
+        post: (mindId: string, input: Rest<"minds_engineEpisodicMemoryPostMemoryEpisodic">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** DELETE /v1/memory/episodic/:id (minds:instances:update). */
+        delete: (mindId: string, input: Rest<"minds_engineEpisodicMemoryDeleteMemoryEpisodicId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/memory/episodic/:id (minds:instances:read). */
+        get: (mindId: string, input: Rest<"minds_engineEpisodicMemoryGetMemoryEpisodicId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** PUT /v1/memory/episodic/:id (minds:instances:update). */
+        put: (mindId: string, input: Rest<"minds_engineEpisodicMemoryPutMemoryEpisodicId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/episodic/search (minds:instances:read). */
+        postSearch: (mindId: string, input: Rest<"minds_engineEpisodicMemoryPostMemoryEpisodicSearch">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    proceduralMemory: {
+        /** POST /v1/memory/procedures (minds:instances:update). */
+        post: (mindId: string, input: Rest<"minds_engineProceduralMemoryPostMemoryProcedures">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/procedures/delete (minds:instances:update). */
+        postDelete: (mindId: string, input: Rest<"minds_engineProceduralMemoryPostMemoryProceduresDelete">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/procedures/get (minds:instances:read). */
+        postGet: (mindId: string, input: Rest<"minds_engineProceduralMemoryPostMemoryProceduresGet">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/memory/procedures/list (minds:instances:read). */
+        getList: (mindId: string, input?: Rest<"minds_engineProceduralMemoryGetMemoryProceduresList">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/procedures/search (minds:instances:read). */
+        postSearch: (mindId: string, input: Rest<"minds_engineProceduralMemoryPostMemoryProceduresSearch">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/procedures/update (minds:instances:update). */
+        postUpdate: (mindId: string, input: Rest<"minds_engineProceduralMemoryPostMemoryProceduresUpdate">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    memory: {
+        /** GET /v1/memory/reindex/status (minds:instances:read). */
+        getReindexStatus: (mindId: string, input?: Rest<"minds_engineMemoryGetMemoryReindexStatus">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/retrieval/hybrid (minds:instances:read). */
+        postRetrievalHybrid: (mindId: string, input: Rest<"minds_engineMemoryPostMemoryRetrievalHybrid">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/memory/stats (minds:instances:read). */
+        getStats: (mindId: string, input?: Rest<"minds_engineMemoryGetMemoryStats">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    resourceMemory: {
+        /** POST /v1/memory/resources (minds:instances:update). */
+        post: (mindId: string, input: Rest<"minds_engineResourceMemoryPostMemoryResources">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/resources/access (minds:instances:update). */
+        postAccess: (mindId: string, input: Rest<"minds_engineResourceMemoryPostMemoryResourcesAccess">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/resources/chunks (minds:instances:read). */
+        postChunks: (mindId: string, input: Rest<"minds_engineResourceMemoryPostMemoryResourcesChunks">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/resources/data (minds:instances:read). */
+        postData: (mindId: string, input: Rest<"minds_engineResourceMemoryPostMemoryResourcesData">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/resources/data/exists (minds:instances:read). */
+        postDataExists: (mindId: string, input: Rest<"minds_engineResourceMemoryPostMemoryResourcesDataExists">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/resources/data/size (minds:instances:read). */
+        postDataSize: (mindId: string, input: Rest<"minds_engineResourceMemoryPostMemoryResourcesDataSize">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/resources/get (minds:instances:read). */
+        postGet: (mindId: string, input: Rest<"minds_engineResourceMemoryPostMemoryResourcesGet">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/memory/resources/list (minds:instances:read). */
+        getList: (mindId: string, input?: Rest<"minds_engineResourceMemoryGetMemoryResourcesList">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/resources/type (minds:instances:read). */
+        postType: (mindId: string, input: Rest<"minds_engineResourceMemoryPostMemoryResourcesType">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/resources/usage (minds:instances:read). */
+        postUsage: (mindId: string, input: Rest<"minds_engineResourceMemoryPostMemoryResourcesUsage">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    vault: {
+        /** POST /v1/memory/vault (minds:instances:update). */
+        post: (mindId: string, input: Rest<"minds_engineVaultPostMemoryVault">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/vault/access-log (minds:instances:manage, refused until manage is mintable). */
+        postAccessLog: (mindId: string, input: Rest<"minds_engineVaultPostMemoryVaultAccessLog">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/vault/delete (minds:instances:update). */
+        postDelete: (mindId: string, input: Rest<"minds_engineVaultPostMemoryVaultDelete">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/vault/get (minds:instances:read). */
+        postGet: (mindId: string, input: Rest<"minds_engineVaultPostMemoryVaultGet">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/vault/search (minds:instances:read). */
+        postSearch: (mindId: string, input: Rest<"minds_engineVaultPostMemoryVaultSearch">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/memory/vault/stats (minds:instances:read). */
+        getStats: (mindId: string, input?: Rest<"minds_engineVaultGetMemoryVaultStats">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/memory/vault/update (minds:instances:update). */
+        postUpdate: (mindId: string, input: Rest<"minds_engineVaultPostMemoryVaultUpdate">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    machineLearning: {
+        /** POST /v1/ml/embed (minds:instances:manage, refused until manage is mintable). */
+        postEmbed: (mindId: string, input: Rest<"minds_engineMachineLearningPostMlEmbed">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/generate (minds:instances:manage, refused until manage is mintable). */
+        postGenerate: (mindId: string, input: Rest<"minds_engineMachineLearningPostMlGenerate">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/metrics (minds:instances:manage, refused until manage is mintable). */
+        postMetrics: (mindId: string, input: Rest<"minds_engineMachineLearningPostMlMetrics">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/ml/models (minds:instances:manage, refused until manage is mintable). */
+        getModels: (mindId: string, input?: Rest<"minds_engineMachineLearningGetMlModels">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/models/load (minds:instances:manage, refused until manage is mintable). */
+        postModelsLoad: (mindId: string, input: Rest<"minds_engineMachineLearningPostMlModelsLoad">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/models/unload (minds:instances:manage, refused until manage is mintable). */
+        postModelsUnload: (mindId: string, input: Rest<"minds_engineMachineLearningPostMlModelsUnload">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/tokenizers/load (minds:instances:manage, refused until manage is mintable). */
+        postTokenizersLoad: (mindId: string, input: Rest<"minds_engineMachineLearningPostMlTokenizersLoad">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/train/hrm (minds:instances:manage, refused until manage is mintable). */
+        postTrainHrm: (mindId: string, input: Rest<"minds_engineMachineLearningPostMlTrainHrm">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/train/supervised (minds:instances:manage, refused until manage is mintable). */
+        postTrainSupervised: (mindId: string, input: Rest<"minds_engineMachineLearningPostMlTrainSupervised">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    vectors: {
+        /** GET /v1/ml/vector (minds:instances:manage, refused until manage is mintable). */
+        get: (mindId: string, input?: Rest<"minds_engineVectorsGetMlVector">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/vector/add (minds:instances:manage, refused until manage is mintable). */
+        postAdd: (mindId: string, input: Rest<"minds_engineVectorsPostMlVectorAdd">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/vector/create (minds:instances:manage, refused until manage is mintable). */
+        postCreate: (mindId: string, input: Rest<"minds_engineVectorsPostMlVectorCreate">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/vector/save (minds:instances:manage, refused until manage is mintable). */
+        postSave: (mindId: string, input: Rest<"minds_engineVectorsPostMlVectorSave">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ml/vector/search (minds:instances:manage, refused until manage is mintable). */
+        postSearch: (mindId: string, input: Rest<"minds_engineVectorsPostMlVectorSearch">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    reasoning: {
+        /** GET /v1/ns/cache/stats (minds:instances:manage, refused until manage is mintable). */
+        getCacheStats: (mindId: string, input?: Rest<"minds_engineReasoningGetNsCacheStats">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/ns/history (minds:instances:manage, refused until manage is mintable). */
+        getHistory: (mindId: string, input?: Rest<"minds_engineReasoningGetNsHistory">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ns/paths/find (minds:instances:manage, refused until manage is mintable). */
+        postPathsFind: (mindId: string, input: Rest<"minds_engineReasoningPostNsPathsFind">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ns/prefetch/start (minds:instances:manage, refused until manage is mintable). */
+        postPrefetchStart: (mindId: string, input: Rest<"minds_engineReasoningPostNsPrefetchStart">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ns/prefetch/stop (minds:instances:manage, refused until manage is mintable). */
+        postPrefetchStop: (mindId: string, input?: Rest<"minds_engineReasoningPostNsPrefetchStop">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ns/retrieve (minds:instances:manage, refused until manage is mintable). */
+        postRetrieve: (mindId: string, input: Rest<"minds_engineReasoningPostNsRetrieve">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/ns/retrieve_with_mode (minds:instances:manage, refused until manage is mintable). */
+        postRetrieveWithMode: (mindId: string, input: Rest<"minds_engineReasoningPostNsRetrieveWithMode">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/ns/rules (minds:instances:manage, refused until manage is mintable). */
+        getRules: (mindId: string, input?: Rest<"minds_engineReasoningGetNsRules">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/ns/stats (minds:instances:manage, refused until manage is mintable). */
+        getStats: (mindId: string, input?: Rest<"minds_engineReasoningGetNsStats">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    learningIsolation: {
+        /** GET /v1/quarantine/items (minds:instances:read). */
+        getItems: (mindId: string, input?: Rest<"minds_engineLearningIsolationGetQuarantineItems">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/quarantine/items/:id (minds:instances:read). */
+        getItemsById: (mindId: string, input: Rest<"minds_engineLearningIsolationGetQuarantineItemsId">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/quarantine/items/:id/approve (minds:instances:update). */
+        postItemsApprove: (mindId: string, input: Rest<"minds_engineLearningIsolationPostQuarantineItemsIdApprove">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/quarantine/items/:id/reject (minds:instances:update). */
+        postItemsReject: (mindId: string, input: Rest<"minds_engineLearningIsolationPostQuarantineItemsIdReject">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/quarantine/policies (minds:instances:read). */
+        getPolicies: (mindId: string, input?: Rest<"minds_engineLearningIsolationGetQuarantinePolicies">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/quarantine/stats (minds:instances:read). */
+        getStats: (mindId: string, input?: Rest<"minds_engineLearningIsolationGetQuarantineStats">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/quarantine/test-gate (minds:instances:read). */
+        postTestGate: (mindId: string, input: Rest<"minds_engineLearningIsolationPostQuarantineTestGate">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    maintenance: {
+        /** POST /v1/search/text (minds:instances:manage, refused until manage is mintable). */
+        postSearchText: (mindId: string, input: Rest<"minds_engineMaintenancePostSearchText">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    spikingNetworks: {
+        /** POST /v1/snn/network/build (minds:instances:manage, refused until manage is mintable). */
+        postNetworkBuild: (mindId: string, input: Rest<"minds_engineSpikingNetworksPostSnnNetworkBuild">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/snn/network/compile (minds:instances:update). */
+        postNetworkCompile: (mindId: string, input: Rest<"minds_engineSpikingNetworksPostSnnNetworkCompile">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/snn/network/state (minds:instances:read). */
+        postNetworkState: (mindId: string, input: Rest<"minds_engineSpikingNetworksPostSnnNetworkState">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/snn/network/step (minds:instances:update). */
+        postNetworkStep: (mindId: string, input: Rest<"minds_engineSpikingNetworksPostSnnNetworkStep">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/snn/neurons (minds:instances:read). */
+        postNeurons: (mindId: string, input: Rest<"minds_engineSpikingNetworksPostSnnNeurons">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/snn/stats (minds:instances:read). */
+        getStats: (mindId: string, input?: Rest<"minds_engineSpikingNetworksGetSnnStats">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/snn/train/bptt (minds:instances:update). */
+        postTrainBptt: (mindId: string, input: Rest<"minds_engineSpikingNetworksPostSnnTrainBptt">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    textChunking: {
+        /** POST /v1/text/chunk (minds:instances:read). */
+        post: (mindId: string, input: Rest<"minds_engineTextChunkingPostTextChunk">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/text/chunk/config (minds:instances:read). */
+        getConfig: (mindId: string, input?: Rest<"minds_engineTextChunkingGetTextChunkConfig">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    transactions: {
+        /** POST /v1/tx/abort (minds:instances:manage, refused until manage is mintable). */
+        postAbort: (mindId: string, input: Rest<"minds_engineTransactionsPostTxAbort">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/tx/begin (minds:instances:manage, refused until manage is mintable). */
+        postBegin: (mindId: string, input: Rest<"minds_engineTransactionsPostTxBegin">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/tx/commit (minds:instances:manage, refused until manage is mintable). */
+        postCommit: (mindId: string, input: Rest<"minds_engineTransactionsPostTxCommit">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+    workingMemory: {
+        /** GET /v1/working-memory/slots (minds:instances:read). */
+        getSlots: (mindId: string, input?: Rest<"minds_engineWorkingMemoryGetWorkingMemorySlots">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/working-memory/slots/clear (minds:instances:update). */
+        postSlotsClear: (mindId: string, input: Rest<"minds_engineWorkingMemoryPostWorkingMemorySlotsClear">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** POST /v1/working-memory/slots/inject (minds:instances:update). */
+        postSlotsInject: (mindId: string, input: Rest<"minds_engineWorkingMemoryPostWorkingMemorySlotsInject">, options?: MindsEngineOptions) => Promise<unknown>;
+        /** GET /v1/working-memory/stats (minds:instances:read). */
+        getStats: (mindId: string, input?: Rest<"minds_engineWorkingMemoryGetWorkingMemoryStats">, options?: MindsEngineOptions) => Promise<unknown>;
+    };
+};
+export {};