@alicloud/cms20240330 9.0.1 → 9.2.0

package/src/client.ts

@@ -29,6 +29,59 @@ export default class Client extends OpenApi {
     return OpenApiUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
   }
 
+  /**
+   * 写入上下文
+   * 
+   * @param request - AddContextsRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns AddContextsResponse
+   */
+  async addContextsWithOptions(workspace: string, contextStoreName: string, request: $_model.AddContextsRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.AddContextsResponse> {
+    request.validate();
+    let body : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.contextType)) {
+      body["contextType"] = request.contextType;
+    }
+
+    if (!$dara.isNull(request.items)) {
+      body["items"] = request.items;
+    }
+
+    if (!$dara.isNull(request.memoryType)) {
+      body["memoryType"] = request.memoryType;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      body: OpenApiUtil.parseToMap(body),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "AddContexts",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}/context`,
+      method: "POST",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.AddContextsResponse>(await this.callApi(params, req, runtime), new $_model.AddContextsResponse({}));
+  }
+
+  /**
+   * 写入上下文
+   * 
+   * @param request - AddContextsRequest
+   * @returns AddContextsResponse
+   */
+  async addContexts(workspace: string, contextStoreName: string, request: $_model.AddContextsRequest): Promise<$_model.AddContextsResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.addContextsWithOptions(workspace, contextStoreName, request, headers, runtime);
+  }
+
   /**
    * 添加记忆
    * 
@@ -530,6 +583,112 @@ export default class Client extends OpenApi {
     return await this.createCloudResourceWithOptions(headers, runtime);
   }
 
+  /**
+   * 创建上下文库
+   * 
+   * @param request - CreateContextStoreRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns CreateContextStoreResponse
+   */
+  async createContextStoreWithOptions(workspace: string, request: $_model.CreateContextStoreRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.CreateContextStoreResponse> {
+    request.validate();
+    let body : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.config)) {
+      body["config"] = request.config;
+    }
+
+    if (!$dara.isNull(request.contextStoreName)) {
+      body["contextStoreName"] = request.contextStoreName;
+    }
+
+    if (!$dara.isNull(request.contextType)) {
+      body["contextType"] = request.contextType;
+    }
+
+    if (!$dara.isNull(request.dataset)) {
+      body["dataset"] = request.dataset;
+    }
+
+    if (!$dara.isNull(request.description)) {
+      body["description"] = request.description;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      body: OpenApiUtil.parseToMap(body),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "CreateContextStore",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore`,
+      method: "POST",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.CreateContextStoreResponse>(await this.callApi(params, req, runtime), new $_model.CreateContextStoreResponse({}));
+  }
+
+  /**
+   * 创建上下文库
+   * 
+   * @param request - CreateContextStoreRequest
+   * @returns CreateContextStoreResponse
+   */
+  async createContextStore(workspace: string, request: $_model.CreateContextStoreRequest): Promise<$_model.CreateContextStoreResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.createContextStoreWithOptions(workspace, request, headers, runtime);
+  }
+
+  /**
+   * 创建 API Key
+   * 
+   * @param request - CreateContextStoreAPIKeyRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns CreateContextStoreAPIKeyResponse
+   */
+  async createContextStoreAPIKeyWithOptions(workspace: string, contextStoreName: string, request: $_model.CreateContextStoreAPIKeyRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.CreateContextStoreAPIKeyResponse> {
+    request.validate();
+    let body : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.name)) {
+      body["name"] = request.name;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      body: OpenApiUtil.parseToMap(body),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "CreateContextStoreAPIKey",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}/apikey`,
+      method: "POST",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.CreateContextStoreAPIKeyResponse>(await this.callApi(params, req, runtime), new $_model.CreateContextStoreAPIKeyResponse({}));
+  }
+
+  /**
+   * 创建 API Key
+   * 
+   * @param request - CreateContextStoreAPIKeyRequest
+   * @returns CreateContextStoreAPIKeyResponse
+   */
+  async createContextStoreAPIKey(workspace: string, contextStoreName: string, request: $_model.CreateContextStoreAPIKeyRequest): Promise<$_model.CreateContextStoreAPIKeyResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.createContextStoreAPIKeyWithOptions(workspace, contextStoreName, request, headers, runtime);
+  }
+
   /**
    * 创建数据集
    * 
@@ -839,6 +998,71 @@ export default class Client extends OpenApi {
     return await this.createMemoryStoreWithOptions(workspace, request, headers, runtime);
   }
 
+  /**
+   * 创建流水线
+   * 
+   * @param request - CreatePipelineRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns CreatePipelineResponse
+   */
+  async createPipelineWithOptions(workspace: string, request: $_model.CreatePipelineRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.CreatePipelineResponse> {
+    request.validate();
+    let body : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.description)) {
+      body["description"] = request.description;
+    }
+
+    if (!$dara.isNull(request.executePolicy)) {
+      body["executePolicy"] = request.executePolicy;
+    }
+
+    if (!$dara.isNull(request.pipeline)) {
+      body["pipeline"] = request.pipeline;
+    }
+
+    if (!$dara.isNull(request.pipelineName)) {
+      body["pipelineName"] = request.pipelineName;
+    }
+
+    if (!$dara.isNull(request.sink)) {
+      body["sink"] = request.sink;
+    }
+
+    if (!$dara.isNull(request.source)) {
+      body["source"] = request.source;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      body: OpenApiUtil.parseToMap(body),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "CreatePipeline",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/pipeline`,
+      method: "POST",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.CreatePipelineResponse>(await this.callApi(params, req, runtime), new $_model.CreatePipelineResponse({}));
+  }
+
+  /**
+   * 创建流水线
+   * 
+   * @param request - CreatePipelineRequest
+   * @returns CreatePipelineResponse
+   */
+  async createPipeline(workspace: string, request: $_model.CreatePipelineRequest): Promise<$_model.CreatePipelineResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.createPipelineWithOptions(workspace, request, headers, runtime);
+  }
+
   /**
    * Create a Prometheus monitoring instance
    * 
@@ -1503,6 +1727,172 @@ export default class Client extends OpenApi {
     return await this.deleteCloudResourceWithOptions(headers, runtime);
   }
 
+  /**
+   * 删除上下文
+   * 
+   * @param request - DeleteContextRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns DeleteContextResponse
+   */
+  async deleteContextWithOptions(workspace: string, contextStoreName: string, contextId: string, request: $_model.DeleteContextRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.DeleteContextResponse> {
+    request.validate();
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "DeleteContext",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}/context/${$dara.URL.percentEncode(contextId)}`,
+      method: "DELETE",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.DeleteContextResponse>(await this.callApi(params, req, runtime), new $_model.DeleteContextResponse({}));
+  }
+
+  /**
+   * 删除上下文
+   * 
+   * @param request - DeleteContextRequest
+   * @returns DeleteContextResponse
+   */
+  async deleteContext(workspace: string, contextStoreName: string, contextId: string, request: $_model.DeleteContextRequest): Promise<$_model.DeleteContextResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.deleteContextWithOptions(workspace, contextStoreName, contextId, request, headers, runtime);
+  }
+
+  /**
+   * 删除上下文库
+   * 
+   * @param request - DeleteContextStoreRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns DeleteContextStoreResponse
+   */
+  async deleteContextStoreWithOptions(workspace: string, contextStoreName: string, request: $_model.DeleteContextStoreRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.DeleteContextStoreResponse> {
+    request.validate();
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "DeleteContextStore",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}`,
+      method: "DELETE",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.DeleteContextStoreResponse>(await this.callApi(params, req, runtime), new $_model.DeleteContextStoreResponse({}));
+  }
+
+  /**
+   * 删除上下文库
+   * 
+   * @param request - DeleteContextStoreRequest
+   * @returns DeleteContextStoreResponse
+   */
+  async deleteContextStore(workspace: string, contextStoreName: string, request: $_model.DeleteContextStoreRequest): Promise<$_model.DeleteContextStoreResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.deleteContextStoreWithOptions(workspace, contextStoreName, request, headers, runtime);
+  }
+
+  /**
+   * 删除 API Key
+   * 
+   * @param request - DeleteContextStoreAPIKeyRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns DeleteContextStoreAPIKeyResponse
+   */
+  async deleteContextStoreAPIKeyWithOptions(workspace: string, contextStoreName: string, name: string, request: $_model.DeleteContextStoreAPIKeyRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.DeleteContextStoreAPIKeyResponse> {
+    request.validate();
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "DeleteContextStoreAPIKey",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}/apikey/${$dara.URL.percentEncode(name)}`,
+      method: "DELETE",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.DeleteContextStoreAPIKeyResponse>(await this.callApi(params, req, runtime), new $_model.DeleteContextStoreAPIKeyResponse({}));
+  }
+
+  /**
+   * 删除 API Key
+   * 
+   * @param request - DeleteContextStoreAPIKeyRequest
+   * @returns DeleteContextStoreAPIKeyResponse
+   */
+  async deleteContextStoreAPIKey(workspace: string, contextStoreName: string, name: string, request: $_model.DeleteContextStoreAPIKeyRequest): Promise<$_model.DeleteContextStoreAPIKeyResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.deleteContextStoreAPIKeyWithOptions(workspace, contextStoreName, name, request, headers, runtime);
+  }
+
+  /**
+   * 批量删除上下文
+   * 
+   * @param request - DeleteContextsRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns DeleteContextsResponse
+   */
+  async deleteContextsWithOptions(workspace: string, contextStoreName: string, request: $_model.DeleteContextsRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.DeleteContextsResponse> {
+    request.validate();
+    let query : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.contextIds)) {
+      query["contextIds"] = request.contextIds;
+    }
+
+    if (!$dara.isNull(request.filter)) {
+      query["filter"] = request.filter;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "DeleteContexts",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}/context`,
+      method: "DELETE",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.DeleteContextsResponse>(await this.callApi(params, req, runtime), new $_model.DeleteContextsResponse({}));
+  }
+
+  /**
+   * 批量删除上下文
+   * 
+   * @param request - DeleteContextsRequest
+   * @returns DeleteContextsResponse
+   */
+  async deleteContexts(workspace: string, contextStoreName: string, request: $_model.DeleteContextsRequest): Promise<$_model.DeleteContextsResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.deleteContextsWithOptions(workspace, contextStoreName, request, headers, runtime);
+  }
+
   /**
    * 删除数据集
    * 
@@ -1800,6 +2190,45 @@ export default class Client extends OpenApi {
     return await this.deleteMemoryStoreWithOptions(workspace, memoryStoreName, request, headers, runtime);
   }
 
+  /**
+   * 删除流水线
+   * 
+   * @param request - DeletePipelineRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns DeletePipelineResponse
+   */
+  async deletePipelineWithOptions(workspace: string, pipelineName: string, request: $_model.DeletePipelineRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.DeletePipelineResponse> {
+    request.validate();
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "DeletePipeline",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/pipeline/${$dara.URL.percentEncode(pipelineName)}`,
+      method: "DELETE",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.DeletePipelineResponse>(await this.callApi(params, req, runtime), new $_model.DeletePipelineResponse({}));
+  }
+
+  /**
+   * 删除流水线
+   * 
+   * @param request - DeletePipelineRequest
+   * @returns DeletePipelineResponse
+   */
+  async deletePipeline(workspace: string, pipelineName: string, request: $_model.DeletePipelineRequest): Promise<$_model.DeletePipelineResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.deletePipelineWithOptions(workspace, pipelineName, request, headers, runtime);
+  }
+
   /**
    * Delete prom instance
    * 
@@ -2730,6 +3159,90 @@ export default class Client extends OpenApi {
     return await this.getCmsServiceWithOptions(request, headers, runtime);
   }
 
+  /**
+   * 查询单条上下文
+   * 
+   * @param request - GetContextRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns GetContextResponse
+   */
+  async getContextWithOptions(workspace: string, contextStoreName: string, contextId: string, request: $_model.GetContextRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.GetContextResponse> {
+    request.validate();
+    let query : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.formatted)) {
+      query["formatted"] = request.formatted;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "GetContext",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}/context/${$dara.URL.percentEncode(contextId)}`,
+      method: "GET",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.GetContextResponse>(await this.callApi(params, req, runtime), new $_model.GetContextResponse({}));
+  }
+
+  /**
+   * 查询单条上下文
+   * 
+   * @param request - GetContextRequest
+   * @returns GetContextResponse
+   */
+  async getContext(workspace: string, contextStoreName: string, contextId: string, request: $_model.GetContextRequest): Promise<$_model.GetContextResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.getContextWithOptions(workspace, contextStoreName, contextId, request, headers, runtime);
+  }
+
+  /**
+   * 查询上下文库
+   * 
+   * @param request - GetContextStoreRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns GetContextStoreResponse
+   */
+  async getContextStoreWithOptions(workspace: string, contextStoreName: string, request: $_model.GetContextStoreRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.GetContextStoreResponse> {
+    request.validate();
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "GetContextStore",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}`,
+      method: "GET",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.GetContextStoreResponse>(await this.callApi(params, req, runtime), new $_model.GetContextStoreResponse({}));
+  }
+
+  /**
+   * 查询上下文库
+   * 
+   * @param request - GetContextStoreRequest
+   * @returns GetContextStoreResponse
+   */
+  async getContextStore(workspace: string, contextStoreName: string, request: $_model.GetContextStoreRequest): Promise<$_model.GetContextStoreResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.getContextStoreWithOptions(workspace, contextStoreName, request, headers, runtime);
+  }
+
   /**
    * 查询数据集
    * 
@@ -3183,6 +3696,45 @@ export default class Client extends OpenApi {
     return await this.getMemoryStoreWithOptions(workspace, memoryStoreName, request, headers, runtime);
   }
 
+  /**
+   * 查询流水线
+   * 
+   * @param request - GetPipelineRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns GetPipelineResponse
+   */
+  async getPipelineWithOptions(workspace: string, pipelineName: string, request: $_model.GetPipelineRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.GetPipelineResponse> {
+    request.validate();
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "GetPipeline",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/pipeline/${$dara.URL.percentEncode(pipelineName)}`,
+      method: "GET",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.GetPipelineResponse>(await this.callApi(params, req, runtime), new $_model.GetPipelineResponse({}));
+  }
+
+  /**
+   * 查询流水线
+   * 
+   * @param request - GetPipelineRequest
+   * @returns GetPipelineResponse
+   */
+  async getPipeline(workspace: string, pipelineName: string, request: $_model.GetPipelineRequest): Promise<$_model.GetPipelineResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.getPipelineWithOptions(workspace, pipelineName, request, headers, runtime);
+  }
+
   /**
    * Query the instance in a specified environment
    * 
@@ -4149,24 +4701,130 @@ export default class Client extends OpenApi {
       query["name"] = request.name;
     }
 
-    if (!$dara.isNull(request.pageNumber)) {
-      query["pageNumber"] = request.pageNumber;
-    }
+    if (!$dara.isNull(request.pageNumber)) {
+      query["pageNumber"] = request.pageNumber;
+    }
+
+    if (!$dara.isNull(request.pageSize)) {
+      query["pageSize"] = request.pageSize;
+    }
+
+    if (!$dara.isNull(request.phone)) {
+      query["phone"] = request.phone;
+    }
+
+    if (!$dara.isNull(request.queryUngroupedContacts)) {
+      query["queryUngroupedContacts"] = request.queryUngroupedContacts;
+    }
+
+    if (!$dara.isNull(request.workspace)) {
+      query["workspace"] = request.workspace;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "ListContacts",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/contact`,
+      method: "GET",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.ListContactsResponse>(await this.callApi(params, req, runtime), new $_model.ListContactsResponse({}));
+  }
+
+  /**
+   * 查询联系人
+   * 
+   * @param request - ListContactsRequest
+   * @returns ListContactsResponse
+   */
+  async listContacts(request: $_model.ListContactsRequest): Promise<$_model.ListContactsResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.listContactsWithOptions(request, headers, runtime);
+  }
+
+  /**
+   * 获取 API Key 列表
+   * 
+   * @param request - ListContextStoreAPIKeysRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns ListContextStoreAPIKeysResponse
+   */
+  async listContextStoreAPIKeysWithOptions(workspace: string, contextStoreName: string, request: $_model.ListContextStoreAPIKeysRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.ListContextStoreAPIKeysResponse> {
+    request.validate();
+    let query : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.maxResults)) {
+      query["maxResults"] = request.maxResults;
+    }
+
+    if (!$dara.isNull(request.nextToken)) {
+      query["nextToken"] = request.nextToken;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "ListContextStoreAPIKeys",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}/apikey`,
+      method: "GET",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.ListContextStoreAPIKeysResponse>(await this.callApi(params, req, runtime), new $_model.ListContextStoreAPIKeysResponse({}));
+  }
+
+  /**
+   * 获取 API Key 列表
+   * 
+   * @param request - ListContextStoreAPIKeysRequest
+   * @returns ListContextStoreAPIKeysResponse
+   */
+  async listContextStoreAPIKeys(workspace: string, contextStoreName: string, request: $_model.ListContextStoreAPIKeysRequest): Promise<$_model.ListContextStoreAPIKeysResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.listContextStoreAPIKeysWithOptions(workspace, contextStoreName, request, headers, runtime);
+  }
 
-    if (!$dara.isNull(request.pageSize)) {
-      query["pageSize"] = request.pageSize;
+  /**
+   * 查询上下文库列表
+   * 
+   * @param request - ListContextStoresRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns ListContextStoresResponse
+   */
+  async listContextStoresWithOptions(workspace: string, request: $_model.ListContextStoresRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.ListContextStoresResponse> {
+    request.validate();
+    let query : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.contextStoreName)) {
+      query["contextStoreName"] = request.contextStoreName;
     }
 
-    if (!$dara.isNull(request.phone)) {
-      query["phone"] = request.phone;
+    if (!$dara.isNull(request.contextType)) {
+      query["contextType"] = request.contextType;
     }
 
-    if (!$dara.isNull(request.queryUngroupedContacts)) {
-      query["queryUngroupedContacts"] = request.queryUngroupedContacts;
+    if (!$dara.isNull(request.maxResults)) {
+      query["maxResults"] = request.maxResults;
     }
 
-    if (!$dara.isNull(request.workspace)) {
-      query["workspace"] = request.workspace;
+    if (!$dara.isNull(request.nextToken)) {
+      query["nextToken"] = request.nextToken;
     }
 
     let req = new $OpenApiUtil.OpenApiRequest({
@@ -4174,29 +4832,29 @@ export default class Client extends OpenApi {
       query: OpenApiUtil.query(query),
     });
     let params = new $OpenApiUtil.Params({
-      action: "ListContacts",
+      action: "ListContextStores",
       version: "2024-03-30",
       protocol: "HTTPS",
-      pathname: `/contact`,
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore`,
       method: "GET",
       authType: "AK",
       style: "ROA",
       reqBodyType: "json",
       bodyType: "json",
     });
