@alicloud/cms20240330 9.0.1 → 9.1.0

package/src/client.ts

@@ -839,6 +839,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
    * 
@@ -1800,6 +1865,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
    * 
@@ -3183,6 +3287,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
    * 
@@ -4860,6 +5003,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
    * 
@@ -6407,6 +6603,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
    * 

package/src/models/CreatePipelineRequest.ts

@@ -0,0 +1,376 @@
+// This file is auto-generated, don't edit it
+import * as $dara from '@darabonba/typescript';
+
+
+export class CreatePipelineRequestExecutePolicyRunOnce extends $dara.Model {
+  /**
+   * @example
+   * 1772519013
+   */
+  fromTime?: number;
+  /**
+   * @example
+   * 1772519013
+   */
+  toTime?: number;
+  static names(): { [key: string]: string } {
+    return {
+      fromTime: 'fromTime',
+      toTime: 'toTime',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      fromTime: 'number',
+      toTime: 'number',
+    };
+  }
+
+  validate() {
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CreatePipelineRequestExecutePolicyScheduled extends $dara.Model {
+  /**
+   * @example
+   * 1772519013
+   */
+  fromTime?: number;
+  /**
+   * @example
+   * 86400
+   */
+  interval?: string;
+  static names(): { [key: string]: string } {
+    return {
+      fromTime: 'fromTime',
+      interval: 'interval',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      fromTime: 'number',
+      interval: 'string',
+    };
+  }
+
+  validate() {
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CreatePipelineRequestExecutePolicy extends $dara.Model {
+  /**
+   * @example
+   * runOnce
+   */
+  mode?: string;
+  runOnce?: CreatePipelineRequestExecutePolicyRunOnce;
+  scheduled?: CreatePipelineRequestExecutePolicyScheduled;
+  static names(): { [key: string]: string } {
+    return {
+      mode: 'mode',
+      runOnce: 'runOnce',
+      scheduled: 'scheduled',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      mode: 'string',
+      runOnce: CreatePipelineRequestExecutePolicyRunOnce,
+      scheduled: CreatePipelineRequestExecutePolicyScheduled,
+    };
+  }
+
+  validate() {
+    if(this.runOnce && typeof (this.runOnce as any).validate === 'function') {
+      (this.runOnce as any).validate();
+    }
+    if(this.scheduled && typeof (this.scheduled as any).validate === 'function') {
+      (this.scheduled as any).validate();
+    }
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CreatePipelineRequestPipelineNodes extends $dara.Model {
+  /**
+   * @example
+   * node_1
+   */
+  id?: string;
+  parameters?: { [key: string]: any };
+  /**
+   * @example
+   * dedup-fuzzy
+   */
+  type?: string;
+  static names(): { [key: string]: string } {
+    return {
+      id: 'id',
+      parameters: 'parameters',
+      type: 'type',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      id: 'string',
+      parameters: { 'type': 'map', 'keyType': 'string', 'valueType': 'any' },
+      type: 'string',
+    };
+  }
+
+  validate() {
+    if(this.parameters) {
+      $dara.Model.validateMap(this.parameters);
+    }
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CreatePipelineRequestPipeline extends $dara.Model {
+  nodes?: CreatePipelineRequestPipelineNodes[];
+  static names(): { [key: string]: string } {
+    return {
+      nodes: 'nodes',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      nodes: { 'type': 'array', 'itemType': CreatePipelineRequestPipelineNodes },
+    };
+  }
+
+  validate() {
+    if(Array.isArray(this.nodes)) {
+      $dara.Model.validateArray(this.nodes);
+    }
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CreatePipelineRequestSinkDataset extends $dara.Model {
+  /**
+   * @example
+   * dataset_1
+   */
+  dataset?: string;
+  /**
+   * @example
+   * workspace-test
+   */
+  workspace?: string;
+  static names(): { [key: string]: string } {
+    return {
+      dataset: 'dataset',
+      workspace: 'workspace',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      dataset: 'string',
+      workspace: 'string',
+    };
+  }
+
+  validate() {
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CreatePipelineRequestSink extends $dara.Model {
+  dataset?: CreatePipelineRequestSinkDataset;
+  /**
+   * @example
+   * dataset
+   */
+  type?: string;
+  static names(): { [key: string]: string } {
+    return {
+      dataset: 'dataset',
+      type: 'type',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      dataset: CreatePipelineRequestSinkDataset,
+      type: 'string',
+    };
+  }
+
+  validate() {
+    if(this.dataset && typeof (this.dataset as any).validate === 'function') {
+      (this.dataset as any).validate();
+    }
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CreatePipelineRequestSourceLogstore extends $dara.Model {
+  /**
+   * @example
+   * test-logstore
+   */
+  logstore?: string;
+  /**
+   * @example
+   * test-project
+   */
+  project?: string;
+  /**
+   * @example
+   * status:500 and method:GET
+   */
+  query?: string;
+  static names(): { [key: string]: string } {
+    return {
+      logstore: 'logstore',
+      project: 'project',
+      query: 'query',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      logstore: 'string',
+      project: 'string',
+      query: 'string',
+    };
+  }
+
+  validate() {
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CreatePipelineRequestSource extends $dara.Model {
+  logstore?: CreatePipelineRequestSourceLogstore;
+  /**
+   * @example
+   * logstore
+   */
+  type?: string;
+  static names(): { [key: string]: string } {
+    return {
+      logstore: 'logstore',
+      type: 'type',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      logstore: CreatePipelineRequestSourceLogstore,
+      type: 'string',
+    };
+  }
+
+  validate() {
+    if(this.logstore && typeof (this.logstore as any).validate === 'function') {
+      (this.logstore as any).validate();
+    }
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CreatePipelineRequest extends $dara.Model {
+  /**
+   * @example
+   * test
+   */
+  description?: string;
+  executePolicy?: CreatePipelineRequestExecutePolicy;
+  pipeline?: CreatePipelineRequestPipeline;
+  /**
+   * @example
+   * pipeline-name-1
+   */
+  pipelineName?: string;
+  sink?: CreatePipelineRequestSink;
+  source?: CreatePipelineRequestSource;
+  static names(): { [key: string]: string } {
+    return {
+      description: 'description',
+      executePolicy: 'executePolicy',
+      pipeline: 'pipeline',
+      pipelineName: 'pipelineName',
+      sink: 'sink',
+      source: 'source',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      description: 'string',
+      executePolicy: CreatePipelineRequestExecutePolicy,
+      pipeline: CreatePipelineRequestPipeline,
+      pipelineName: 'string',
+      sink: CreatePipelineRequestSink,
+      source: CreatePipelineRequestSource,
+    };
+  }
+
+  validate() {
+    if(this.executePolicy && typeof (this.executePolicy as any).validate === 'function') {
+      (this.executePolicy as any).validate();
+    }
+    if(this.pipeline && typeof (this.pipeline as any).validate === 'function') {
+      (this.pipeline as any).validate();
+    }
+    if(this.sink && typeof (this.sink as any).validate === 'function') {
+      (this.sink as any).validate();
+    }
+    if(this.source && typeof (this.source as any).validate === 'function') {
+      (this.source as any).validate();
+    }
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+

package/src/models/CreatePipelineResponse.ts

@@ -0,0 +1,40 @@
+// This file is auto-generated, don't edit it
+import * as $dara from '@darabonba/typescript';
+import { CreatePipelineResponseBody } from "./CreatePipelineResponseBody";
+
+
+export class CreatePipelineResponse extends $dara.Model {
+  headers?: { [key: string]: string };
+  statusCode?: number;
+  body?: CreatePipelineResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      statusCode: 'statusCode',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      statusCode: 'number',
+      body: CreatePipelineResponseBody,
+    };
+  }
+
+  validate() {
+    if(this.headers) {
+      $dara.Model.validateMap(this.headers);
+    }
+    if(this.body && typeof (this.body as any).validate === 'function') {
+      (this.body as any).validate();
+    }
+    super.validate();
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+