@amaster.ai/client 1.1.50 → 1.1.52-beta.0

package/types/__tests__/type-checks.test-d.ts

@@ -190,6 +190,17 @@ describe('Type Tests', () => {
   });
 
   describe('BPM Types', () => {
+    it('should accept businessKey when starting a process', () => {
+      type StartProcessInputs = Parameters<AmasterClient['bpm']['startProcess']>[1];
+
+      expectTypeOf<{
+        businessKey: string;
+        variables: {
+          expense_id: { value: string; type: 'String' };
+        };
+      }>().toMatchTypeOf<StartProcessInputs>();
+    });
+
     it('should have correct Task structure', () => {
       expectTypeOf<Task>().toMatchTypeOf<{
         id: string;
@@ -206,5 +217,31 @@ describe('Type Tests', () => {
         businessKey?: string;
       }>();
     });
+
+    it('should allow BPM variable submissions with business keys', () => {
+      expectTypeOf<Parameters<AmasterClient['bpm']['startProcess']>[1]>().toMatchTypeOf<{
+        businessKey?: string;
+        variables: {
+          recordId: {
+            value: string;
+            type: 'String';
+          };
+        };
+      }>();
+    });
+
+    it('should not expose business keys on BPM task completion submissions', () => {
+      expectTypeOf<Parameters<AmasterClient['bpm']['completeTask']>[1]>().toMatchTypeOf<{
+        variables: {
+          approved: {
+            value: boolean;
+            type: 'Boolean';
+          };
+        };
+      }>();
+      expectTypeOf<Parameters<AmasterClient['bpm']['completeTask']>[1]>().not.toMatchTypeOf<{
+        businessKey?: string;
+      }>();
+    });
   });
 });

package/types/bpm.d.ts

@@ -79,6 +79,14 @@ export interface VariableSubmission {
   variables: Record<string, CamundaVariable>;
 }
 
+/**
+ * Process start payload. `businessKey` is only valid when starting a process,
+ * not when completing a task.
+ */
+export interface ProcessStartSubmission extends VariableSubmission {
+  businessKey?: string;
+}
+
 // ==================== Process Types ====================
 
 /**
@@ -392,7 +400,7 @@ export interface BpmClientAPI {
    */
   startProcess(
     processKey: string,
-    inputs?: Record<string, CamundaVariableValue> | VariableSubmission
+    inputs?: Record<string, CamundaVariableValue> | ProcessStartSubmission
   ): Promise<ClientResult<ProcessInstance>>;
 
   /**

package/types/index.d.ts

@@ -30,6 +30,7 @@
  * - **Entity Operations**: {@link ./entity.d.ts}
  * - **BPM (Business Process)**: {@link ./bpm.d.ts}
  * - **Workflow Execution**: {@link ./workflow.d.ts}
+ * - **Knowledge Base**: {@link ./knowledge.d.ts}
  *
  * ## AI-Friendly Type Structure
  * This package provides modular type definitions optimized for AI tools and large language models.
@@ -48,6 +49,7 @@ import type { AuthClientAPI } from "./auth/index";
 import type { EntityClientAPI } from "./entity";
 import type { BpmClientAPI } from "./bpm";
 import type { WorkflowClientAPI } from "./workflow";
+import type { KnowledgeClientAPI } from "./knowledge";
 import type { ASRClientConfig, ASRClient, ASRHttpClientConfig, ASRHttpClient } from "./asr";
 import type { CopilotClientAPI } from "./copilot";
 import type { FunctionClientAPI } from "./function";
@@ -206,6 +208,16 @@ export interface AmasterClient {
    */
   workflow: WorkflowClientAPI;
 
