@kmlckj/licos-platform-sdk 0.9.0 → 0.10.1

package/README.md

@@ -119,94 +119,114 @@ const results = await knowledge.search('How do I reset my password?', {
 });
 ```
 
-The browser entry does not export knowledge helpers because runtime tokens must
-not be bundled into public frontend code.
-
-## Unified Namespace (UNS)
-
-UNS helpers expose the same Schema, resource discovery, validation, plan,
-apply, binding, data, point, video, and enterprise path APIs as the Python
-platform SDK. They are server-only and derive the trusted project scope from
-the injected runtime identity.
-
-```js
-import { uns } from '@kmlckj/licos-platform-sdk';
-
-const schema = await uns.schemaCurrent();
-const checked = await uns.validate(document);
-const reviewedPlan = await uns.plan(document);
-
-await uns.apply(document, {
-  expectedDocumentHash: reviewedPlan.documentHash,
-  expectedPlanHash: reviewedPlan.planHash,
-  confirmed: true,
-});
-```
-
-Use a `UNSChangeSet` for an isolated structural change. Review the dedicated
-plan and pass both hashes back unchanged. Destructive or replacement actions
-also require `impactConfirmed: true`.
-
-```js
-const changes = await uns.planChanges(changeSet);
-await uns.applyChanges(changeSet, {
-  expectedDocumentHash: changes.documentHash,
-  expectedPlanHash: changes.planHash,
-  confirmed: true,
-  impactConfirmed: true,
-});
-```
-
-Use `uns.openPath(path)` when business code targets an existing enterprise UNS
-path without creating or changing `UNS.json`:
-
-```js
-const temperature = uns.openPath('project:/production-line/temperature');
-const current = await temperature.pointCurrent();
-```
-
-Realtime point consumers obtain the server-side WebSocket endpoint through the
-authorized project runtime API. Create one upstream connection per returned
-`nodeCode`; do not derive or hardcode a DataFactory address:
-
-```js
-const realtime = await uns.pointRealtimeConfig('TEMP_01');
-// Connect to realtime.websocketUrl and register with realtime.nodeCode.
-```
-
-Resource apply, data writes, point writes, and video controls require explicit
-confirmation. Data deletion accepts the exact rows returned by a prior query
-and also requires explicit confirmation. Point writes require a reason and ticket. The browser entry
-does not export UNS helpers.
+The browser entry does not export knowledge helpers because runtime tokens must
+not be bundled into public frontend code.
 
-## Direct Industrial Integration
+### Enterprise knowledge
 
-The server-only `industrial` facade manages collection and video resources
-without creating DataFactory UNS nodes. Use it only when the user explicitly
-selects direct collector integration; UNS failures must not trigger this mode.
+Enterprise knowledge is a separate, enterprise-user-only resource model. The
+platform derives tenant scope and permissions from the current user token; do
+not pass tenant IDs from application code.
 
 ```js
-import { industrial } from '@kmlckj/licos-platform-sdk';
+import { enterpriseKnowledge } from '@kmlckj/licos-platform-sdk';
 