-    return $dara.cast<$_model.ListContactsResponse>(await this.callApi(params, req, runtime), new $_model.ListContactsResponse({}));
+    return $dara.cast<$_model.ListContextStoresResponse>(await this.callApi(params, req, runtime), new $_model.ListContextStoresResponse({}));
   }
 
   /**
-   * 查询联系人
+   * 查询上下文库列表
    * 
-   * @param request - ListContactsRequest
-   * @returns ListContactsResponse
+   * @param request - ListContextStoresRequest
+   * @returns ListContextStoresResponse
    */
-  async listContacts(request: $_model.ListContactsRequest): Promise<$_model.ListContactsResponse> {
+  async listContextStores(workspace: string, request: $_model.ListContextStoresRequest): Promise<$_model.ListContextStoresResponse> {
     let runtime = new $dara.RuntimeOptions({ });
     let headers : {[key: string ]: string} = { };
-    return await this.listContactsWithOptions(request, headers, runtime);
+    return await this.listContextStoresWithOptions(workspace, request, headers, runtime);
   }
 
   /**
@@ -4860,6 +5518,59 @@ export default class Client extends OpenApi {
     return await this.listMemoryStoresWithOptions(workspace, request, headers, runtime);
   }
 
+  /**
+   * 查询流水线列表
+   * 
+   * @param request - ListPipelinesRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns ListPipelinesResponse
+   */
+  async listPipelinesWithOptions(workspace: string, request: $_model.ListPipelinesRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.ListPipelinesResponse> {
+    request.validate();
+    let query : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.maxResults)) {
+      query["maxResults"] = request.maxResults;
+    }
+
+    if (!$dara.isNull(request.nextToken)) {
+      query["nextToken"] = request.nextToken;
+    }
+
+    if (!$dara.isNull(request.pipelineName)) {
+      query["pipelineName"] = request.pipelineName;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "ListPipelines",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/pipeline`,
+      method: "GET",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.ListPipelinesResponse>(await this.callApi(params, req, runtime), new $_model.ListPipelinesResponse({}));
+  }
+
+  /**
+   * 查询流水线列表
+   * 
+   * @param request - ListPipelinesRequest
+   * @returns ListPipelinesResponse
+   */
+  async listPipelines(workspace: string, request: $_model.ListPipelinesRequest): Promise<$_model.ListPipelinesResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.listPipelinesWithOptions(workspace, request, headers, runtime);
+  }
+
   /**
    * Get Prometheus Instance Dashboard List
    * 
@@ -5542,6 +6253,71 @@ export default class Client extends OpenApi {
     return await this.queryAlertRulesWithOptions(request, headers, runtime);
   }
 
+  /**
+   * 搜索上下文
+   * 
+   * @param request - SearchContextRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns SearchContextResponse
+   */
+  async searchContextWithOptions(workspace: string, contextStoreName: string, request: $_model.SearchContextRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.SearchContextResponse> {
+    request.validate();
+    let body : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.filter)) {
+      body["filter"] = request.filter;
+    }
+
+    if (!$dara.isNull(request.formatted)) {
+      body["formatted"] = request.formatted;
+    }
+
+    if (!$dara.isNull(request.limit)) {
+      body["limit"] = request.limit;
+    }
+
+    if (!$dara.isNull(request.query)) {
+      body["query"] = request.query;
+    }
+
+    if (!$dara.isNull(request.retrievalOption)) {
+      body["retrievalOption"] = request.retrievalOption;
+    }
+
+    if (!$dara.isNull(request.threshold)) {
+      body["threshold"] = request.threshold;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      body: OpenApiUtil.parseToMap(body),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "SearchContext",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}/context/search`,
+      method: "POST",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.SearchContextResponse>(await this.callApi(params, req, runtime), new $_model.SearchContextResponse({}));
+  }
+
+  /**
+   * 搜索上下文
+   * 
+   * @param request - SearchContextRequest
+   * @returns SearchContextResponse
+   */
+  async searchContext(workspace: string, contextStoreName: string, request: $_model.SearchContextRequest): Promise<$_model.SearchContextResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.searchContextWithOptions(workspace, contextStoreName, request, headers, runtime);
+  }
+
   /**
    * 搜索记忆
    * 
@@ -6076,6 +6852,124 @@ export default class Client extends OpenApi {
     return await this.updateBizTraceWithOptions(bizTraceId, request, headers, runtime);
   }
 
+  /**
+   * 修改上下文
+   * 
+   * @param request - UpdateContextRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns UpdateContextResponse
+   */
+  async updateContextWithOptions(workspace: string, contextStoreName: string, contextId: string, request: $_model.UpdateContextRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.UpdateContextResponse> {
+    request.validate();
+    let body : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.content)) {
+      body["content"] = request.content;
+    }
+
+    if (!$dara.isNull(request.experience)) {
+      body["experience"] = request.experience;
+    }
+
+    if (!$dara.isNull(request.metadata)) {
+      body["metadata"] = request.metadata;
+    }
+
+    if (!$dara.isNull(request.payload)) {
+      body["payload"] = request.payload;
+    }
+
+    if (!$dara.isNull(request.triggerCondition)) {
+      body["triggerCondition"] = request.triggerCondition;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      body: OpenApiUtil.parseToMap(body),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "UpdateContext",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}/context/${$dara.URL.percentEncode(contextId)}`,
+      method: "PUT",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.UpdateContextResponse>(await this.callApi(params, req, runtime), new $_model.UpdateContextResponse({}));
+  }
+
+  /**
+   * 修改上下文
+   * 
+   * @param request - UpdateContextRequest
+   * @returns UpdateContextResponse
+   */
+  async updateContext(workspace: string, contextStoreName: string, contextId: string, request: $_model.UpdateContextRequest): Promise<$_model.UpdateContextResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.updateContextWithOptions(workspace, contextStoreName, contextId, request, headers, runtime);
+  }
+
+  /**
+   * 修改上下文库配置
+   * 
+   * @param request - UpdateContextStoreRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns UpdateContextStoreResponse
+   */
+  async updateContextStoreWithOptions(workspace: string, contextStoreName: string, request: $_model.UpdateContextStoreRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.UpdateContextStoreResponse> {
+    request.validate();
+    let body : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.config)) {
+      body["config"] = request.config;
+    }
+
+    if (!$dara.isNull(request.contextType)) {
+      body["contextType"] = request.contextType;
+    }
+
+    if (!$dara.isNull(request.dataset)) {
+      body["dataset"] = request.dataset;
+    }
+
+    if (!$dara.isNull(request.description)) {
+      body["description"] = request.description;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      body: OpenApiUtil.parseToMap(body),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "UpdateContextStore",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/contextstore/${$dara.URL.percentEncode(contextStoreName)}`,
+      method: "PUT",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.UpdateContextStoreResponse>(await this.callApi(params, req, runtime), new $_model.UpdateContextStoreResponse({}));
+  }
+
+  /**
+   * 修改上下文库配置
+   * 
+   * @param request - UpdateContextStoreRequest
+   * @returns UpdateContextStoreResponse
+   */
+  async updateContextStore(workspace: string, contextStoreName: string, request: $_model.UpdateContextStoreRequest): Promise<$_model.UpdateContextStoreResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.updateContextStoreWithOptions(workspace, contextStoreName, request, headers, runtime);
+  }
+
   /**
    * 更新数据集
    * 
@@ -6407,6 +7301,67 @@ export default class Client extends OpenApi {
     return await this.updateNotifyStrategyWithOptions(notifyStrategyId, request, headers, runtime);
   }
 
+  /**
+   * 更新流水线
+   * 
+   * @param request - UpdatePipelineRequest
+   * @param headers - map
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns UpdatePipelineResponse
+   */
+  async updatePipelineWithOptions(workspace: string, pipelineName: string, request: $_model.UpdatePipelineRequest, headers: {[key: string ]: string}, runtime: $dara.RuntimeOptions): Promise<$_model.UpdatePipelineResponse> {
+    request.validate();
+    let body : {[key: string ]: any} = { };
+    if (!$dara.isNull(request.description)) {
+      body["description"] = request.description;
+    }
+
+    if (!$dara.isNull(request.executePolicy)) {
+      body["executePolicy"] = request.executePolicy;
+    }
+
+    if (!$dara.isNull(request.pipeline)) {
+      body["pipeline"] = request.pipeline;
+    }
+
+    if (!$dara.isNull(request.sink)) {
+      body["sink"] = request.sink;
+    }
+
+    if (!$dara.isNull(request.source)) {
+      body["source"] = request.source;
+    }
+
+    let req = new $OpenApiUtil.OpenApiRequest({
+      headers: headers,
+      body: OpenApiUtil.parseToMap(body),
+    });
+    let params = new $OpenApiUtil.Params({
+      action: "UpdatePipeline",
+      version: "2024-03-30",
+      protocol: "HTTPS",
+      pathname: `/workspace/${$dara.URL.percentEncode(workspace)}/pipeline/${$dara.URL.percentEncode(pipelineName)}`,
+      method: "PUT",
+      authType: "AK",
+      style: "ROA",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $dara.cast<$_model.UpdatePipelineResponse>(await this.callApi(params, req, runtime), new $_model.UpdatePipelineResponse({}));
+  }
+
+  /**
+   * 更新流水线
+   * 
+   * @param request - UpdatePipelineRequest
+   * @returns UpdatePipelineResponse
+   */
+  async updatePipeline(workspace: string, pipelineName: string, request: $_model.UpdatePipelineRequest): Promise<$_model.UpdatePipelineResponse> {
+    let runtime = new $dara.RuntimeOptions({ });
+    let headers : {[key: string ]: string} = { };
+    return await this.updatePipelineWithOptions(workspace, pipelineName, request, headers, runtime);
+  }
+
   /**
    * Update Prometheus instance information
    *