+  /**
+   * Knowledge base document management module
+   *
+   * Provides methods for resolving the current organization knowledge base,
+   * listing documents, uploading documents, polling indexing status, and deleting documents.
+   *
+   * For detailed documentation, see {@link ./knowledge.d.ts}
+   */
+  knowledge: KnowledgeClientAPI;
+
   /**
    * ASR (Automatic Speech Recognition) module
    *
@@ -414,6 +426,30 @@ export type {
   WorkflowInputValue,
   WorkflowFile,
 } from "./workflow";
+export type {
+  KnowledgeClientAPI,
+  KnowledgeClientAPI as KnowledgeClient,
+  KnowledgeDatasetIdResponse,
+  KnowledgeDeleteDocumentOptions,
+  KnowledgeDocument,
+  KnowledgeDocumentListResponse,
+  KnowledgeDocumentListStatus,
+  KnowledgeDocumentStatus,
+  KnowledgeGetDatasetIdOptions,
+  KnowledgeIndexingStatus,
+  KnowledgeIndexingStatusOptions,
+  KnowledgeIndexingStatusResponse,
+  KnowledgeListDocumentsOptions,
+  KnowledgeMetadataField,
+  KnowledgeMetadataOperation,
+  KnowledgeMetadataUpdateRequest,
+  KnowledgeResolveOptions,
+  KnowledgeRoles,
+  KnowledgeUpdateDocumentsMetadataOptions,
+  KnowledgeUploadDocumentOptions,
+  KnowledgeUploadResponse,
+  KnowledgeWaitForIndexingOptions,
+} from "./knowledge";
 export type {
   ASRClient,
   ASRClientConfig,

package/types/knowledge.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Knowledge base document management types.
+ *
+ * @module knowledge
+ */
+
+import type { ClientResult } from "./common";
+
+export type KnowledgeDocumentStatus = "completed" | "indexing" | "error" | "paused";
+export type KnowledgeDocumentListStatus = KnowledgeDocumentStatus | "all";
+export type KnowledgeRoles = string | string[];
+
+export interface KnowledgeDatasetIdResponse {
+  dataset_id: string;
+}
+
+export interface KnowledgeDocument {
+  id: string;
+  name: string;
+  data_source_type?: string;
+  doc_type?: string | null;
+  doc_form?: string | null;
+  indexing_status?: string;
+  display_status?: string;
+  enabled?: boolean;
+  archived?: boolean;
+  word_count?: number;
+  hit_count?: number;
+  position?: number;
+  created_at?: number;
+  updated_at?: number;
+  completed_segments?: number;
+  total_segments?: number;
+  [key: string]: unknown;
+}
+
+export interface KnowledgeDocumentListResponse {
+  data: KnowledgeDocument[];
+  total: number;
+  page: number;
+  limit: number;
+  has_more: boolean;
+}
+
+export interface KnowledgeIndexingStatus {
+  id: string;
+  name?: string;
+  indexing_status?: string;
+  processing_started_at?: number | null;
+  parsing_completed_at?: number | null;
+  cleaning_completed_at?: number | null;
+  splitting_completed_at?: number | null;
+  completed_at?: number | null;
+  paused_at?: number | null;
+  stopped_at?: number | null;
+  completed_segments?: number;
+  total_segments?: number;
+  error?: string | null;
+  [key: string]: unknown;
+}
+
+export interface KnowledgeIndexingStatusResponse {
+  data: KnowledgeIndexingStatus[];
+}
+
+export interface KnowledgeUploadResponse {
+  document: KnowledgeDocument;
+  batch: string;
+}
+
+export interface KnowledgeMetadataField {
+  id: string;
+  name: string;
+  type?: "string" | "number" | "time" | string;
+  value: unknown;
+}
+
+export interface KnowledgeMetadataOperation {
+  document_id: string;
+  metadata_list: KnowledgeMetadataField[];
+  partial_update?: boolean;
+}
+
+export interface KnowledgeMetadataUpdateRequest {
+  operation_data: KnowledgeMetadataOperation[];
+}
+
+export type KnowledgeResolveOptions =
+  | {
+      datasetId: string;
+      orgCode?: string;
+      refresh?: boolean;
+    }
+  | {
+      datasetId?: string;
+      orgCode: string;
+      refresh?: boolean;
+    };
+
+export interface KnowledgeGetDatasetIdOptions {
+  orgCode: string;
+  refresh?: boolean;
+}
+
+export type KnowledgeListDocumentsOptions = KnowledgeResolveOptions & {
+  page?: number;
+  limit?: number;
+  keyword?: string;
+  status?: KnowledgeDocumentListStatus;
+  sort?: string;
+  fetch?: boolean | string;
+  appCode?: string;
+  roles?: KnowledgeRoles;
+};
+
+export type KnowledgeUploadDocumentOptions = KnowledgeResolveOptions & {
+  file: File | Blob;
+  fileName?: string;
+  appCode?: string;
+  config?: Record<string, unknown>;
+};
+
+export type KnowledgeIndexingStatusOptions = KnowledgeResolveOptions & {
+  batch: string;
+};
+
+export type KnowledgeWaitForIndexingOptions = KnowledgeIndexingStatusOptions & {
+  intervalMs?: number;
+  timeoutMs?: number;
+};
+
+export type KnowledgeDeleteDocumentOptions = KnowledgeResolveOptions & {
+  documentId: string;
+  appCode?: string;
+};
+
+export type KnowledgeUpdateDocumentsMetadataOptions = KnowledgeResolveOptions &
+  KnowledgeMetadataUpdateRequest;
+
+export interface KnowledgeClientAPI {
+  getDatasetId(
+    options: KnowledgeGetDatasetIdOptions
+  ): Promise<ClientResult<KnowledgeDatasetIdResponse>>;
+  listDocuments(
+    options: KnowledgeListDocumentsOptions
+  ): Promise<ClientResult<KnowledgeDocumentListResponse>>;
+  uploadDocument(
+    options: KnowledgeUploadDocumentOptions
+  ): Promise<ClientResult<KnowledgeUploadResponse>>;
+  getIndexingStatus(
+    options: KnowledgeIndexingStatusOptions
+  ): Promise<ClientResult<KnowledgeIndexingStatusResponse>>;
+  waitForIndexing(
+    options: KnowledgeWaitForIndexingOptions
+  ): Promise<ClientResult<KnowledgeIndexingStatusResponse>>;
+  deleteDocument(options: KnowledgeDeleteDocumentOptions): Promise<ClientResult<null>>;
+  updateDocumentsMetadata(
+    options: KnowledgeUpdateDocumentsMetadataOptions
+  ): Promise<ClientResult<{ result: string }>>;
+}