-const points = await industrial.searchResources('collectionPoint', {
-  scope: 'project',
-  keyword: 'temperature',
+const tree = await enterpriseKnowledge.tree({
+  includeTypes: ['STANDARD', 'GRAPH', 'OBJECT_STORAGE'],
 });
 
-const current = await industrial.pointCurrent(points.items[0].id);
-const realtime = await industrial.realtimeConnection({
-  pointIds: [points.items[0].id],
-  transport: 'websocket',
-});
+const validation = await enterpriseKnowledge.validateReferences(
+  ['knowledge-source-id'],
+  { requiredCapability: 'retrieve' },
+);
+
+if (validation.valid) {
+  const evidence = await enterpriseKnowledge.retrieve(
+    '设备停机前必须完成哪些检查？',
+    ['knowledge-source-id'],
+  );
+}
+
+await enterpriseKnowledge.uploadDocumentChunked(
+  'knowledge-source-id',
+  '/workspace/projects/manual.pdf',
+);
+```
+
+The API covers folders, knowledge-base lifecycle, resource audits, document
+listing and chunk inspection, resumable uploads, processing tasks, retrieval,
+and object-storage knowledge bases. Temporary document/object URLs must be
+obtained with `getDocumentOriginalUrl` or `getObjectDownloadUrl`; do not build
+storage URLs manually.
+
+## Unified Namespace (UNS)
+
+UNS helpers use the platform UNS Modeling module. Isolation follows the tenant
+UNS directory hierarchy rather than a project-local namespace. The helpers are
+server-only and use the injected platform identity.
+
+```js
+import { uns } from '@kmlckj/licos-platform-sdk';
+
+const schema = await uns.provisioningSchema();
+const capabilities = await uns.provisioningCapabilities();
+await uns.validate(document);
+await uns.plan(document);
+const created = await uns.submit(document, { idempotencyKey: stableRequestId });
+const result = await uns.waitJob(created.jobId);
+const operations = await uns.operations(created.jobId);
+```
+
+Always fetch schema and capabilities before generating a provisioning document.
+Use the fixed flow `validate -> plan -> submit -> wait -> operations`.
+Provisioning is asynchronous; only a terminal job status determines the result.
+
+```js
+const nodes = await uns.listNodes();
+const latest = await uns.nodeLatest(nodes[0].id);
+const history = await uns.nodeHistory(nodes[0].id, { limit: 100 });
+const realtime = await uns.realtimeConnection();
 ```
 
-Realtime subscription defaults to upstream WebSocket and supports explicitly
-selected MQTT. Point control defaults to HTTP and supports explicitly selected
-MQTT. Neither direction silently falls back. Resource writes use a reviewed
-`IndustrialChangeSet`; point and video writes require independent confirmation.
-The browser entry does not export industrial helpers or external credentials.
+The realtime URL contains a short-lived platform ticket, not a user token.
+Nodes, templates, and labels expose direct CRUD APIs. The SDK also exposes the
+node schemas, JSON definition inference, reverse modeling metadata, attachments,
+and the four documented IoT source queries:
 
-## OAuth2 Application Management
+```js
+const fileSchema = await uns.nodeSchema('file');
+const definition = await uns.inferDefinition({ temperature: 23.5 });
+const schemas = await uns.listReverseSchemas();
+const attachments = await uns.uploadAttachments(nodes[0].id, [
+  { name: 'manual.pdf', data: manualBytes, contentType: 'application/pdf' },
+]);
+const collectors = await uns.listCollectors('IOT_POINT_COLLECTOR');
+const points = await uns.listPoints('IOT_POINT_COLLECTOR', collectors.records[0].id);
+const current = await uns.sourceLatest(collectors.records[0].id, points.records[0].id);
+```
+
+The browser entry does not export UNS helpers.
+
+## Industrial IoT Source Queries
+
+The server-only `industrial` facade exposes the documented UNS IoT source
+queries.
+
+```js
+import { industrial } from '@kmlckj/licos-platform-sdk';
+
+const collectors = await industrial.collectors(industrial.IOT_POINT_COLLECTOR);
+const points = await industrial.points(
+  industrial.IOT_POINT_COLLECTOR,
+  collectors.records[0].id,
+);
+const current = await industrial.latest(collectors.records[0].id, points.records[0].id);
+```
+
+Create or update collectors and video resources through the UNS provisioning
+flow. The browser entry does not export industrial helpers.
+
+## OAuth2 Application Management
 
 OAuth2 management is available only from trusted Node runtime code. It uses the
 current project owner's platform identity and is not exported by the browser

package/dist/enterprise-knowledge.js

@@ -0,0 +1 @@
+import{createHash as e}from"node:crypto";import{createReadStream as t}from"node:fs";import{open as n,readFile as r,stat as o}from"node:fs/promises";import s from"node:path";import{ApiError as a}from"./shared.js";import{authHeaders as i,refreshRuntimeConfig as d,runtimeConfig as c,shouldRefreshUserToken as p}from"./runtime.js";export const DEFAULT_ENTERPRISE_KNOWLEDGE_CHUNK_SIZE=8388608;export const MIN_ENTERPRISE_KNOWLEDGE_CHUNK_SIZE=5242880;export const MAX_ENTERPRISE_KNOWLEDGE_CHUNK_SIZE=104857600;function l(e){return Object.fromEntries(Object.entries(e).filter(([,e])=>null!=e))}function u(e,t){const n=String(e??"").trim();if(!n)throw new TypeError(`${t} is required`);return n}function g(e){return Array.isArray(e)?e.join(","):e}function f(e,t,n={}){const r=new URL(`${e.baseUrl}/api/v1/knowledge/enterprise${t}`);for(const[e,t]of Object.entries(l(n)))Array.isArray(t)?t.forEach(t=>r.searchParams.append(e,String(t))):r.searchParams.set(e,String(t));return r}async function m(){return c({useCurrentUser:!0})}async function w(e){const t=await e.text();let n=null;if(t)try{n=JSON.parse(t)}catch{if(!e.ok)throw new a(t,{status:e.status});throw new a("enterprise knowledge API returned invalid JSON",{status:e.status,details:t})}if(!e.ok)throw new a(n?.message||t||`enterprise knowledge API returned ${e.status}`,{status:e.status,code:"number"==typeof n?.code?n.code:void 0,details:n});if(!n||"object"!=typeof n)return n;if(void 0!==n.code&&0!==n.code||!1===n.success)throw new a(n.message||"enterprise knowledge API failed",{status:e.status,code:"number"==typeof n.code?n.code:void 0,details:n});return n.data}async function y(e,t,{params:n,body:r}={}){let o=await m();for(let s=0;s<2;s+=1)try{const s=await fetch(f(o,t,n),{method:e,headers:i(o,void 0===r?void 0:"application/json"),body:void 0===r?void 0:JSON.stringify(l(r))});return await w(s)}catch(e){if(0===s&&p(e)){o=await d(o);continue}throw e}throw new a("enterprise knowledge API failed")}async function E(e,t){let n=await m();for(let r=0;r<2;r+=1)try{const r=await fetch(f(n,e),{method:"POST",headers:i(n),body:t()});return await w(r)}catch(e){if(0===r&&p(e)){n=await d(n);continue}throw e}throw new a("enterprise knowledge upload failed")}async function h(e,t){let n=await m();for(let r=0;r<2;r+=1){const o=f(n,e,t);try{const e=await fetch(o,{method:"GET",headers:i(n),redirect:"manual"});if([301,302,303,307,308].includes(e.status)){const t=e.headers.get("location");if(!t)throw new a("enterprise knowledge download response has no redirect URL",{status:e.status});return new URL(t,o).toString()}throw await w(e),new a("enterprise knowledge download response has no redirect URL",{status:e.status})}catch(e){if(0===r&&p(e)){n=await d(n);continue}throw e}}throw new a("enterprise knowledge download URL failed")}function _(e){return{".csv":"text/csv",".doc":"application/msword",".docx":"application/vnd.openxmlformats-officedocument.wordprocessingml.document",".json":"application/json",".md":"text/markdown",".pdf":"application/pdf",".ppt":"application/vnd.ms-powerpoint",".pptx":"application/vnd.openxmlformats-officedocument.presentationml.presentation",".txt":"text/plain",".xls":"application/vnd.ms-excel",".xlsx":"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"}[s.extname(e).toLowerCase()]||"application/octet-stream"}async function b(e,t={}){if("string"==typeof e){const n=await o(e);if(!n.isFile())throw new TypeError(`upload input is not a file: ${e}`);const r=t.fileName||t.file_name||s.basename(e);return{path:e,fileName:r,contentType:t.contentType||t.content_type||_(r),size:n.size}}let n;if(e instanceof Blob)n=Buffer.from(await e.arrayBuffer());else{if(!(Buffer.isBuffer(e)||e instanceof Uint8Array))throw new TypeError("upload input must be a file path, Blob, Buffer, or Uint8Array");n=Buffer.from(e)}const r=t.fileName||t.file_name||e.name||"upload.bin";return{data:n,fileName:r,contentType:t.contentType||t.content_type||e.type||_(r),size:n.length}}async function K(e){return e.data??r(e.path)}async function T(n){const r=e("sha256");return n.data?(r.update(n.data),r.digest("hex")):(await new Promise((e,o)=>{const s=t(n.path);s.on("data",e=>r.update(e)),s.on("error",o),s.on("end",e)}),r.digest("hex"))}function k(e,t){return new Blob([t],{type:e.contentType})}export async function enterpriseKnowledgeTree(e={}){return y("GET","/tree",{params:{include_types:g(e.includeTypes??e.include_types)}})}export async function searchEnterpriseKnowledgeBases(e,t={}){return y("GET","/search",{params:{q:u(e,"query"),include_types:g(t.includeTypes??t.include_types),page:t.page,page_size:t.pageSize??t.page_size}})}export async function validateEnterpriseKnowledgeReferences(e,t={}){if(!Array.isArray(e)||0===e.length)throw new TypeError("knowledgeBaseIds is required");return y("POST","/references/validate",{body:{knowledge_base_ids:e.map(String),required_capability:t.requiredCapability??t.required_capability??"retrieve"}})}export async function retrieveEnterpriseKnowledge(e,t){if(!Array.isArray(t)||0===t.length)throw new TypeError("sourceIds is required");return y("POST","/retrieve",{body:{query:u(e,"query"),source_ids:t.map(String)}})}export async function listEnterpriseKnowledgeFolders(e={}){return y("GET","/folders",{params:{parent_id:e.parentId??e.parent_id,include_children:e.includeChildren??e.include_children,q:e.query??e.q,page:e.page,page_size:e.pageSize??e.page_size}})}export async function getEnterpriseKnowledgeFolder(e){return y("GET",`/folders/${encodeURIComponent(u(e,"folderId"))}`)}export async function createEnterpriseKnowledgeFolder(e,t={}){return y("POST","/folders",{body:{parent_id:t.parentId??t.parent_id,name:u(e,"name"),description:t.description}})}export async function deleteEnterpriseKnowledgeFolder(e,t={}){return y("DELETE",`/folders/${encodeURIComponent(u(e,"folderId"))}`,{body:{reason:t.reason,hard_delete:t.hardDelete??t.hard_delete,confirm_name:t.confirmName??t.confirm_name}})}export async function listEnterpriseFolderKnowledgeBases(e,t={}){return y("GET",`/folders/${encodeURIComponent(u(e,"folderId"))}/knowledge-bases`,{params:{include_children:t.includeChildren??t.include_children,include_types:g(t.includeTypes??t.include_types),q:t.query??t.q,page:t.page,page_size:t.pageSize??t.page_size}})}export async function createEnterpriseKnowledgeBase(e,t={}){return y("POST","/knowledge-bases",{body:{folder_id:t.folderId??t.folder_id,name:u(e,"name"),description:t.description,knowledge_type:t.knowledgeType??t.knowledge_type??"STANDARD"}})}export async function getEnterpriseKnowledgeBase(e){return y("GET",`/knowledge-bases/${encodeURIComponent(u(e,"sourceId"))}`)}export async function deleteEnterpriseKnowledgeBase(e,t={}){return y("DELETE",`/knowledge-bases/${encodeURIComponent(u(e,"sourceId"))}`,{body:{reason:t.reason,hard_delete:t.hardDelete??t.hard_delete,confirm_name:t.confirmName??t.confirm_name}})}export async function listEnterpriseKnowledgeResourceAudits(e={}){return y("GET","/resource-audits",{params:{operation:e.operation,resource_kind:e.resourceKind??e.resource_kind,resource_id:e.resourceId??e.resource_id,knowledge_type:e.knowledgeType??e.knowledge_type,q:e.query??e.q,page:e.page,page_size:e.pageSize??e.page_size}})}export async function listEnterpriseKnowledgeDocuments(e,t={}){return y("GET","/documents",{params:{source_id:u(e,"sourceId"),page:t.page,page_size:t.pageSize??t.page_size,q:t.query??t.q,status:t.status,document_id:t.documentId??t.document_id}})}export async function getEnterpriseKnowledgeDocument(e){return y("GET",`/documents/${encodeURIComponent(u(e,"documentId"))}`)}export async function listEnterpriseKnowledgeDocumentChunks(e,t={}){return y("GET",`/documents/${encodeURIComponent(u(e,"documentId"))}/chunks`,{params:{page:t.page,page_size:t.pageSize??t.page_size,q:t.query??t.q}})}export async function getEnterpriseKnowledgeDocumentOriginalUrl(e,t={}){return h(`/documents/${encodeURIComponent(u(e,"documentId"))}/original`,{download:t.download??!1})}export async function batchDeleteEnterpriseKnowledgeDocuments(e,t,n={}){if(!Array.isArray(t)||0===t.length)throw new TypeError("documentIds is required");return y("POST","/documents/batch-delete",{body:{source_id:u(e,"sourceId"),document_ids:t.map(String),operator:n.operator,reason:n.reason}})}export async function uploadEnterpriseKnowledgeDocument(e,t,n={}){const r=await b(t,n),o=await K(r);return E("/documents/upload-async",()=>{const t=new FormData;return t.append("source_id",u(e,"sourceId")),t.append("file",k(r,o),r.fileName),t})}export async function initEnterpriseKnowledgeDocumentUpload(e,t){return y("POST","/documents/chunked-upload/init",{body:{source_id:u(e,"sourceId"),file_name:u(t.fileName??t.file_name,"fileName"),content_type:u(t.contentType??t.content_type,"contentType"),file_size:t.fileSize??t.file_size,chunk_size:t.chunkSize??t.chunk_size,fingerprint:u(t.fingerprint,"fingerprint")}})}export async function getEnterpriseKnowledgeDocumentUpload(e){return y("GET",`/documents/chunked-upload/${encodeURIComponent(u(e,"sessionId"))}`)}export async function uploadEnterpriseKnowledgeDocumentPart(e,t,n){const r=Buffer.from(n);return E(`/documents/chunked-upload/${encodeURIComponent(u(e,"sessionId"))}/parts`,()=>{const e=new FormData;return e.append("part_number",String(t)),e.append("chunk",new Blob([r],{type:"application/octet-stream"}),`part-${t}.bin`),e})}export async function completeEnterpriseKnowledgeDocumentUpload(e){return y("POST","/documents/chunked-upload/complete",{body:{session_id:u(e,"sessionId")}})}export async function uploadEnterpriseKnowledgeDocumentChunked(e,t,r={}){const o=await b(t,r),s=r.chunkSize??r.chunk_size??8388608;if(s<5242880||s>104857600)throw new RangeError("chunkSize must be between 5 MiB and 100 MiB");if(o.size<=0)throw new RangeError("upload file must not be empty");const i=await initEnterpriseKnowledgeDocumentUpload(e,{fileName:o.fileName,contentType:o.contentType,fileSize:o.size,chunkSize:s,fingerprint:r.fingerprint||await T(o)}),d=i?.session_id;if(!d)throw new a("enterprise knowledge upload init returned no session_id");const c=new Set((i.uploaded_part_numbers||[]).map(Number)),p=Number(i.total_chunks||Math.ceil(o.size/s)),l=o.path?await n(o.path,"r"):null;try{for(let e=1;e<=p;e+=1){if(c.has(e))continue;const t=(e-1)*s,n=Math.min(s,o.size-t);let r;if(l){r=Buffer.allocUnsafe(n);const{bytesRead:o}=await l.read(r,0,n,t);if(o!==n)throw new a(`failed to read upload part ${e}`)}else r=o.data.subarray(t,t+n);await uploadEnterpriseKnowledgeDocumentPart(d,e,r)}}finally{await(l?.close())}return completeEnterpriseKnowledgeDocumentUpload(d)}export async function getEnterpriseKnowledgeUploadTask(e){return y("GET",`/tasks/${encodeURIComponent(u(e,"taskId"))}`)}export async function listEnterpriseKnowledgeUploadTasks(e,t={}){return y("GET","/tasks",{params:{source_id:u(e,"sourceId"),page:t.page,page_size:t.pageSize??t.page_size,status:t.status,q:t.query??t.q}})}export async function getEnterpriseObjectStorageContract(){return y("GET","/object-storage/contract")}export async function queryEnterpriseKnowledgeObjects(e,t={}){return y("POST",`/object-storage/${encodeURIComponent(u(e,"sourceId"))}/objects/query`,{body:{prefix:t.prefix,q:t.query??t.q,page:t.page,page_size:t.pageSize??t.page_size}})}export async function uploadEnterpriseKnowledgeObjects(e,t,n={}){if(!Array.isArray(t)||0===t.length)throw new TypeError("inputs is required");const r=await Promise.all(t.map(e=>b(e))),o=await Promise.all(r.map(K)),s=n.objectKeys??n.object_keys??[];if(s.length>0&&s.length!==r.length)throw new TypeError("objectKeys must have the same item count as inputs");const a=n.metadataJson??n.metadata_json??n.metadata;return E(`/object-storage/${encodeURIComponent(u(e,"sourceId"))}/objects/upload-async`,()=>{const e=new FormData;return r.forEach((t,n)=>{e.append("files",k(t,o[n]),t.fileName)}),s.forEach(t=>e.append("objectKeys",String(t))),void 0!==n.prefix&&e.append("prefix",String(n.prefix)),void 0!==a&&e.append("metadataJson","string"==typeof a?a:JSON.stringify(a)),e})}export async function getEnterpriseKnowledgeObject(e,t){return y("POST",`/object-storage/${encodeURIComponent(u(e,"sourceId"))}/objects/detail`,{body:{objectKey:u(t,"objectKey")}})}export async function getEnterpriseKnowledgeObjectDownloadUrl(e,t,n={}){return h(`/object-storage/${encodeURIComponent(u(e,"sourceId"))}/objects/download`,{object_key:u(t,"objectKey"),inline:n.inline??!1})}export async function deleteEnterpriseKnowledgeObject(e,t){return y("POST",`/object-storage/${encodeURIComponent(u(e,"sourceId"))}/objects/delete`,{body:{objectKey:u(t,"objectKey")}})}export async function getEnterpriseKnowledgeObjectUploadTask(e){return y("GET",`/object-storage/tasks/${encodeURIComponent(u(e,"taskId"))}`)}export const enterpriseKnowledge={tree:enterpriseKnowledgeTree,searchKnowledgeBases:searchEnterpriseKnowledgeBases,validateReferences:validateEnterpriseKnowledgeReferences,retrieve:retrieveEnterpriseKnowledge,listFolders:listEnterpriseKnowledgeFolders,getFolder:getEnterpriseKnowledgeFolder,createFolder:createEnterpriseKnowledgeFolder,deleteFolder:deleteEnterpriseKnowledgeFolder,listFolderKnowledgeBases:listEnterpriseFolderKnowledgeBases,createKnowledgeBase:createEnterpriseKnowledgeBase,getKnowledgeBase:getEnterpriseKnowledgeBase,deleteKnowledgeBase:deleteEnterpriseKnowledgeBase,listResourceAudits:listEnterpriseKnowledgeResourceAudits,listDocuments:listEnterpriseKnowledgeDocuments,getDocument:getEnterpriseKnowledgeDocument,listDocumentChunks:listEnterpriseKnowledgeDocumentChunks,getDocumentOriginalUrl:getEnterpriseKnowledgeDocumentOriginalUrl,batchDeleteDocuments:batchDeleteEnterpriseKnowledgeDocuments,uploadDocument:uploadEnterpriseKnowledgeDocument,initDocumentUpload:initEnterpriseKnowledgeDocumentUpload,getDocumentUpload:getEnterpriseKnowledgeDocumentUpload,uploadDocumentPart:uploadEnterpriseKnowledgeDocumentPart,completeDocumentUpload:completeEnterpriseKnowledgeDocumentUpload,uploadDocumentChunked:uploadEnterpriseKnowledgeDocumentChunked,getUploadTask:getEnterpriseKnowledgeUploadTask,listUploadTasks:listEnterpriseKnowledgeUploadTasks,getObjectStorageContract:getEnterpriseObjectStorageContract,queryObjects:queryEnterpriseKnowledgeObjects,uploadObjects:uploadEnterpriseKnowledgeObjects,getObject:getEnterpriseKnowledgeObject,getObjectDownloadUrl:getEnterpriseKnowledgeObjectDownloadUrl,deleteObject:deleteEnterpriseKnowledgeObject,getObjectUploadTask:getEnterpriseKnowledgeObjectUploadTask};

package/dist/index.d.ts

@@ -20,16 +20,20 @@ export interface RuntimeConfig {
   ownerUserId?: string;
   ownerProjectType?: string;
   ownerApplicationType?: string;
-  runtimeEnv?: string;
-  currentUserId?: string;
-  currentUserOrgId?: string;
-}
+  runtimeEnv?: string;
+  currentUserId?: string;
+  currentUserOrgId?: string;
+}
 
-export function runtimeConfig(options?: { environmentOverrideEnv?: string }): Promise<RuntimeConfig>;
+export function runtimeConfig(options?: {
+  environmentOverrideEnv?: string;
+  requireProject?: boolean;
+  useCurrentUser?: boolean;
+}): Promise<RuntimeConfig>;
 export function authHeaders(config: RuntimeConfig, contentType?: string): Record<string, string>;
 
-export * from './uns.js';
-export * from './industrial.js';
+export * from './uns.js';
+export * from './industrial.js';
 
 export type OAuthLoginAudience = 'ALL' | 'OWNER_TENANT';
 
@@ -382,7 +386,7 @@ export function listDocuments(datasetId: string, options?: { page?: number; size
 export function deleteDocuments(datasetId: string, documentIds: string[]): Promise<void>;
 export function search(query: string, options?: SearchKnowledgeOptions): Promise<KnowledgeSearchResult>;
 
-export const knowledge: {
+export const knowledge: {
   DataSourceType: typeof DataSourceType;
   ChunkConfig: typeof ChunkConfig;
   KnowledgeDocument: typeof KnowledgeDocument;
@@ -399,10 +403,312 @@ export const knowledge: {
   addUrl: typeof addUrl;
   listDocuments: typeof listDocuments;
   deleteDocuments: typeof deleteDocuments;
-  search: typeof search;
-};
-
-export interface DatabaseFilter {
+  search: typeof search;
+};
+
+export type EnterpriseKnowledgeType = 'STANDARD' | 'GRAPH' | 'OBJECT_STORAGE';
+export type EnterpriseKnowledgeCapability = 'retrieve' | 'upload' | 'list_files' | 'batch_delete_files';
+export type EnterpriseKnowledgeFileInput = string | Blob | Buffer | Uint8Array;
+
+export interface EnterpriseKnowledgePageOptions {
+  page?: number;
+  pageSize?: number;
+  page_size?: number;
+}
+
+export interface EnterpriseKnowledgeFilterOptions extends EnterpriseKnowledgePageOptions {
+  query?: string;
+  q?: string;
+}
+
+export interface EnterpriseKnowledgeTypesOptions {
+  includeTypes?: EnterpriseKnowledgeType[] | string;
+  include_types?: EnterpriseKnowledgeType[] | string;
+}
+
+export interface EnterpriseKnowledgeDeleteOptions {
+  reason?: string;
+  hardDelete?: boolean;
+  hard_delete?: boolean;
+  confirmName?: string;
+  confirm_name?: string;
+}
+
+export interface EnterpriseKnowledgeUploadOptions {
+  fileName?: string;
+  file_name?: string;
+  contentType?: string;
+  content_type?: string;
+}
+
+export interface EnterpriseKnowledgeChunkedUploadOptions extends EnterpriseKnowledgeUploadOptions {
+  chunkSize?: number;
+  chunk_size?: number;
+  fingerprint?: string;
+}
+
+export interface EnterpriseKnowledgeTreeNode {
+  id?: string;
+  parent_id?: string;
+  node_type?: string;
+  name?: string;
+  protected?: boolean;
+  deletable?: boolean;
+  knowledge_base_id?: string;
+  knowledge_type?: EnterpriseKnowledgeType | string;
+  capabilities?: {
+    retrieve?: boolean;
+    upload?: boolean;
+    list_files?: boolean;
+    batch_delete_files?: boolean;
+  };
+  children?: EnterpriseKnowledgeTreeNode[];
+  [key: string]: unknown;
+}
+
+export interface EnterpriseKnowledgeTreeResponse {
+  status?: string;
+  data?: {
+    tenant_id?: string;
+    permission_scope?: string;
+    nodes?: EnterpriseKnowledgeTreeNode[];
+  };
+  [key: string]: unknown;
+}
+
+export interface EnterpriseKnowledgeReferenceValidation {
+  valid?: boolean;
+  required_capability?: EnterpriseKnowledgeCapability | string;
+  items?: Array<{
+    knowledge_base_id?: string;
+    name?: string;
+    knowledge_type?: EnterpriseKnowledgeType | string;
+    valid?: boolean;
+    code?: string;
+    message?: string;
+    [key: string]: unknown;
+  }>;
+  [key: string]: unknown;
+}
+
+export interface EnterpriseKnowledgeUploadSession {
+  session_id?: string;
+  source_id?: string;
+  file_name?: string;
+  content_type?: string;
+  file_size?: number;
+  chunk_size?: number;
+  total_chunks?: number;
+  uploaded_chunks?: number;
+  uploaded_part_numbers?: number[];
+  fingerprint?: string;
+  status?: string;
+  expires_at?: string;
+  [key: string]: unknown;
+}
+
+export function enterpriseKnowledgeTree(
+  options?: EnterpriseKnowledgeTypesOptions,
+): Promise<EnterpriseKnowledgeTreeResponse>;
+export function searchEnterpriseKnowledgeBases(
+  query: string,
+  options?: EnterpriseKnowledgeTypesOptions & EnterpriseKnowledgePageOptions,
+): Promise<Record<string, unknown>>;
+export function validateEnterpriseKnowledgeReferences(
+  knowledgeBaseIds: string[],
+  options?: {
+    requiredCapability?: EnterpriseKnowledgeCapability;
+    required_capability?: EnterpriseKnowledgeCapability;
+  },
+): Promise<EnterpriseKnowledgeReferenceValidation>;
+export function retrieveEnterpriseKnowledge(
+  query: string,
+  sourceIds: string[],
+): Promise<Record<string, unknown>>;
+export function listEnterpriseKnowledgeFolders(
+  options?: EnterpriseKnowledgeFilterOptions & {
+    parentId?: string;
+    parent_id?: string;
+    includeChildren?: boolean;
+    include_children?: boolean;
+  },
+): Promise<Record<string, unknown>>;
+export function getEnterpriseKnowledgeFolder(folderId: string): Promise<Record<string, unknown>>;
+export function createEnterpriseKnowledgeFolder(
+  name: string,
+  options?: { parentId?: string; parent_id?: string; description?: string },
+): Promise<Record<string, unknown>>;
+export function deleteEnterpriseKnowledgeFolder(
+  folderId: string,
+  options?: EnterpriseKnowledgeDeleteOptions,
+): Promise<Record<string, unknown>>;
+export function listEnterpriseFolderKnowledgeBases(
+  folderId: string,
+  options?: EnterpriseKnowledgeFilterOptions &
+    EnterpriseKnowledgeTypesOptions & {
+      includeChildren?: boolean;
+      include_children?: boolean;
+    },
+): Promise<Record<string, unknown>>;
+export function createEnterpriseKnowledgeBase(
+  name: string,
+  options?: {
+    folderId?: string;
+    folder_id?: string;
+    description?: string;
+    knowledgeType?: EnterpriseKnowledgeType;
+    knowledge_type?: EnterpriseKnowledgeType;
+  },
+): Promise<Record<string, unknown>>;
+export function getEnterpriseKnowledgeBase(sourceId: string): Promise<Record<string, unknown>>;
+export function deleteEnterpriseKnowledgeBase(
+  sourceId: string,
+  options?: EnterpriseKnowledgeDeleteOptions,
+): Promise<Record<string, unknown>>;
+export function listEnterpriseKnowledgeResourceAudits(
+  options?: EnterpriseKnowledgeFilterOptions & {
+    operation?: string;
+    resourceKind?: 'FOLDER' | 'KNOWLEDGE_BASE' | 'OBJECT_STORAGE' | string;
+    resource_kind?: 'FOLDER' | 'KNOWLEDGE_BASE' | 'OBJECT_STORAGE' | string;
+    resourceId?: string;
+    resource_id?: string;
+    knowledgeType?: EnterpriseKnowledgeType;
+    knowledge_type?: EnterpriseKnowledgeType;
+  },
+): Promise<Record<string, unknown>>;
+export function listEnterpriseKnowledgeDocuments(
+  sourceId: string,
+  options?: EnterpriseKnowledgeFilterOptions & {
+    status?: string;
+    documentId?: string;
+    document_id?: string;
+  },
+): Promise<Record<string, unknown>>;
+export function getEnterpriseKnowledgeDocument(documentId: string): Promise<Record<string, unknown>>;
+export function listEnterpriseKnowledgeDocumentChunks(
+  documentId: string,
+  options?: EnterpriseKnowledgeFilterOptions,
+): Promise<Record<string, unknown>>;
+export function getEnterpriseKnowledgeDocumentOriginalUrl(
+  documentId: string,
+  options?: { download?: boolean },
+): Promise<string>;
+export function batchDeleteEnterpriseKnowledgeDocuments(
+  sourceId: string,
+  documentIds: string[],
+  options?: { operator?: string; reason?: string },
+): Promise<Record<string, unknown>>;
+export function uploadEnterpriseKnowledgeDocument(
+  sourceId: string,
+  input: EnterpriseKnowledgeFileInput,
+  options?: EnterpriseKnowledgeUploadOptions,
+): Promise<Record<string, unknown>>;
+export function initEnterpriseKnowledgeDocumentUpload(
+  sourceId: string,
+  options: {
+    fileName?: string;
+    file_name?: string;
+    contentType?: string;
+    content_type?: string;
+    fileSize?: number;
+    file_size?: number;
+    chunkSize?: number;
+    chunk_size?: number;
+    fingerprint: string;
+  },
+): Promise<EnterpriseKnowledgeUploadSession>;
+export function getEnterpriseKnowledgeDocumentUpload(
+  sessionId: string,
+): Promise<EnterpriseKnowledgeUploadSession>;
+export function uploadEnterpriseKnowledgeDocumentPart(
+  sessionId: string,
+  partNumber: number,
+  chunk: Buffer | Uint8Array,
+): Promise<Record<string, unknown>>;
+export function completeEnterpriseKnowledgeDocumentUpload(
+  sessionId: string,
+): Promise<Record<string, unknown>>;
+export function uploadEnterpriseKnowledgeDocumentChunked(
+  sourceId: string,
+  input: EnterpriseKnowledgeFileInput,
+  options?: EnterpriseKnowledgeChunkedUploadOptions,
+): Promise<Record<string, unknown>>;
+export function getEnterpriseKnowledgeUploadTask(taskId: string): Promise<Record<string, unknown>>;
+export function listEnterpriseKnowledgeUploadTasks(
+  sourceId: string,
+  options?: EnterpriseKnowledgeFilterOptions & { status?: string },
+): Promise<Record<string, unknown>>;
+export function getEnterpriseObjectStorageContract(): Promise<Record<string, unknown>>;
+export function queryEnterpriseKnowledgeObjects(
+  sourceId: string,
+  options?: EnterpriseKnowledgeFilterOptions & { prefix?: string },
+): Promise<Record<string, unknown>>;
+export function uploadEnterpriseKnowledgeObjects(
+  sourceId: string,
+  inputs: EnterpriseKnowledgeFileInput[],
+  options?: {
+    objectKeys?: string[];
+    object_keys?: string[];
+    prefix?: string;
+    metadata?: Record<string, unknown> | string;
+    metadataJson?: Record<string, unknown> | string;
+    metadata_json?: Record<string, unknown> | string;
+  },
+): Promise<Record<string, unknown>>;
+export function getEnterpriseKnowledgeObject(
+  sourceId: string,
+  objectKey: string,
+): Promise<Record<string, unknown>>;
+export function getEnterpriseKnowledgeObjectDownloadUrl(
+  sourceId: string,
+  objectKey: string,
+  options?: { inline?: boolean },
+): Promise<string>;
+export function deleteEnterpriseKnowledgeObject(
+  sourceId: string,
+  objectKey: string,
+): Promise<Record<string, unknown>>;
+export function getEnterpriseKnowledgeObjectUploadTask(
+  taskId: string,
+): Promise<Record<string, unknown>>;
+
+export const enterpriseKnowledge: {
+  tree: typeof enterpriseKnowledgeTree;
+  searchKnowledgeBases: typeof searchEnterpriseKnowledgeBases;
+  validateReferences: typeof validateEnterpriseKnowledgeReferences;
+  retrieve: typeof retrieveEnterpriseKnowledge;
+  listFolders: typeof listEnterpriseKnowledgeFolders;
+  getFolder: typeof getEnterpriseKnowledgeFolder;
+  createFolder: typeof createEnterpriseKnowledgeFolder;
+  deleteFolder: typeof deleteEnterpriseKnowledgeFolder;
+  listFolderKnowledgeBases: typeof listEnterpriseFolderKnowledgeBases;
+  createKnowledgeBase: typeof createEnterpriseKnowledgeBase;
+  getKnowledgeBase: typeof getEnterpriseKnowledgeBase;
+  deleteKnowledgeBase: typeof deleteEnterpriseKnowledgeBase;
+  listResourceAudits: typeof listEnterpriseKnowledgeResourceAudits;
+  listDocuments: typeof listEnterpriseKnowledgeDocuments;
+  getDocument: typeof getEnterpriseKnowledgeDocument;
+  listDocumentChunks: typeof listEnterpriseKnowledgeDocumentChunks;
+  getDocumentOriginalUrl: typeof getEnterpriseKnowledgeDocumentOriginalUrl;
+  batchDeleteDocuments: typeof batchDeleteEnterpriseKnowledgeDocuments;
+  uploadDocument: typeof uploadEnterpriseKnowledgeDocument;
+  initDocumentUpload: typeof initEnterpriseKnowledgeDocumentUpload;
+  getDocumentUpload: typeof getEnterpriseKnowledgeDocumentUpload;
+  uploadDocumentPart: typeof uploadEnterpriseKnowledgeDocumentPart;
+  completeDocumentUpload: typeof completeEnterpriseKnowledgeDocumentUpload;
+  uploadDocumentChunked: typeof uploadEnterpriseKnowledgeDocumentChunked;
+  getUploadTask: typeof getEnterpriseKnowledgeUploadTask;
+  listUploadTasks: typeof listEnterpriseKnowledgeUploadTasks;
+  getObjectStorageContract: typeof getEnterpriseObjectStorageContract;
+  queryObjects: typeof queryEnterpriseKnowledgeObjects;
+  uploadObjects: typeof uploadEnterpriseKnowledgeObjects;
+  getObject: typeof getEnterpriseKnowledgeObject;
+  getObjectDownloadUrl: typeof getEnterpriseKnowledgeObjectDownloadUrl;
+  deleteObject: typeof deleteEnterpriseKnowledgeObject;
+  getObjectUploadTask: typeof getEnterpriseKnowledgeObjectUploadTask;
+};
+
+export interface DatabaseFilter {
   field: string;
   op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'not_in' | 'is_null' | 'is_not_null' | 'like' | 'ilike' | string;
   value?: unknown;

package/dist/index.js

@@ -1 +1 @@
-export{PlatformSdkError,ConfigurationError,ApiError}from"./shared.js";export{runtimeConfig,authHeaders}from"./runtime.js";export*from"./database.js";export*from"./knowledge.js";export*from"./industrial.js";export*from"./oauth.js";export*from"./oauth-runtime.js";export*from"./storage.js";export*from"./uns.js";export{studioDatabase}from"./studio-database.js";
+export{PlatformSdkError,ConfigurationError,ApiError}from"./shared.js";export{runtimeConfig,authHeaders}from"./runtime.js";export*from"./database.js";export*from"./enterprise-knowledge.js";export*from"./knowledge.js";export*from"./industrial.js";export*from"./oauth.js";export*from"./oauth-runtime.js";export*from"./storage.js";export*from"./uns.js";export{studioDatabase}from"./studio-database.js";