@alicloud/eventbridge20200401 2.0.1 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/client.ts CHANGED
@@ -1469,6 +1469,280 @@ export class EnableRuleResponse extends $tea.Model {
1469
1469
  }
1470
1470
  }
1471
1471
 
1472
+ export class EventCenterCheckEnabledOnDefaultBusResponseBody extends $tea.Model {
1473
+ code?: string;
1474
+ data?: EventCenterCheckEnabledOnDefaultBusResponseBodyData;
1475
+ message?: string;
1476
+ requestId?: string;
1477
+ success?: boolean;
1478
+ static names(): { [key: string]: string } {
1479
+ return {
1480
+ code: 'Code',
1481
+ data: 'Data',
1482
+ message: 'Message',
1483
+ requestId: 'RequestId',
1484
+ success: 'Success',
1485
+ };
1486
+ }
1487
+
1488
+ static types(): { [key: string]: any } {
1489
+ return {
1490
+ code: 'string',
1491
+ data: EventCenterCheckEnabledOnDefaultBusResponseBodyData,
1492
+ message: 'string',
1493
+ requestId: 'string',
1494
+ success: 'boolean',
1495
+ };
1496
+ }
1497
+
1498
+ constructor(map?: { [key: string]: any }) {
1499
+ super(map);
1500
+ }
1501
+ }
1502
+
1503
+ export class EventCenterCheckEnabledOnDefaultBusResponse extends $tea.Model {
1504
+ headers?: { [key: string]: string };
1505
+ statusCode?: number;
1506
+ body?: EventCenterCheckEnabledOnDefaultBusResponseBody;
1507
+ static names(): { [key: string]: string } {
1508
+ return {
1509
+ headers: 'headers',
1510
+ statusCode: 'statusCode',
1511
+ body: 'body',
1512
+ };
1513
+ }
1514
+
1515
+ static types(): { [key: string]: any } {
1516
+ return {
1517
+ headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
1518
+ statusCode: 'number',
1519
+ body: EventCenterCheckEnabledOnDefaultBusResponseBody,
1520
+ };
1521
+ }
1522
+
1523
+ constructor(map?: { [key: string]: any }) {
1524
+ super(map);
1525
+ }
1526
+ }
1527
+
1528
+ export class EventCenterDisableOnDefaultBusResponseBody extends $tea.Model {
1529
+ code?: string;
1530
+ message?: string;
1531
+ requestId?: string;
1532
+ success?: boolean;
1533
+ static names(): { [key: string]: string } {
1534
+ return {
1535
+ code: 'Code',
1536
+ message: 'Message',
1537
+ requestId: 'RequestId',
1538
+ success: 'Success',
1539
+ };
1540
+ }
1541
+
1542
+ static types(): { [key: string]: any } {
1543
+ return {
1544
+ code: 'string',
1545
+ message: 'string',
1546
+ requestId: 'string',
1547
+ success: 'boolean',
1548
+ };
1549
+ }
1550
+
1551
+ constructor(map?: { [key: string]: any }) {
1552
+ super(map);
1553
+ }
1554
+ }
1555
+
1556
+ export class EventCenterDisableOnDefaultBusResponse extends $tea.Model {
1557
+ headers?: { [key: string]: string };
1558
+ statusCode?: number;
1559
+ body?: EventCenterDisableOnDefaultBusResponseBody;
1560
+ static names(): { [key: string]: string } {
1561
+ return {
1562
+ headers: 'headers',
1563
+ statusCode: 'statusCode',
1564
+ body: 'body',
1565
+ };
1566
+ }
1567
+
1568
+ static types(): { [key: string]: any } {
1569
+ return {
1570
+ headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
1571
+ statusCode: 'number',
1572
+ body: EventCenterDisableOnDefaultBusResponseBody,
1573
+ };
1574
+ }
1575
+
1576
+ constructor(map?: { [key: string]: any }) {
1577
+ super(map);
1578
+ }
1579
+ }
1580
+
1581
+ export class EventCenterEnableOnDefaultBusResponseBody extends $tea.Model {
1582
+ code?: string;
1583
+ message?: string;
1584
+ requestId?: string;
1585
+ success?: boolean;
1586
+ static names(): { [key: string]: string } {
1587
+ return {
1588
+ code: 'Code',
1589
+ message: 'Message',
1590
+ requestId: 'RequestId',
1591
+ success: 'Success',
1592
+ };
1593
+ }
1594
+
1595
+ static types(): { [key: string]: any } {
1596
+ return {
1597
+ code: 'string',
1598
+ message: 'string',
1599
+ requestId: 'string',
1600
+ success: 'boolean',
1601
+ };
1602
+ }
1603
+
1604
+ constructor(map?: { [key: string]: any }) {
1605
+ super(map);
1606
+ }
1607
+ }
1608
+
1609
+ export class EventCenterEnableOnDefaultBusResponse extends $tea.Model {
1610
+ headers?: { [key: string]: string };
1611
+ statusCode?: number;
1612
+ body?: EventCenterEnableOnDefaultBusResponseBody;
1613
+ static names(): { [key: string]: string } {
1614
+ return {
1615
+ headers: 'headers',
1616
+ statusCode: 'statusCode',
1617
+ body: 'body',
1618
+ };
1619
+ }
1620
+
1621
+ static types(): { [key: string]: any } {
1622
+ return {
1623
+ headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
1624
+ statusCode: 'number',
1625
+ body: EventCenterEnableOnDefaultBusResponseBody,
1626
+ };
1627
+ }
1628
+
1629
+ constructor(map?: { [key: string]: any }) {
1630
+ super(map);
1631
+ }
1632
+ }
1633
+
1634
+ export class EventCenterQueryEventsRequest extends $tea.Model {
1635
+ body?: EventCenterQueryEventsRequestBody;
1636
+ busName?: string;
1637
+ maxResults?: number;
1638
+ nextToken?: string;
1639
+ static names(): { [key: string]: string } {
1640
+ return {
1641
+ body: 'Body',
1642
+ busName: 'BusName',
1643
+ maxResults: 'MaxResults',
1644
+ nextToken: 'NextToken',
1645
+ };
1646
+ }
1647
+
1648
+ static types(): { [key: string]: any } {
1649
+ return {
1650
+ body: EventCenterQueryEventsRequestBody,
1651
+ busName: 'string',
1652
+ maxResults: 'number',
1653
+ nextToken: 'string',
1654
+ };
1655
+ }
1656
+
1657
+ constructor(map?: { [key: string]: any }) {
1658
+ super(map);
1659
+ }
1660
+ }
1661
+
1662
+ export class EventCenterQueryEventsShrinkRequest extends $tea.Model {
1663
+ bodyShrink?: string;
1664
+ busName?: string;
1665
+ maxResults?: number;
1666
+ nextToken?: string;
1667
+ static names(): { [key: string]: string } {
1668
+ return {
1669
+ bodyShrink: 'Body',
1670
+ busName: 'BusName',
1671
+ maxResults: 'MaxResults',
1672
+ nextToken: 'NextToken',
1673
+ };
1674
+ }
1675
+
1676
+ static types(): { [key: string]: any } {
1677
+ return {
1678
+ bodyShrink: 'string',
1679
+ busName: 'string',
1680
+ maxResults: 'number',
1681
+ nextToken: 'string',
1682
+ };
1683
+ }
1684
+
1685
+ constructor(map?: { [key: string]: any }) {
1686
+ super(map);
1687
+ }
1688
+ }
1689
+
1690
+ export class EventCenterQueryEventsResponseBody extends $tea.Model {
1691
+ code?: string;
1692
+ data?: EventCenterQueryEventsResponseBodyData;
1693
+ message?: string;
1694
+ requestId?: string;
1695
+ success?: boolean;
1696
+ static names(): { [key: string]: string } {
1697
+ return {
1698
+ code: 'Code',
1699
+ data: 'Data',
1700
+ message: 'Message',
1701
+ requestId: 'RequestId',
1702
+ success: 'Success',
1703
+ };
1704
+ }
1705
+
1706
+ static types(): { [key: string]: any } {
1707
+ return {
1708
+ code: 'string',
1709
+ data: EventCenterQueryEventsResponseBodyData,
1710
+ message: 'string',
1711
+ requestId: 'string',
1712
+ success: 'boolean',
1713
+ };
1714
+ }
1715
+
1716
+ constructor(map?: { [key: string]: any }) {
1717
+ super(map);
1718
+ }
1719
+ }
1720
+
1721
+ export class EventCenterQueryEventsResponse extends $tea.Model {
1722
+ headers?: { [key: string]: string };
1723
+ statusCode?: number;
1724
+ body?: EventCenterQueryEventsResponseBody;
1725
+ static names(): { [key: string]: string } {
1726
+ return {
1727
+ headers: 'headers',
1728
+ statusCode: 'statusCode',
1729
+ body: 'body',
1730
+ };
1731
+ }
1732
+
1733
+ static types(): { [key: string]: any } {
1734
+ return {
1735
+ headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
1736
+ statusCode: 'number',
1737
+ body: EventCenterQueryEventsResponseBody,
1738
+ };
1739
+ }
1740
+
1741
+ constructor(map?: { [key: string]: any }) {
1742
+ super(map);
1743
+ }
1744
+ }
1745
+
1472
1746
  export class GetApiDestinationRequest extends $tea.Model {
1473
1747
  apiDestinationName?: string;
1474
1748
  static names(): { [key: string]: string } {
@@ -6915,6 +7189,243 @@ export class DeleteTargetsResponseBodyData extends $tea.Model {
6915
7189
  }
6916
7190
  }
6917
7191
 
7192
+ export class EventCenterCheckEnabledOnDefaultBusResponseBodyData extends $tea.Model {
7193
+ enabled?: boolean;
7194
+ static names(): { [key: string]: string } {
7195
+ return {
7196
+ enabled: 'Enabled',
7197
+ };
7198
+ }
7199
+
7200
+ static types(): { [key: string]: any } {
7201
+ return {
7202
+ enabled: 'boolean',
7203
+ };
7204
+ }
7205
+
7206
+ constructor(map?: { [key: string]: any }) {
7207
+ super(map);
7208
+ }
7209
+ }
7210
+
7211
+ export class EventCenterQueryEventsRequestBodyParametersCalculations extends $tea.Model {
7212
+ column?: string;
7213
+ op?: string;
7214
+ static names(): { [key: string]: string } {
7215
+ return {
7216
+ column: 'Column',
7217
+ op: 'Op',
7218
+ };
7219
+ }
7220
+
7221
+ static types(): { [key: string]: any } {
7222
+ return {
7223
+ column: 'string',
7224
+ op: 'string',
7225
+ };
7226
+ }
7227
+
7228
+ constructor(map?: { [key: string]: any }) {
7229
+ super(map);
7230
+ }
7231
+ }
7232
+
7233
+ export class EventCenterQueryEventsRequestBodyParametersFilters extends $tea.Model {
7234
+ column?: string;
7235
+ op?: string;
7236
+ values?: string[];
7237
+ static names(): { [key: string]: string } {
7238
+ return {
7239
+ column: 'Column',
7240
+ op: 'Op',
7241
+ values: 'Values',
7242
+ };
7243
+ }
7244
+
7245
+ static types(): { [key: string]: any } {
7246
+ return {
7247
+ column: 'string',
7248
+ op: 'string',
7249
+ values: { 'type': 'array', 'itemType': 'string' },
7250
+ };
7251
+ }
7252
+
7253
+ constructor(map?: { [key: string]: any }) {
7254
+ super(map);
7255
+ }
7256
+ }
7257
+
7258
+ export class EventCenterQueryEventsRequestBodyParametersOrders extends $tea.Model {
7259
+ column?: string;
7260
+ desc?: boolean;
7261
+ op?: string;
7262
+ static names(): { [key: string]: string } {
7263
+ return {
7264
+ column: 'Column',
7265
+ desc: 'Desc',
7266
+ op: 'Op',
7267
+ };
7268
+ }
7269
+
7270
+ static types(): { [key: string]: any } {
7271
+ return {
7272
+ column: 'string',
7273
+ desc: 'boolean',
7274
+ op: 'string',
7275
+ };
7276
+ }
7277
+
7278
+ constructor(map?: { [key: string]: any }) {
7279
+ super(map);
7280
+ }
7281
+ }
7282
+
7283
+ export class EventCenterQueryEventsRequestBodyParameters extends $tea.Model {
7284
+ breakdowns?: string[];
7285
+ calculations?: EventCenterQueryEventsRequestBodyParametersCalculations[];
7286
+ endTime?: number;
7287
+ filterCombination?: string;
7288
+ filters?: EventCenterQueryEventsRequestBodyParametersFilters[];
7289
+ granularity?: number;
7290
+ limit?: number;
7291
+ offset?: number;
7292
+ orders?: EventCenterQueryEventsRequestBodyParametersOrders[];
7293
+ startTime?: number;
7294
+ timeRange?: number;
7295
+ static names(): { [key: string]: string } {
7296
+ return {
7297
+ breakdowns: 'Breakdowns',
7298
+ calculations: 'Calculations',
7299
+ endTime: 'EndTime',
7300
+ filterCombination: 'FilterCombination',
7301
+ filters: 'Filters',
7302
+ granularity: 'Granularity',
7303
+ limit: 'Limit',
7304
+ offset: 'Offset',
7305
+ orders: 'Orders',
7306
+ startTime: 'StartTime',
7307
+ timeRange: 'TimeRange',
7308
+ };
7309
+ }
7310
+
7311
+ static types(): { [key: string]: any } {
7312
+ return {
7313
+ breakdowns: { 'type': 'array', 'itemType': 'string' },
7314
+ calculations: { 'type': 'array', 'itemType': EventCenterQueryEventsRequestBodyParametersCalculations },
7315
+ endTime: 'number',
7316
+ filterCombination: 'string',
7317
+ filters: { 'type': 'array', 'itemType': EventCenterQueryEventsRequestBodyParametersFilters },
7318
+ granularity: 'number',
7319
+ limit: 'number',
7320
+ offset: 'number',
7321
+ orders: { 'type': 'array', 'itemType': EventCenterQueryEventsRequestBodyParametersOrders },
7322
+ startTime: 'number',
7323
+ timeRange: 'number',
7324
+ };
7325
+ }
7326
+
7327
+ constructor(map?: { [key: string]: any }) {
7328
+ super(map);
7329
+ }
7330
+ }
7331
+
7332
+ export class EventCenterQueryEventsRequestBody extends $tea.Model {
7333
+ parameters?: EventCenterQueryEventsRequestBodyParameters;
7334
+ queryType?: string;
7335
+ schemaId?: string;
7336
+ static names(): { [key: string]: string } {
7337
+ return {
7338
+ parameters: 'Parameters',
7339
+ queryType: 'QueryType',
7340
+ schemaId: 'SchemaId',
7341
+ };
7342
+ }
7343
+
7344
+ static types(): { [key: string]: any } {
7345
+ return {
7346
+ parameters: EventCenterQueryEventsRequestBodyParameters,
7347
+ queryType: 'string',
7348
+ schemaId: 'string',
7349
+ };
7350
+ }
7351
+
7352
+ constructor(map?: { [key: string]: any }) {
7353
+ super(map);
7354
+ }
7355
+ }
7356
+
7357
+ export class EventCenterQueryEventsResponseBodyDataTable extends $tea.Model {
7358
+ rowData?: { [key: string]: any };
7359
+ static names(): { [key: string]: string } {
7360
+ return {
7361
+ rowData: 'RowData',
7362
+ };
7363
+ }
7364
+
7365
+ static types(): { [key: string]: any } {
7366
+ return {
7367
+ rowData: { 'type': 'map', 'keyType': 'string', 'valueType': 'any' },
7368
+ };
7369
+ }
7370
+
7371
+ constructor(map?: { [key: string]: any }) {
7372
+ super(map);
7373
+ }
7374
+ }
7375
+
7376
+ export class EventCenterQueryEventsResponseBodyDataTimeSeries extends $tea.Model {
7377
+ rowData?: { [key: string]: any };
7378
+ time?: string;
7379
+ static names(): { [key: string]: string } {
7380
+ return {
7381
+ rowData: 'RowData',
7382
+ time: 'Time',
7383
+ };
7384
+ }
7385
+
7386
+ static types(): { [key: string]: any } {
7387
+ return {
7388
+ rowData: { 'type': 'map', 'keyType': 'string', 'valueType': 'any' },
7389
+ time: 'string',
7390
+ };
7391
+ }
7392
+
7393
+ constructor(map?: { [key: string]: any }) {
7394
+ super(map);
7395
+ }
7396
+ }
7397
+
7398
+ export class EventCenterQueryEventsResponseBodyData extends $tea.Model {
7399
+ maxResults?: number;
7400
+ nextToken?: string;
7401
+ table?: EventCenterQueryEventsResponseBodyDataTable[];
7402
+ timeSeries?: EventCenterQueryEventsResponseBodyDataTimeSeries[];
7403
+ totalCount?: number;
7404
+ static names(): { [key: string]: string } {
7405
+ return {
7406
+ maxResults: 'MaxResults',
7407
+ nextToken: 'NextToken',
7408
+ table: 'Table',
7409
+ timeSeries: 'TimeSeries',
7410
+ totalCount: 'TotalCount',
7411
+ };
7412
+ }
7413
+
7414
+ static types(): { [key: string]: any } {
7415
+ return {
7416
+ maxResults: 'number',
7417
+ nextToken: 'string',
7418
+ table: { 'type': 'array', 'itemType': EventCenterQueryEventsResponseBodyDataTable },
7419
+ timeSeries: { 'type': 'array', 'itemType': EventCenterQueryEventsResponseBodyDataTimeSeries },
7420
+ totalCount: 'number',
7421
+ };
7422
+ }
7423
+
7424
+ constructor(map?: { [key: string]: any }) {
7425
+ super(map);
7426
+ }
7427
+ }
7428
+
6918
7429
  export class GetApiDestinationResponseBodyDataHttpApiParameters extends $tea.Model {
6919
7430
  endpoint?: string;
6920
7431
  method?: string;
@@ -14667,11 +15178,13 @@ export default class Client extends OpenApi {
14667
15178
  }
14668
15179
 
14669
15180
  /**
14670
- * You can call this API operation to create an API destination.
14671
- *
14672
- * @param tmpReq CreateApiDestinationRequest
14673
- * @param runtime runtime options for this request RuntimeOptions
14674
- * @return CreateApiDestinationResponse
15181
+ * @summary Creates an API destination.
15182
+ *
15183
+ * @description You can call this API operation to create an API destination.
15184
+ *
15185
+ * @param tmpReq CreateApiDestinationRequest
15186
+ * @param runtime runtime options for this request RuntimeOptions
15187
+ * @return CreateApiDestinationResponse
14675
15188
  */
14676
15189
  async createApiDestinationWithOptions(tmpReq: CreateApiDestinationRequest, runtime: $Util.RuntimeOptions): Promise<CreateApiDestinationResponse> {
14677
15190
  Util.validateModel(tmpReq);
@@ -14716,10 +15229,12 @@ export default class Client extends OpenApi {
14716
15229
  }
14717
15230
 
14718
15231
  /**
14719
- * You can call this API operation to create an API destination.
14720
- *
14721
- * @param request CreateApiDestinationRequest
14722
- * @return CreateApiDestinationResponse
15232
+ * @summary Creates an API destination.
15233
+ *
15234
+ * @description You can call this API operation to create an API destination.
15235
+ *
15236
+ * @param request CreateApiDestinationRequest
15237
+ * @return CreateApiDestinationResponse
14723
15238
  */
14724
15239
  async createApiDestination(request: CreateApiDestinationRequest): Promise<CreateApiDestinationResponse> {
14725
15240
  let runtime = new $Util.RuntimeOptions({ });
@@ -14727,11 +15242,13 @@ export default class Client extends OpenApi {
14727
15242
  }
14728
15243
 
14729
15244
  /**
14730
- * You can call this API operation to create a connection.
14731
- *
14732
- * @param tmpReq CreateConnectionRequest
14733
- * @param runtime runtime options for this request RuntimeOptions
14734
- * @return CreateConnectionResponse
15245
+ * @summary Creates a connection.
15246
+ *
15247
+ * @description You can call this API operation to create a connection.
15248
+ *
15249
+ * @param tmpReq CreateConnectionRequest
15250
+ * @param runtime runtime options for this request RuntimeOptions
15251
+ * @return CreateConnectionResponse
14735
15252
  */
14736
15253
  async createConnectionWithOptions(tmpReq: CreateConnectionRequest, runtime: $Util.RuntimeOptions): Promise<CreateConnectionResponse> {
14737
15254
  Util.validateModel(tmpReq);
@@ -14780,10 +15297,12 @@ export default class Client extends OpenApi {
14780
15297
  }
14781
15298
 
14782
15299
  /**
14783
- * You can call this API operation to create a connection.
14784
- *
14785
- * @param request CreateConnectionRequest
14786
- * @return CreateConnectionResponse
15300
+ * @summary Creates a connection.
15301
+ *
15302
+ * @description You can call this API operation to create a connection.
15303
+ *
15304
+ * @param request CreateConnectionRequest
15305
+ * @return CreateConnectionResponse
14787
15306
  */
14788
15307
  async createConnection(request: CreateConnectionRequest): Promise<CreateConnectionResponse> {
14789
15308
  let runtime = new $Util.RuntimeOptions({ });
@@ -14791,11 +15310,13 @@ export default class Client extends OpenApi {
14791
15310
  }
14792
15311
 
14793
15312
  /**
14794
- * You can call this API operation to create an event bus.
14795
- *
14796
- * @param request CreateEventBusRequest
14797
- * @param runtime runtime options for this request RuntimeOptions
14798
- * @return CreateEventBusResponse
15313
+ * @summary Creates an event bus.
15314
+ *
15315
+ * @description You can call this API operation to create an event bus.
15316
+ *
15317
+ * @param request CreateEventBusRequest
15318
+ * @param runtime runtime options for this request RuntimeOptions
15319
+ * @return CreateEventBusResponse
14799
15320
  */
14800
15321
  async createEventBusWithOptions(request: CreateEventBusRequest, runtime: $Util.RuntimeOptions): Promise<CreateEventBusResponse> {
14801
15322
  Util.validateModel(request);
@@ -14826,10 +15347,12 @@ export default class Client extends OpenApi {
14826
15347
  }
14827
15348
 
14828
15349
  /**
14829
- * You can call this API operation to create an event bus.
14830
- *
14831
- * @param request CreateEventBusRequest
14832
- * @return CreateEventBusResponse
15350
+ * @summary Creates an event bus.
15351
+ *
15352
+ * @description You can call this API operation to create an event bus.
15353
+ *
15354
+ * @param request CreateEventBusRequest
15355
+ * @return CreateEventBusResponse
14833
15356
  */
14834
15357
  async createEventBus(request: CreateEventBusRequest): Promise<CreateEventBusResponse> {
14835
15358
  let runtime = new $Util.RuntimeOptions({ });
@@ -14837,11 +15360,13 @@ export default class Client extends OpenApi {
14837
15360
  }
14838
15361
 
14839
15362
  /**
14840
- * You can call this operation to create an event source.
14841
- *
14842
- * @param tmpReq CreateEventSourceRequest
14843
- * @param runtime runtime options for this request RuntimeOptions
14844
- * @return CreateEventSourceResponse
15363
+ * @summary Creates an event source.
15364
+ *
15365
+ * @description You can call this operation to create an event source.
15366
+ *
15367
+ * @param tmpReq CreateEventSourceRequest
15368
+ * @param runtime runtime options for this request RuntimeOptions
15369
+ * @return CreateEventSourceResponse
14845
15370
  */
14846
15371
  async createEventSourceWithOptions(tmpReq: CreateEventSourceRequest, runtime: $Util.RuntimeOptions): Promise<CreateEventSourceResponse> {
14847
15372
  Util.validateModel(tmpReq);
@@ -14934,10 +15459,12 @@ export default class Client extends OpenApi {
14934
15459
  }
14935
15460
 
14936
15461
  /**
14937
- * You can call this operation to create an event source.
14938
- *
14939
- * @param request CreateEventSourceRequest
14940
- * @return CreateEventSourceResponse
15462
+ * @summary Creates an event source.
15463
+ *
15464
+ * @description You can call this operation to create an event source.
15465
+ *
15466
+ * @param request CreateEventSourceRequest
15467
+ * @return CreateEventSourceResponse
14941
15468
  */
14942
15469
  async createEventSource(request: CreateEventSourceRequest): Promise<CreateEventSourceResponse> {
14943
15470
  let runtime = new $Util.RuntimeOptions({ });
@@ -14945,11 +15472,13 @@ export default class Client extends OpenApi {
14945
15472
  }
14946
15473
 
14947
15474
  /**
14948
- * You can call this API operation to create an event stream.
14949
- *
14950
- * @param tmpReq CreateEventStreamingRequest
14951
- * @param runtime runtime options for this request RuntimeOptions
14952
- * @return CreateEventStreamingResponse
15475
+ * @summary Creates an event stream.
15476
+ *
15477
+ * @description You can call this API operation to create an event stream.
15478
+ *
15479
+ * @param tmpReq CreateEventStreamingRequest
15480
+ * @param runtime runtime options for this request RuntimeOptions
15481
+ * @return CreateEventStreamingResponse
14953
15482
  */
14954
15483
  async createEventStreamingWithOptions(tmpReq: CreateEventStreamingRequest, runtime: $Util.RuntimeOptions): Promise<CreateEventStreamingResponse> {
14955
15484
  Util.validateModel(tmpReq);
@@ -15018,10 +15547,12 @@ export default class Client extends OpenApi {
15018
15547
  }
15019
15548
 
15020
15549
  /**
15021
- * You can call this API operation to create an event stream.
15022
- *
15023
- * @param request CreateEventStreamingRequest
15024
- * @return CreateEventStreamingResponse
15550
+ * @summary Creates an event stream.
15551
+ *
15552
+ * @description You can call this API operation to create an event stream.
15553
+ *
15554
+ * @param request CreateEventStreamingRequest
15555
+ * @return CreateEventStreamingResponse
15025
15556
  */
15026
15557
  async createEventStreaming(request: CreateEventStreamingRequest): Promise<CreateEventStreamingResponse> {
15027
15558
  let runtime = new $Util.RuntimeOptions({ });
@@ -15029,11 +15560,13 @@ export default class Client extends OpenApi {
15029
15560
  }
15030
15561
 
15031
15562
  /**
15032
- * You can call this API operation to create an event rule.
15033
- *
15034
- * @param tmpReq CreateRuleRequest
15035
- * @param runtime runtime options for this request RuntimeOptions
15036
- * @return CreateRuleResponse
15563
+ * @summary Creates an event rule.
15564
+ *
15565
+ * @description You can call this API operation to create an event rule.
15566
+ *
15567
+ * @param tmpReq CreateRuleRequest
15568
+ * @param runtime runtime options for this request RuntimeOptions
15569
+ * @return CreateRuleResponse
15037
15570
  */
15038
15571
  async createRuleWithOptions(tmpReq: CreateRuleRequest, runtime: $Util.RuntimeOptions): Promise<CreateRuleResponse> {
15039
15572
  Util.validateModel(tmpReq);
@@ -15086,10 +15619,12 @@ export default class Client extends OpenApi {
15086
15619
  }
15087
15620
 
15088
15621
  /**
15089
- * You can call this API operation to create an event rule.
15090
- *
15091
- * @param request CreateRuleRequest
15092
- * @return CreateRuleResponse
15622
+ * @summary Creates an event rule.
15623
+ *
15624
+ * @description You can call this API operation to create an event rule.
15625
+ *
15626
+ * @param request CreateRuleRequest
15627
+ * @return CreateRuleResponse
15093
15628
  */
15094
15629
  async createRule(request: CreateRuleRequest): Promise<CreateRuleResponse> {
15095
15630
  let runtime = new $Util.RuntimeOptions({ });
@@ -15097,11 +15632,13 @@ export default class Client extends OpenApi {
15097
15632
  }
15098
15633
 
15099
15634
  /**
15100
- * You can call this API operation to create a service-linked role for your cloud service.
15101
- *
15102
- * @param request CreateServiceLinkedRoleForProductRequest
15103
- * @param runtime runtime options for this request RuntimeOptions
15104
- * @return CreateServiceLinkedRoleForProductResponse
15635
+ * @summary Creates a service-linked role for your cloud service.
15636
+ *
15637
+ * @description You can call this API operation to create a service-linked role for your cloud service.
15638
+ *
15639
+ * @param request CreateServiceLinkedRoleForProductRequest
15640
+ * @param runtime runtime options for this request RuntimeOptions
15641
+ * @return CreateServiceLinkedRoleForProductResponse
15105
15642
  */
15106
15643
  async createServiceLinkedRoleForProductWithOptions(request: CreateServiceLinkedRoleForProductRequest, runtime: $Util.RuntimeOptions): Promise<CreateServiceLinkedRoleForProductResponse> {
15107
15644
  Util.validateModel(request);
@@ -15128,10 +15665,12 @@ export default class Client extends OpenApi {
15128
15665
  }
15129
15666
 
15130
15667
  /**
15131
- * You can call this API operation to create a service-linked role for your cloud service.
15132
- *
15133
- * @param request CreateServiceLinkedRoleForProductRequest
15134
- * @return CreateServiceLinkedRoleForProductResponse
15668
+ * @summary Creates a service-linked role for your cloud service.
15669
+ *
15670
+ * @description You can call this API operation to create a service-linked role for your cloud service.
15671
+ *
15672
+ * @param request CreateServiceLinkedRoleForProductRequest
15673
+ * @return CreateServiceLinkedRoleForProductResponse
15135
15674
  */
15136
15675
  async createServiceLinkedRoleForProduct(request: CreateServiceLinkedRoleForProductRequest): Promise<CreateServiceLinkedRoleForProductResponse> {
15137
15676
  let runtime = new $Util.RuntimeOptions({ });
@@ -15139,11 +15678,13 @@ export default class Client extends OpenApi {
15139
15678
  }
15140
15679
 
15141
15680
  /**
15142
- * You can call this API operation to delete an API destination.
15143
- *
15144
- * @param request DeleteApiDestinationRequest
15145
- * @param runtime runtime options for this request RuntimeOptions
15146
- * @return DeleteApiDestinationResponse
15681
+ * @summary Deletes an API destination.
15682
+ *
15683
+ * @description You can call this API operation to delete an API destination.
15684
+ *
15685
+ * @param request DeleteApiDestinationRequest
15686
+ * @param runtime runtime options for this request RuntimeOptions
15687
+ * @return DeleteApiDestinationResponse
15147
15688
  */
15148
15689
  async deleteApiDestinationWithOptions(request: DeleteApiDestinationRequest, runtime: $Util.RuntimeOptions): Promise<DeleteApiDestinationResponse> {
15149
15690
  Util.validateModel(request);
@@ -15170,10 +15711,12 @@ export default class Client extends OpenApi {
15170
15711
  }
15171
15712
 
15172
15713
  /**
15173
- * You can call this API operation to delete an API destination.
15174
- *
15175
- * @param request DeleteApiDestinationRequest
15176
- * @return DeleteApiDestinationResponse
15714
+ * @summary Deletes an API destination.
15715
+ *
15716
+ * @description You can call this API operation to delete an API destination.
15717
+ *
15718
+ * @param request DeleteApiDestinationRequest
15719
+ * @return DeleteApiDestinationResponse
15177
15720
  */
15178
15721
  async deleteApiDestination(request: DeleteApiDestinationRequest): Promise<DeleteApiDestinationResponse> {
15179
15722
  let runtime = new $Util.RuntimeOptions({ });
@@ -15181,11 +15724,13 @@ export default class Client extends OpenApi {
15181
15724
  }
15182
15725
 
15183
15726
  /**
15184
- * You can call this API operation to delete a connection.
15185
- *
15186
- * @param request DeleteConnectionRequest
15187
- * @param runtime runtime options for this request RuntimeOptions
15188
- * @return DeleteConnectionResponse
15727
+ * @summary Deletes a connection.
15728
+ *
15729
+ * @description You can call this API operation to delete a connection.
15730
+ *
15731
+ * @param request DeleteConnectionRequest
15732
+ * @param runtime runtime options for this request RuntimeOptions
15733
+ * @return DeleteConnectionResponse
15189
15734
  */
15190
15735
  async deleteConnectionWithOptions(request: DeleteConnectionRequest, runtime: $Util.RuntimeOptions): Promise<DeleteConnectionResponse> {
15191
15736
  Util.validateModel(request);
@@ -15212,10 +15757,12 @@ export default class Client extends OpenApi {
15212
15757
  }
15213
15758
 
15214
15759
  /**
15215
- * You can call this API operation to delete a connection.
15216
- *
15217
- * @param request DeleteConnectionRequest
15218
- * @return DeleteConnectionResponse
15760
+ * @summary Deletes a connection.
15761
+ *
15762
+ * @description You can call this API operation to delete a connection.
15763
+ *
15764
+ * @param request DeleteConnectionRequest
15765
+ * @return DeleteConnectionResponse
15219
15766
  */
15220
15767
  async deleteConnection(request: DeleteConnectionRequest): Promise<DeleteConnectionResponse> {
15221
15768
  let runtime = new $Util.RuntimeOptions({ });
@@ -15223,11 +15770,13 @@ export default class Client extends OpenApi {
15223
15770
  }
15224
15771
 
15225
15772
  /**
15226
- * You can call this API operation to delete an event bus.
15227
- *
15228
- * @param request DeleteEventBusRequest
15229
- * @param runtime runtime options for this request RuntimeOptions
15230
- * @return DeleteEventBusResponse
15773
+ * @summary Deletes an event bus.
15774
+ *
15775
+ * @description You can call this API operation to delete an event bus.
15776
+ *
15777
+ * @param request DeleteEventBusRequest
15778
+ * @param runtime runtime options for this request RuntimeOptions
15779
+ * @return DeleteEventBusResponse
15231
15780
  */
15232
15781
  async deleteEventBusWithOptions(request: DeleteEventBusRequest, runtime: $Util.RuntimeOptions): Promise<DeleteEventBusResponse> {
15233
15782
  Util.validateModel(request);
@@ -15254,10 +15803,12 @@ export default class Client extends OpenApi {
15254
15803
  }
15255
15804
 
15256
15805
  /**
15257
- * You can call this API operation to delete an event bus.
15258
- *
15259
- * @param request DeleteEventBusRequest
15260
- * @return DeleteEventBusResponse
15806
+ * @summary Deletes an event bus.
15807
+ *
15808
+ * @description You can call this API operation to delete an event bus.
15809
+ *
15810
+ * @param request DeleteEventBusRequest
15811
+ * @return DeleteEventBusResponse
15261
15812
  */
15262
15813
  async deleteEventBus(request: DeleteEventBusRequest): Promise<DeleteEventBusResponse> {
15263
15814
  let runtime = new $Util.RuntimeOptions({ });
@@ -15265,11 +15816,13 @@ export default class Client extends OpenApi {
15265
15816
  }
15266
15817
 
15267
15818
  /**
15268
- * You can call this API operation to delete an event source.
15269
- *
15270
- * @param request DeleteEventSourceRequest
15271
- * @param runtime runtime options for this request RuntimeOptions
15272
- * @return DeleteEventSourceResponse
15819
+ * @summary Deletes an event source.
15820
+ *
15821
+ * @description You can call this API operation to delete an event source.
15822
+ *
15823
+ * @param request DeleteEventSourceRequest
15824
+ * @param runtime runtime options for this request RuntimeOptions
15825
+ * @return DeleteEventSourceResponse
15273
15826
  */
15274
15827
  async deleteEventSourceWithOptions(request: DeleteEventSourceRequest, runtime: $Util.RuntimeOptions): Promise<DeleteEventSourceResponse> {
15275
15828
  Util.validateModel(request);
@@ -15300,10 +15853,12 @@ export default class Client extends OpenApi {
15300
15853
  }
15301
15854
 
15302
15855
  /**
15303
- * You can call this API operation to delete an event source.
15304
- *
15305
- * @param request DeleteEventSourceRequest
15306
- * @return DeleteEventSourceResponse
15856
+ * @summary Deletes an event source.
15857
+ *
15858
+ * @description You can call this API operation to delete an event source.
15859
+ *
15860
+ * @param request DeleteEventSourceRequest
15861
+ * @return DeleteEventSourceResponse
15307
15862
  */
15308
15863
  async deleteEventSource(request: DeleteEventSourceRequest): Promise<DeleteEventSourceResponse> {
15309
15864
  let runtime = new $Util.RuntimeOptions({ });
@@ -15311,11 +15866,13 @@ export default class Client extends OpenApi {
15311
15866
  }
15312
15867
 
15313
15868
  /**
15314
- * You can call this API operation to delete an event stream.
15315
- *
15316
- * @param request DeleteEventStreamingRequest
15317
- * @param runtime runtime options for this request RuntimeOptions
15318
- * @return DeleteEventStreamingResponse
15869
+ * @summary Deletes an event stream.
15870
+ *
15871
+ * @description You can call this API operation to delete an event stream.
15872
+ *
15873
+ * @param request DeleteEventStreamingRequest
15874
+ * @param runtime runtime options for this request RuntimeOptions
15875
+ * @return DeleteEventStreamingResponse
15319
15876
  */
15320
15877
  async deleteEventStreamingWithOptions(request: DeleteEventStreamingRequest, runtime: $Util.RuntimeOptions): Promise<DeleteEventStreamingResponse> {
15321
15878
  Util.validateModel(request);
@@ -15342,10 +15899,12 @@ export default class Client extends OpenApi {
15342
15899
  }
15343
15900
 
15344
15901
  /**
15345
- * You can call this API operation to delete an event stream.
15346
- *
15347
- * @param request DeleteEventStreamingRequest
15348
- * @return DeleteEventStreamingResponse
15902
+ * @summary Deletes an event stream.
15903
+ *
15904
+ * @description You can call this API operation to delete an event stream.
15905
+ *
15906
+ * @param request DeleteEventStreamingRequest
15907
+ * @return DeleteEventStreamingResponse
15349
15908
  */
15350
15909
  async deleteEventStreaming(request: DeleteEventStreamingRequest): Promise<DeleteEventStreamingResponse> {
15351
15910
  let runtime = new $Util.RuntimeOptions({ });
@@ -15353,11 +15912,13 @@ export default class Client extends OpenApi {
15353
15912
  }
15354
15913
 
15355
15914
  /**
15356
- * You can call this API operation to delete an event rule.
15357
- *
15358
- * @param request DeleteRuleRequest
15359
- * @param runtime runtime options for this request RuntimeOptions
15360
- * @return DeleteRuleResponse
15915
+ * @summary Deletes an event rule.
15916
+ *
15917
+ * @description You can call this API operation to delete an event rule.
15918
+ *
15919
+ * @param request DeleteRuleRequest
15920
+ * @param runtime runtime options for this request RuntimeOptions
15921
+ * @return DeleteRuleResponse
15361
15922
  */
15362
15923
  async deleteRuleWithOptions(request: DeleteRuleRequest, runtime: $Util.RuntimeOptions): Promise<DeleteRuleResponse> {
15363
15924
  Util.validateModel(request);
@@ -15388,10 +15949,12 @@ export default class Client extends OpenApi {
15388
15949
  }
15389
15950
 
15390
15951
  /**
15391
- * You can call this API operation to delete an event rule.
15392
- *
15393
- * @param request DeleteRuleRequest
15394
- * @return DeleteRuleResponse
15952
+ * @summary Deletes an event rule.
15953
+ *
15954
+ * @description You can call this API operation to delete an event rule.
15955
+ *
15956
+ * @param request DeleteRuleRequest
15957
+ * @return DeleteRuleResponse
15395
15958
  */
15396
15959
  async deleteRule(request: DeleteRuleRequest): Promise<DeleteRuleResponse> {
15397
15960
  let runtime = new $Util.RuntimeOptions({ });
@@ -15399,11 +15962,13 @@ export default class Client extends OpenApi {
15399
15962
  }
15400
15963
 
15401
15964
  /**
15402
- * You can call this API operation to delete one or more event targets of an event rule.
15403
- *
15404
- * @param tmpReq DeleteTargetsRequest
15405
- * @param runtime runtime options for this request RuntimeOptions
15406
- * @return DeleteTargetsResponse
15965
+ * @summary Deletes one or more event targets of an event rule.
15966
+ *
15967
+ * @description You can call this API operation to delete one or more event targets of an event rule.
15968
+ *
15969
+ * @param tmpReq DeleteTargetsRequest
15970
+ * @param runtime runtime options for this request RuntimeOptions
15971
+ * @return DeleteTargetsResponse
15407
15972
  */
15408
15973
  async deleteTargetsWithOptions(tmpReq: DeleteTargetsRequest, runtime: $Util.RuntimeOptions): Promise<DeleteTargetsResponse> {
15409
15974
  Util.validateModel(tmpReq);
@@ -15444,10 +16009,12 @@ export default class Client extends OpenApi {
15444
16009
  }
15445
16010
 
15446
16011
  /**
15447
- * You can call this API operation to delete one or more event targets of an event rule.
15448
- *
15449
- * @param request DeleteTargetsRequest
15450
- * @return DeleteTargetsResponse
16012
+ * @summary Deletes one or more event targets of an event rule.
16013
+ *
16014
+ * @description You can call this API operation to delete one or more event targets of an event rule.
16015
+ *
16016
+ * @param request DeleteTargetsRequest
16017
+ * @return DeleteTargetsResponse
15451
16018
  */
15452
16019
  async deleteTargets(request: DeleteTargetsRequest): Promise<DeleteTargetsResponse> {
15453
16020
  let runtime = new $Util.RuntimeOptions({ });
@@ -15455,11 +16022,13 @@ export default class Client extends OpenApi {
15455
16022
  }
15456
16023
 
15457
16024
  /**
15458
- * You can call this API operation to disable an event rule.
15459
- *
15460
- * @param request DisableRuleRequest
15461
- * @param runtime runtime options for this request RuntimeOptions
15462
- * @return DisableRuleResponse
16025
+ * @summary Disables an event rule.
16026
+ *
16027
+ * @description You can call this API operation to disable an event rule.
16028
+ *
16029
+ * @param request DisableRuleRequest
16030
+ * @param runtime runtime options for this request RuntimeOptions
16031
+ * @return DisableRuleResponse
15463
16032
  */
15464
16033
  async disableRuleWithOptions(request: DisableRuleRequest, runtime: $Util.RuntimeOptions): Promise<DisableRuleResponse> {
15465
16034
  Util.validateModel(request);
@@ -15490,10 +16059,12 @@ export default class Client extends OpenApi {
15490
16059
  }
15491
16060
 
15492
16061
  /**
15493
- * You can call this API operation to disable an event rule.
15494
- *
15495
- * @param request DisableRuleRequest
15496
- * @return DisableRuleResponse
16062
+ * @summary Disables an event rule.
16063
+ *
16064
+ * @description You can call this API operation to disable an event rule.
16065
+ *
16066
+ * @param request DisableRuleRequest
16067
+ * @return DisableRuleResponse
15497
16068
  */
15498
16069
  async disableRule(request: DisableRuleRequest): Promise<DisableRuleResponse> {
15499
16070
  let runtime = new $Util.RuntimeOptions({ });
@@ -15501,11 +16072,13 @@ export default class Client extends OpenApi {
15501
16072
  }
15502
16073
 
15503
16074
  /**
15504
- * You can call this API operation to enable an event rule.
15505
- *
15506
- * @param request EnableRuleRequest
15507
- * @param runtime runtime options for this request RuntimeOptions
15508
- * @return EnableRuleResponse
16075
+ * @summary Enables an event rule.
16076
+ *
16077
+ * @description You can call this API operation to enable an event rule.
16078
+ *
16079
+ * @param request EnableRuleRequest
16080
+ * @param runtime runtime options for this request RuntimeOptions
16081
+ * @return EnableRuleResponse
15509
16082
  */
15510
16083
  async enableRuleWithOptions(request: EnableRuleRequest, runtime: $Util.RuntimeOptions): Promise<EnableRuleResponse> {
15511
16084
  Util.validateModel(request);
@@ -15536,10 +16109,12 @@ export default class Client extends OpenApi {
15536
16109
  }
15537
16110
 
15538
16111
  /**
15539
- * You can call this API operation to enable an event rule.
15540
- *
15541
- * @param request EnableRuleRequest
15542
- * @return EnableRuleResponse
16112
+ * @summary Enables an event rule.
16113
+ *
16114
+ * @description You can call this API operation to enable an event rule.
16115
+ *
16116
+ * @param request EnableRuleRequest
16117
+ * @return EnableRuleResponse
15543
16118
  */
15544
16119
  async enableRule(request: EnableRuleRequest): Promise<EnableRuleResponse> {
15545
16120
  let runtime = new $Util.RuntimeOptions({ });
@@ -15547,11 +16122,174 @@ export default class Client extends OpenApi {
15547
16122
  }
15548
16123
 
15549
16124
  /**
15550
- * You can call this API operation to query the information about an API destination.
15551
- *
15552
- * @param request GetApiDestinationRequest
15553
- * @param runtime runtime options for this request RuntimeOptions
15554
- * @return GetApiDestinationResponse
16125
+ * @summary EventCenterCheckEnabledOnDefaultBus
16126
+ *
16127
+ * @param request EventCenterCheckEnabledOnDefaultBusRequest
16128
+ * @param runtime runtime options for this request RuntimeOptions
16129
+ * @return EventCenterCheckEnabledOnDefaultBusResponse
16130
+ */
16131
+ async eventCenterCheckEnabledOnDefaultBusWithOptions(runtime: $Util.RuntimeOptions): Promise<EventCenterCheckEnabledOnDefaultBusResponse> {
16132
+ let req = new $OpenApi.OpenApiRequest({ });
16133
+ let params = new $OpenApi.Params({
16134
+ action: "EventCenterCheckEnabledOnDefaultBus",
16135
+ version: "2020-04-01",
16136
+ protocol: "HTTPS",
16137
+ pathname: "/",
16138
+ method: "POST",
16139
+ authType: "AK",
16140
+ style: "RPC",
16141
+ reqBodyType: "formData",
16142
+ bodyType: "json",
16143
+ });
16144
+ return $tea.cast<EventCenterCheckEnabledOnDefaultBusResponse>(await this.callApi(params, req, runtime), new EventCenterCheckEnabledOnDefaultBusResponse({}));
16145
+ }
16146
+
16147
+ /**
16148
+ * @summary EventCenterCheckEnabledOnDefaultBus
16149
+ *
16150
+ * @return EventCenterCheckEnabledOnDefaultBusResponse
16151
+ */
16152
+ async eventCenterCheckEnabledOnDefaultBus(): Promise<EventCenterCheckEnabledOnDefaultBusResponse> {
16153
+ let runtime = new $Util.RuntimeOptions({ });
16154
+ return await this.eventCenterCheckEnabledOnDefaultBusWithOptions(runtime);
16155
+ }
16156
+
16157
+ /**
16158
+ * @summary EventCenterDisableOnDefaultBus
16159
+ *
16160
+ * @param request EventCenterDisableOnDefaultBusRequest
16161
+ * @param runtime runtime options for this request RuntimeOptions
16162
+ * @return EventCenterDisableOnDefaultBusResponse
16163
+ */
16164
+ async eventCenterDisableOnDefaultBusWithOptions(runtime: $Util.RuntimeOptions): Promise<EventCenterDisableOnDefaultBusResponse> {
16165
+ let req = new $OpenApi.OpenApiRequest({ });
16166
+ let params = new $OpenApi.Params({
16167
+ action: "EventCenterDisableOnDefaultBus",
16168
+ version: "2020-04-01",
16169
+ protocol: "HTTPS",
16170
+ pathname: "/",
16171
+ method: "POST",
16172
+ authType: "AK",
16173
+ style: "RPC",
16174
+ reqBodyType: "formData",
16175
+ bodyType: "json",
16176
+ });
16177
+ return $tea.cast<EventCenterDisableOnDefaultBusResponse>(await this.callApi(params, req, runtime), new EventCenterDisableOnDefaultBusResponse({}));
16178
+ }
16179
+
16180
+ /**
16181
+ * @summary EventCenterDisableOnDefaultBus
16182
+ *
16183
+ * @return EventCenterDisableOnDefaultBusResponse
16184
+ */
16185
+ async eventCenterDisableOnDefaultBus(): Promise<EventCenterDisableOnDefaultBusResponse> {
16186
+ let runtime = new $Util.RuntimeOptions({ });
16187
+ return await this.eventCenterDisableOnDefaultBusWithOptions(runtime);
16188
+ }
16189
+
16190
+ /**
16191
+ * @summary EventCenterEnableOnDefaultBus
16192
+ *
16193
+ * @param request EventCenterEnableOnDefaultBusRequest
16194
+ * @param runtime runtime options for this request RuntimeOptions
16195
+ * @return EventCenterEnableOnDefaultBusResponse
16196
+ */
16197
+ async eventCenterEnableOnDefaultBusWithOptions(runtime: $Util.RuntimeOptions): Promise<EventCenterEnableOnDefaultBusResponse> {
16198
+ let req = new $OpenApi.OpenApiRequest({ });
16199
+ let params = new $OpenApi.Params({
16200
+ action: "EventCenterEnableOnDefaultBus",
16201
+ version: "2020-04-01",
16202
+ protocol: "HTTPS",
16203
+ pathname: "/",
16204
+ method: "POST",
16205
+ authType: "AK",
16206
+ style: "RPC",
16207
+ reqBodyType: "formData",
16208
+ bodyType: "json",
16209
+ });
16210
+ return $tea.cast<EventCenterEnableOnDefaultBusResponse>(await this.callApi(params, req, runtime), new EventCenterEnableOnDefaultBusResponse({}));
16211
+ }
16212
+
16213
+ /**
16214
+ * @summary EventCenterEnableOnDefaultBus
16215
+ *
16216
+ * @return EventCenterEnableOnDefaultBusResponse
16217
+ */
16218
+ async eventCenterEnableOnDefaultBus(): Promise<EventCenterEnableOnDefaultBusResponse> {
16219
+ let runtime = new $Util.RuntimeOptions({ });
16220
+ return await this.eventCenterEnableOnDefaultBusWithOptions(runtime);
16221
+ }
16222
+
16223
+ /**
16224
+ * @summary EventCenterQueryEvents
16225
+ *
16226
+ * @param tmpReq EventCenterQueryEventsRequest
16227
+ * @param runtime runtime options for this request RuntimeOptions
16228
+ * @return EventCenterQueryEventsResponse
16229
+ */
16230
+ async eventCenterQueryEventsWithOptions(tmpReq: EventCenterQueryEventsRequest, runtime: $Util.RuntimeOptions): Promise<EventCenterQueryEventsResponse> {
16231
+ Util.validateModel(tmpReq);
16232
+ let request = new EventCenterQueryEventsShrinkRequest({ });
16233
+ OpenApiUtil.convert(tmpReq, request);
16234
+ if (!Util.isUnset(tmpReq.body)) {
16235
+ request.bodyShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.body, "Body", "json");
16236
+ }
16237
+
16238
+ let query = { };
16239
+ if (!Util.isUnset(request.busName)) {
16240
+ query["BusName"] = request.busName;
16241
+ }
16242
+
16243
+ if (!Util.isUnset(request.maxResults)) {
16244
+ query["MaxResults"] = request.maxResults;
16245
+ }
16246
+
16247
+ if (!Util.isUnset(request.nextToken)) {
16248
+ query["NextToken"] = request.nextToken;
16249
+ }
16250
+
16251
+ let body : {[key: string ]: any} = { };
16252
+ if (!Util.isUnset(request.bodyShrink)) {
16253
+ body["Body"] = request.bodyShrink;
16254
+ }
16255
+
16256
+ let req = new $OpenApi.OpenApiRequest({
16257
+ query: OpenApiUtil.query(query),
16258
+ body: OpenApiUtil.parseToMap(body),
16259
+ });
16260
+ let params = new $OpenApi.Params({
16261
+ action: "EventCenterQueryEvents",
16262
+ version: "2020-04-01",
16263
+ protocol: "HTTPS",
16264
+ pathname: "/",
16265
+ method: "POST",
16266
+ authType: "AK",
16267
+ style: "RPC",
16268
+ reqBodyType: "formData",
16269
+ bodyType: "json",
16270
+ });
16271
+ return $tea.cast<EventCenterQueryEventsResponse>(await this.callApi(params, req, runtime), new EventCenterQueryEventsResponse({}));
16272
+ }
16273
+
16274
+ /**
16275
+ * @summary EventCenterQueryEvents
16276
+ *
16277
+ * @param request EventCenterQueryEventsRequest
16278
+ * @return EventCenterQueryEventsResponse
16279
+ */
16280
+ async eventCenterQueryEvents(request: EventCenterQueryEventsRequest): Promise<EventCenterQueryEventsResponse> {
16281
+ let runtime = new $Util.RuntimeOptions({ });
16282
+ return await this.eventCenterQueryEventsWithOptions(request, runtime);
16283
+ }
16284
+
16285
+ /**
16286
+ * @summary Queries the information about an API destination.
16287
+ *
16288
+ * @description You can call this API operation to query the information about an API destination.
16289
+ *
16290
+ * @param request GetApiDestinationRequest
16291
+ * @param runtime runtime options for this request RuntimeOptions
16292
+ * @return GetApiDestinationResponse
15555
16293
  */
15556
16294
  async getApiDestinationWithOptions(request: GetApiDestinationRequest, runtime: $Util.RuntimeOptions): Promise<GetApiDestinationResponse> {
15557
16295
  Util.validateModel(request);
@@ -15578,10 +16316,12 @@ export default class Client extends OpenApi {
15578
16316
  }
15579
16317
 
15580
16318
  /**
15581
- * You can call this API operation to query the information about an API destination.
15582
- *
15583
- * @param request GetApiDestinationRequest
15584
- * @return GetApiDestinationResponse
16319
+ * @summary Queries the information about an API destination.
16320
+ *
16321
+ * @description You can call this API operation to query the information about an API destination.
16322
+ *
16323
+ * @param request GetApiDestinationRequest
16324
+ * @return GetApiDestinationResponse
15585
16325
  */
15586
16326
  async getApiDestination(request: GetApiDestinationRequest): Promise<GetApiDestinationResponse> {
15587
16327
  let runtime = new $Util.RuntimeOptions({ });
@@ -15589,11 +16329,13 @@ export default class Client extends OpenApi {
15589
16329
  }
15590
16330
 
15591
16331
  /**
15592
- * You can call this API operation to query the configurations of a connection.
15593
- *
15594
- * @param request GetConnectionRequest
15595
- * @param runtime runtime options for this request RuntimeOptions
15596
- * @return GetConnectionResponse
16332
+ * @summary Queries the configurations of a connection.
16333
+ *
16334
+ * @description You can call this API operation to query the configurations of a connection.
16335
+ *
16336
+ * @param request GetConnectionRequest
16337
+ * @param runtime runtime options for this request RuntimeOptions
16338
+ * @return GetConnectionResponse
15597
16339
  */
15598
16340
  async getConnectionWithOptions(request: GetConnectionRequest, runtime: $Util.RuntimeOptions): Promise<GetConnectionResponse> {
15599
16341
  Util.validateModel(request);
@@ -15620,10 +16362,12 @@ export default class Client extends OpenApi {
15620
16362
  }
15621
16363
 
15622
16364
  /**
15623
- * You can call this API operation to query the configurations of a connection.
15624
- *
15625
- * @param request GetConnectionRequest
15626
- * @return GetConnectionResponse
16365
+ * @summary Queries the configurations of a connection.
16366
+ *
16367
+ * @description You can call this API operation to query the configurations of a connection.
16368
+ *
16369
+ * @param request GetConnectionRequest
16370
+ * @return GetConnectionResponse
15627
16371
  */
15628
16372
  async getConnection(request: GetConnectionRequest): Promise<GetConnectionResponse> {
15629
16373
  let runtime = new $Util.RuntimeOptions({ });
@@ -15631,11 +16375,13 @@ export default class Client extends OpenApi {
15631
16375
  }
15632
16376
 
15633
16377
  /**
15634
- * You can call this API operation to query the detailed information about an event bus.
15635
- *
15636
- * @param request GetEventBusRequest
15637
- * @param runtime runtime options for this request RuntimeOptions
15638
- * @return GetEventBusResponse
16378
+ * @summary Queries the detailed information about an event bus.
16379
+ *
16380
+ * @description You can call this API operation to query the detailed information about an event bus.
16381
+ *
16382
+ * @param request GetEventBusRequest
16383
+ * @param runtime runtime options for this request RuntimeOptions
16384
+ * @return GetEventBusResponse
15639
16385
  */
15640
16386
  async getEventBusWithOptions(request: GetEventBusRequest, runtime: $Util.RuntimeOptions): Promise<GetEventBusResponse> {
15641
16387
  Util.validateModel(request);
@@ -15662,10 +16408,12 @@ export default class Client extends OpenApi {
15662
16408
  }
15663
16409
 
15664
16410
  /**
15665
- * You can call this API operation to query the detailed information about an event bus.
15666
- *
15667
- * @param request GetEventBusRequest
15668
- * @return GetEventBusResponse
16411
+ * @summary Queries the detailed information about an event bus.
16412
+ *
16413
+ * @description You can call this API operation to query the detailed information about an event bus.
16414
+ *
16415
+ * @param request GetEventBusRequest
16416
+ * @return GetEventBusResponse
15669
16417
  */
15670
16418
  async getEventBus(request: GetEventBusRequest): Promise<GetEventBusResponse> {
15671
16419
  let runtime = new $Util.RuntimeOptions({ });
@@ -15673,11 +16421,13 @@ export default class Client extends OpenApi {
15673
16421
  }
15674
16422
 
15675
16423
  /**
15676
- * You can call this API operation to query the details of an event stream.
15677
- *
15678
- * @param request GetEventStreamingRequest
15679
- * @param runtime runtime options for this request RuntimeOptions
15680
- * @return GetEventStreamingResponse
16424
+ * @summary Queries the details of an event stream.
16425
+ *
16426
+ * @description You can call this API operation to query the details of an event stream.
16427
+ *
16428
+ * @param request GetEventStreamingRequest
16429
+ * @param runtime runtime options for this request RuntimeOptions
16430
+ * @return GetEventStreamingResponse
15681
16431
  */
15682
16432
  async getEventStreamingWithOptions(request: GetEventStreamingRequest, runtime: $Util.RuntimeOptions): Promise<GetEventStreamingResponse> {
15683
16433
  Util.validateModel(request);
@@ -15704,10 +16454,12 @@ export default class Client extends OpenApi {
15704
16454
  }
15705
16455
 
15706
16456
  /**
15707
- * You can call this API operation to query the details of an event stream.
15708
- *
15709
- * @param request GetEventStreamingRequest
15710
- * @return GetEventStreamingResponse
16457
+ * @summary Queries the details of an event stream.
16458
+ *
16459
+ * @description You can call this API operation to query the details of an event stream.
16460
+ *
16461
+ * @param request GetEventStreamingRequest
16462
+ * @return GetEventStreamingResponse
15711
16463
  */
15712
16464
  async getEventStreaming(request: GetEventStreamingRequest): Promise<GetEventStreamingResponse> {
15713
16465
  let runtime = new $Util.RuntimeOptions({ });
@@ -15715,11 +16467,13 @@ export default class Client extends OpenApi {
15715
16467
  }
15716
16468
 
15717
16469
  /**
15718
- * You can call this API operation to query the details of an event rule.
15719
- *
15720
- * @param request GetRuleRequest
15721
- * @param runtime runtime options for this request RuntimeOptions
15722
- * @return GetRuleResponse
16470
+ * @summary Queries the details of an event rule.
16471
+ *
16472
+ * @description You can call this API operation to query the details of an event rule.
16473
+ *
16474
+ * @param request GetRuleRequest
16475
+ * @param runtime runtime options for this request RuntimeOptions
16476
+ * @return GetRuleResponse
15723
16477
  */
15724
16478
  async getRuleWithOptions(request: GetRuleRequest, runtime: $Util.RuntimeOptions): Promise<GetRuleResponse> {
15725
16479
  Util.validateModel(request);
@@ -15750,10 +16504,12 @@ export default class Client extends OpenApi {
15750
16504
  }
15751
16505
 
15752
16506
  /**
15753
- * You can call this API operation to query the details of an event rule.
15754
- *
15755
- * @param request GetRuleRequest
15756
- * @return GetRuleResponse
16507
+ * @summary Queries the details of an event rule.
16508
+ *
16509
+ * @description You can call this API operation to query the details of an event rule.
16510
+ *
16511
+ * @param request GetRuleRequest
16512
+ * @return GetRuleResponse
15757
16513
  */
15758
16514
  async getRule(request: GetRuleRequest): Promise<GetRuleResponse> {
15759
16515
  let runtime = new $Util.RuntimeOptions({ });
@@ -15761,11 +16517,13 @@ export default class Client extends OpenApi {
15761
16517
  }
15762
16518
 
15763
16519
  /**
15764
- * You can call this API operation to query all Alibaba Cloud service event sources.
15765
- *
15766
- * @param request ListAliyunOfficialEventSourcesRequest
15767
- * @param runtime runtime options for this request RuntimeOptions
15768
- * @return ListAliyunOfficialEventSourcesResponse
16520
+ * @summary Queries all Alibaba Cloud service event sources.
16521
+ *
16522
+ * @description You can call this API operation to query all Alibaba Cloud service event sources.
16523
+ *
16524
+ * @param request ListAliyunOfficialEventSourcesRequest
16525
+ * @param runtime runtime options for this request RuntimeOptions
16526
+ * @return ListAliyunOfficialEventSourcesResponse
15769
16527
  */
15770
16528
  async listAliyunOfficialEventSourcesWithOptions(runtime: $Util.RuntimeOptions): Promise<ListAliyunOfficialEventSourcesResponse> {
15771
16529
  let req = new $OpenApi.OpenApiRequest({ });
@@ -15784,9 +16542,11 @@ export default class Client extends OpenApi {
15784
16542
  }
15785
16543
 
15786
16544
  /**
15787
- * You can call this API operation to query all Alibaba Cloud service event sources.
15788
- *
15789
- * @return ListAliyunOfficialEventSourcesResponse
16545
+ * @summary Queries all Alibaba Cloud service event sources.
16546
+ *
16547
+ * @description You can call this API operation to query all Alibaba Cloud service event sources.
16548
+ *
16549
+ * @return ListAliyunOfficialEventSourcesResponse
15790
16550
  */
15791
16551
  async listAliyunOfficialEventSources(): Promise<ListAliyunOfficialEventSourcesResponse> {
15792
16552
  let runtime = new $Util.RuntimeOptions({ });
@@ -15794,11 +16554,13 @@ export default class Client extends OpenApi {
15794
16554
  }
15795
16555
 
15796
16556
  /**
15797
- * You can use this API operation to query a list of API destinations.
15798
- *
15799
- * @param request ListApiDestinationsRequest
15800
- * @param runtime runtime options for this request RuntimeOptions
15801
- * @return ListApiDestinationsResponse
16557
+ * @summary Queries a list of API destinations.
16558
+ *
16559
+ * @description You can use this API operation to query a list of API destinations.
16560
+ *
16561
+ * @param request ListApiDestinationsRequest
16562
+ * @param runtime runtime options for this request RuntimeOptions
16563
+ * @return ListApiDestinationsResponse
15802
16564
  */
15803
16565
  async listApiDestinationsWithOptions(request: ListApiDestinationsRequest, runtime: $Util.RuntimeOptions): Promise<ListApiDestinationsResponse> {
15804
16566
  Util.validateModel(request);
@@ -15837,10 +16599,12 @@ export default class Client extends OpenApi {
15837
16599
  }
15838
16600
 
15839
16601
  /**
15840
- * You can use this API operation to query a list of API destinations.
15841
- *
15842
- * @param request ListApiDestinationsRequest
15843
- * @return ListApiDestinationsResponse
16602
+ * @summary Queries a list of API destinations.
16603
+ *
16604
+ * @description You can use this API operation to query a list of API destinations.
16605
+ *
16606
+ * @param request ListApiDestinationsRequest
16607
+ * @return ListApiDestinationsResponse
15844
16608
  */
15845
16609
  async listApiDestinations(request: ListApiDestinationsRequest): Promise<ListApiDestinationsResponse> {
15846
16610
  let runtime = new $Util.RuntimeOptions({ });
@@ -15848,11 +16612,13 @@ export default class Client extends OpenApi {
15848
16612
  }
15849
16613
 
15850
16614
  /**
15851
- * You can call this API operation to query connections.
15852
- *
15853
- * @param request ListConnectionsRequest
15854
- * @param runtime runtime options for this request RuntimeOptions
15855
- * @return ListConnectionsResponse
16615
+ * @summary Queries connections.
16616
+ *
16617
+ * @description You can call this API operation to query connections.
16618
+ *
16619
+ * @param request ListConnectionsRequest
16620
+ * @param runtime runtime options for this request RuntimeOptions
16621
+ * @return ListConnectionsResponse
15856
16622
  */
15857
16623
  async listConnectionsWithOptions(request: ListConnectionsRequest, runtime: $Util.RuntimeOptions): Promise<ListConnectionsResponse> {
15858
16624
  Util.validateModel(request);
@@ -15887,10 +16653,12 @@ export default class Client extends OpenApi {
15887
16653
  }
15888
16654
 
15889
16655
  /**
15890
- * You can call this API operation to query connections.
15891
- *
15892
- * @param request ListConnectionsRequest
15893
- * @return ListConnectionsResponse
16656
+ * @summary Queries connections.
16657
+ *
16658
+ * @description You can call this API operation to query connections.
16659
+ *
16660
+ * @param request ListConnectionsRequest
16661
+ * @return ListConnectionsResponse
15894
16662
  */
15895
16663
  async listConnections(request: ListConnectionsRequest): Promise<ListConnectionsResponse> {
15896
16664
  let runtime = new $Util.RuntimeOptions({ });
@@ -15898,11 +16666,13 @@ export default class Client extends OpenApi {
15898
16666
  }
15899
16667
 
15900
16668
  /**
15901
- * You can call this API operation to query all event buses.
15902
- *
15903
- * @param request ListEventBusesRequest
15904
- * @param runtime runtime options for this request RuntimeOptions
15905
- * @return ListEventBusesResponse
16669
+ * @summary Queries all event buses.
16670
+ *
16671
+ * @description You can call this API operation to query all event buses.
16672
+ *
16673
+ * @param request ListEventBusesRequest
16674
+ * @param runtime runtime options for this request RuntimeOptions
16675
+ * @return ListEventBusesResponse
15906
16676
  */
15907
16677
  async listEventBusesWithOptions(request: ListEventBusesRequest, runtime: $Util.RuntimeOptions): Promise<ListEventBusesResponse> {
15908
16678
  Util.validateModel(request);
@@ -15937,10 +16707,12 @@ export default class Client extends OpenApi {
15937
16707
  }
15938
16708
 
15939
16709
  /**
15940
- * You can call this API operation to query all event buses.
15941
- *
15942
- * @param request ListEventBusesRequest
15943
- * @return ListEventBusesResponse
16710
+ * @summary Queries all event buses.
16711
+ *
16712
+ * @description You can call this API operation to query all event buses.
16713
+ *
16714
+ * @param request ListEventBusesRequest
16715
+ * @return ListEventBusesResponse
15944
16716
  */
15945
16717
  async listEventBuses(request: ListEventBusesRequest): Promise<ListEventBusesResponse> {
15946
16718
  let runtime = new $Util.RuntimeOptions({ });
@@ -15948,11 +16720,13 @@ export default class Client extends OpenApi {
15948
16720
  }
15949
16721
 
15950
16722
  /**
15951
- * You can call this API operation to query event streams.
15952
- *
15953
- * @param request ListEventStreamingsRequest
15954
- * @param runtime runtime options for this request RuntimeOptions
15955
- * @return ListEventStreamingsResponse
16723
+ * @summary Queries event streams.
16724
+ *
16725
+ * @description You can call this API operation to query event streams.
16726
+ *
16727
+ * @param request ListEventStreamingsRequest
16728
+ * @param runtime runtime options for this request RuntimeOptions
16729
+ * @return ListEventStreamingsResponse
15956
16730
  */
15957
16731
  async listEventStreamingsWithOptions(request: ListEventStreamingsRequest, runtime: $Util.RuntimeOptions): Promise<ListEventStreamingsResponse> {
15958
16732
  Util.validateModel(request);
@@ -15995,10 +16769,12 @@ export default class Client extends OpenApi {
15995
16769
  }
15996
16770
 
15997
16771
  /**
15998
- * You can call this API operation to query event streams.
15999
- *
16000
- * @param request ListEventStreamingsRequest
16001
- * @return ListEventStreamingsResponse
16772
+ * @summary Queries event streams.
16773
+ *
16774
+ * @description You can call this API operation to query event streams.
16775
+ *
16776
+ * @param request ListEventStreamingsRequest
16777
+ * @return ListEventStreamingsResponse
16002
16778
  */
16003
16779
  async listEventStreamings(request: ListEventStreamingsRequest): Promise<ListEventStreamingsResponse> {
16004
16780
  let runtime = new $Util.RuntimeOptions({ });
@@ -16006,11 +16782,13 @@ export default class Client extends OpenApi {
16006
16782
  }
16007
16783
 
16008
16784
  /**
16009
- * You can call this API operation to query all rules of an event bus.
16010
- *
16011
- * @param request ListRulesRequest
16012
- * @param runtime runtime options for this request RuntimeOptions
16013
- * @return ListRulesResponse
16785
+ * @summary Queries all rules of an event bus.
16786
+ *
16787
+ * @description You can call this API operation to query all rules of an event bus.
16788
+ *
16789
+ * @param request ListRulesRequest
16790
+ * @param runtime runtime options for this request RuntimeOptions
16791
+ * @return ListRulesResponse
16014
16792
  */
16015
16793
  async listRulesWithOptions(request: ListRulesRequest, runtime: $Util.RuntimeOptions): Promise<ListRulesResponse> {
16016
16794
  Util.validateModel(request);
@@ -16049,16 +16827,25 @@ export default class Client extends OpenApi {
16049
16827
  }
16050
16828
 
16051
16829
  /**
16052
- * You can call this API operation to query all rules of an event bus.
16053
- *
16054
- * @param request ListRulesRequest
16055
- * @return ListRulesResponse
16830
+ * @summary Queries all rules of an event bus.
16831
+ *
16832
+ * @description You can call this API operation to query all rules of an event bus.
16833
+ *
16834
+ * @param request ListRulesRequest
16835
+ * @return ListRulesResponse
16056
16836
  */
16057
16837
  async listRules(request: ListRulesRequest): Promise<ListRulesResponse> {
16058
16838
  let runtime = new $Util.RuntimeOptions({ });
16059
16839
  return await this.listRulesWithOptions(request, runtime);
16060
16840
  }
16061
16841
 
16842
+ /**
16843
+ * @summary Queries all event targets of an event rule.
16844
+ *
16845
+ * @param request ListTargetsRequest
16846
+ * @param runtime runtime options for this request RuntimeOptions
16847
+ * @return ListTargetsResponse
16848
+ */
16062
16849
  async listTargetsWithOptions(request: ListTargetsRequest, runtime: $Util.RuntimeOptions): Promise<ListTargetsResponse> {
16063
16850
  Util.validateModel(request);
16064
16851
  let query = { };
@@ -16099,17 +16886,25 @@ export default class Client extends OpenApi {
16099
16886
  return $tea.cast<ListTargetsResponse>(await this.callApi(params, req, runtime), new ListTargetsResponse({}));
16100
16887
  }
16101
16888
 
16889
+ /**
16890
+ * @summary Queries all event targets of an event rule.
16891
+ *
16892
+ * @param request ListTargetsRequest
16893
+ * @return ListTargetsResponse
16894
+ */
16102
16895
  async listTargets(request: ListTargetsRequest): Promise<ListTargetsResponse> {
16103
16896
  let runtime = new $Util.RuntimeOptions({ });
16104
16897
  return await this.listTargetsWithOptions(request, runtime);
16105
16898
  }
16106
16899
 
16107
16900
  /**
16108
- * You can call this API operation to query custom event sources.
16109
- *
16110
- * @param request ListUserDefinedEventSourcesRequest
16111
- * @param runtime runtime options for this request RuntimeOptions
16112
- * @return ListUserDefinedEventSourcesResponse
16901
+ * @summary Queries all custom event sources.
16902
+ *
16903
+ * @description You can call this API operation to query custom event sources.
16904
+ *
16905
+ * @param request ListUserDefinedEventSourcesRequest
16906
+ * @param runtime runtime options for this request RuntimeOptions
16907
+ * @return ListUserDefinedEventSourcesResponse
16113
16908
  */
16114
16909
  async listUserDefinedEventSourcesWithOptions(request: ListUserDefinedEventSourcesRequest, runtime: $Util.RuntimeOptions): Promise<ListUserDefinedEventSourcesResponse> {
16115
16910
  Util.validateModel(request);
@@ -16148,10 +16943,12 @@ export default class Client extends OpenApi {
16148
16943
  }
16149
16944
 
16150
16945
  /**
16151
- * You can call this API operation to query custom event sources.
16152
- *
16153
- * @param request ListUserDefinedEventSourcesRequest
16154
- * @return ListUserDefinedEventSourcesResponse
16946
+ * @summary Queries all custom event sources.
16947
+ *
16948
+ * @description You can call this API operation to query custom event sources.
16949
+ *
16950
+ * @param request ListUserDefinedEventSourcesRequest
16951
+ * @return ListUserDefinedEventSourcesResponse
16155
16952
  */
16156
16953
  async listUserDefinedEventSources(request: ListUserDefinedEventSourcesRequest): Promise<ListUserDefinedEventSourcesResponse> {
16157
16954
  let runtime = new $Util.RuntimeOptions({ });
@@ -16159,11 +16956,13 @@ export default class Client extends OpenApi {
16159
16956
  }
16160
16957
 
16161
16958
  /**
16162
- * You can call this API operation to stop an event stream that is running.
16163
- *
16164
- * @param request PauseEventStreamingRequest
16165
- * @param runtime runtime options for this request RuntimeOptions
16166
- * @return PauseEventStreamingResponse
16959
+ * @summary Stops an event stream that is running.
16960
+ *
16961
+ * @description You can call this API operation to stop an event stream that is running.
16962
+ *
16963
+ * @param request PauseEventStreamingRequest
16964
+ * @param runtime runtime options for this request RuntimeOptions
16965
+ * @return PauseEventStreamingResponse
16167
16966
  */
16168
16967
  async pauseEventStreamingWithOptions(request: PauseEventStreamingRequest, runtime: $Util.RuntimeOptions): Promise<PauseEventStreamingResponse> {
16169
16968
  Util.validateModel(request);
@@ -16190,10 +16989,12 @@ export default class Client extends OpenApi {
16190
16989
  }
16191
16990
 
16192
16991
  /**
16193
- * You can call this API operation to stop an event stream that is running.
16194
- *
16195
- * @param request PauseEventStreamingRequest
16196
- * @return PauseEventStreamingResponse
16992
+ * @summary Stops an event stream that is running.
16993
+ *
16994
+ * @description You can call this API operation to stop an event stream that is running.
16995
+ *
16996
+ * @param request PauseEventStreamingRequest
16997
+ * @return PauseEventStreamingResponse
16197
16998
  */
16198
16999
  async pauseEventStreaming(request: PauseEventStreamingRequest): Promise<PauseEventStreamingResponse> {
16199
17000
  let runtime = new $Util.RuntimeOptions({ });
@@ -16201,11 +17002,13 @@ export default class Client extends OpenApi {
16201
17002
  }
16202
17003
 
16203
17004
  /**
16204
- * You can call this API operation to create or update event targets under a rule.
16205
- *
16206
- * @param tmpReq PutTargetsRequest
16207
- * @param runtime runtime options for this request RuntimeOptions
16208
- * @return PutTargetsResponse
17005
+ * @summary Creates or updates event targets under a rule.
17006
+ *
17007
+ * @description You can call this API operation to create or update event targets under a rule.
17008
+ *
17009
+ * @param tmpReq PutTargetsRequest
17010
+ * @param runtime runtime options for this request RuntimeOptions
17011
+ * @return PutTargetsResponse
16209
17012
  */
16210
17013
  async putTargetsWithOptions(tmpReq: PutTargetsRequest, runtime: $Util.RuntimeOptions): Promise<PutTargetsResponse> {
16211
17014
  Util.validateModel(tmpReq);
@@ -16246,10 +17049,12 @@ export default class Client extends OpenApi {
16246
17049
  }
16247
17050
 
16248
17051
  /**
16249
- * You can call this API operation to create or update event targets under a rule.
16250
- *
16251
- * @param request PutTargetsRequest
16252
- * @return PutTargetsResponse
17052
+ * @summary Creates or updates event targets under a rule.
17053
+ *
17054
+ * @description You can call this API operation to create or update event targets under a rule.
17055
+ *
17056
+ * @param request PutTargetsRequest
17057
+ * @return PutTargetsResponse
16253
17058
  */
16254
17059
  async putTargets(request: PutTargetsRequest): Promise<PutTargetsResponse> {
16255
17060
  let runtime = new $Util.RuntimeOptions({ });
@@ -16257,11 +17062,13 @@ export default class Client extends OpenApi {
16257
17062
  }
16258
17063
 
16259
17064
  /**
16260
- * You can call this API operation to query the content of an event.
16261
- *
16262
- * @param request QueryEventRequest
16263
- * @param runtime runtime options for this request RuntimeOptions
16264
- * @return QueryEventResponse
17065
+ * @summary Queries the content of an event.
17066
+ *
17067
+ * @description You can call this API operation to query the content of an event.
17068
+ *
17069
+ * @param request QueryEventRequest
17070
+ * @param runtime runtime options for this request RuntimeOptions
17071
+ * @return QueryEventResponse
16265
17072
  */
16266
17073
  async queryEventWithOptions(request: QueryEventRequest, runtime: $Util.RuntimeOptions): Promise<QueryEventResponse> {
16267
17074
  Util.validateModel(request);
@@ -16296,10 +17103,12 @@ export default class Client extends OpenApi {
16296
17103
  }
16297
17104
 
16298
17105
  /**
16299
- * You can call this API operation to query the content of an event.
16300
- *
16301
- * @param request QueryEventRequest
16302
- * @return QueryEventResponse
17106
+ * @summary Queries the content of an event.
17107
+ *
17108
+ * @description You can call this API operation to query the content of an event.
17109
+ *
17110
+ * @param request QueryEventRequest
17111
+ * @return QueryEventResponse
16303
17112
  */
16304
17113
  async queryEvent(request: QueryEventRequest): Promise<QueryEventResponse> {
16305
17114
  let runtime = new $Util.RuntimeOptions({ });
@@ -16307,11 +17116,13 @@ export default class Client extends OpenApi {
16307
17116
  }
16308
17117
 
16309
17118
  /**
16310
- * You can call this API operation to query event traces.
16311
- *
16312
- * @param request QueryEventTracesRequest
16313
- * @param runtime runtime options for this request RuntimeOptions
16314
- * @return QueryEventTracesResponse
17119
+ * @summary Queries event traces.
17120
+ *
17121
+ * @description You can call this API operation to query event traces.
17122
+ *
17123
+ * @param request QueryEventTracesRequest
17124
+ * @param runtime runtime options for this request RuntimeOptions
17125
+ * @return QueryEventTracesResponse
16315
17126
  */
16316
17127
  async queryEventTracesWithOptions(request: QueryEventTracesRequest, runtime: $Util.RuntimeOptions): Promise<QueryEventTracesResponse> {
16317
17128
  Util.validateModel(request);
@@ -16342,10 +17153,12 @@ export default class Client extends OpenApi {
16342
17153
  }
16343
17154
 
16344
17155
  /**
16345
- * You can call this API operation to query event traces.
16346
- *
16347
- * @param request QueryEventTracesRequest
16348
- * @return QueryEventTracesResponse
17156
+ * @summary Queries event traces.
17157
+ *
17158
+ * @description You can call this API operation to query event traces.
17159
+ *
17160
+ * @param request QueryEventTracesRequest
17161
+ * @return QueryEventTracesResponse
16349
17162
  */
16350
17163
  async queryEventTraces(request: QueryEventTracesRequest): Promise<QueryEventTracesResponse> {
16351
17164
  let runtime = new $Util.RuntimeOptions({ });
@@ -16353,11 +17166,13 @@ export default class Client extends OpenApi {
16353
17166
  }
16354
17167
 
16355
17168
  /**
16356
- * You can call this API operation to query event traces by event ID.
16357
- *
16358
- * @param request QueryTracedEventByEventIdRequest
16359
- * @param runtime runtime options for this request RuntimeOptions
16360
- * @return QueryTracedEventByEventIdResponse
17169
+ * @summary Queries event traces by event ID.
17170
+ *
17171
+ * @description You can call this API operation to query event traces by event ID.
17172
+ *
17173
+ * @param request QueryTracedEventByEventIdRequest
17174
+ * @param runtime runtime options for this request RuntimeOptions
17175
+ * @return QueryTracedEventByEventIdResponse
16361
17176
  */
16362
17177
  async queryTracedEventByEventIdWithOptions(request: QueryTracedEventByEventIdRequest, runtime: $Util.RuntimeOptions): Promise<QueryTracedEventByEventIdResponse> {
16363
17178
  Util.validateModel(request);
@@ -16392,10 +17207,12 @@ export default class Client extends OpenApi {
16392
17207
  }
16393
17208
 
16394
17209
  /**
16395
- * You can call this API operation to query event traces by event ID.
16396
- *
16397
- * @param request QueryTracedEventByEventIdRequest
16398
- * @return QueryTracedEventByEventIdResponse
17210
+ * @summary Queries event traces by event ID.
17211
+ *
17212
+ * @description You can call this API operation to query event traces by event ID.
17213
+ *
17214
+ * @param request QueryTracedEventByEventIdRequest
17215
+ * @return QueryTracedEventByEventIdResponse
16399
17216
  */
16400
17217
  async queryTracedEventByEventId(request: QueryTracedEventByEventIdRequest): Promise<QueryTracedEventByEventIdResponse> {
16401
17218
  let runtime = new $Util.RuntimeOptions({ });
@@ -16403,11 +17220,13 @@ export default class Client extends OpenApi {
16403
17220
  }
16404
17221
 
16405
17222
  /**
16406
- * You can call this API operation to query event traces by time range.
16407
- *
16408
- * @param request QueryTracedEventsRequest
16409
- * @param runtime runtime options for this request RuntimeOptions
16410
- * @return QueryTracedEventsResponse
17223
+ * @summary Queries event traces by time range.
17224
+ *
17225
+ * @description You can call this API operation to query event traces by time range.
17226
+ *
17227
+ * @param request QueryTracedEventsRequest
17228
+ * @param runtime runtime options for this request RuntimeOptions
17229
+ * @return QueryTracedEventsResponse
16411
17230
  */
16412
17231
  async queryTracedEventsWithOptions(request: QueryTracedEventsRequest, runtime: $Util.RuntimeOptions): Promise<QueryTracedEventsResponse> {
16413
17232
  Util.validateModel(request);
@@ -16462,10 +17281,12 @@ export default class Client extends OpenApi {
16462
17281
  }
16463
17282
 
16464
17283
  /**
16465
- * You can call this API operation to query event traces by time range.
16466
- *
16467
- * @param request QueryTracedEventsRequest
16468
- * @return QueryTracedEventsResponse
17284
+ * @summary Queries event traces by time range.
17285
+ *
17286
+ * @description You can call this API operation to query event traces by time range.
17287
+ *
17288
+ * @param request QueryTracedEventsRequest
17289
+ * @return QueryTracedEventsResponse
16469
17290
  */
16470
17291
  async queryTracedEvents(request: QueryTracedEventsRequest): Promise<QueryTracedEventsResponse> {
16471
17292
  let runtime = new $Util.RuntimeOptions({ });
@@ -16473,11 +17294,13 @@ export default class Client extends OpenApi {
16473
17294
  }
16474
17295
 
16475
17296
  /**
16476
- * You can call this API operation to enable a created or deactivated event stream.
16477
- *
16478
- * @param request StartEventStreamingRequest
16479
- * @param runtime runtime options for this request RuntimeOptions
16480
- * @return StartEventStreamingResponse
17297
+ * @summary Enables a created or deactivated event stream.
17298
+ *
17299
+ * @description You can call this API operation to enable a created or deactivated event stream.
17300
+ *
17301
+ * @param request StartEventStreamingRequest
17302
+ * @param runtime runtime options for this request RuntimeOptions
17303
+ * @return StartEventStreamingResponse
16481
17304
  */
16482
17305
  async startEventStreamingWithOptions(request: StartEventStreamingRequest, runtime: $Util.RuntimeOptions): Promise<StartEventStreamingResponse> {
16483
17306
  Util.validateModel(request);
@@ -16504,10 +17327,12 @@ export default class Client extends OpenApi {
16504
17327
  }
16505
17328
 
16506
17329
  /**
16507
- * You can call this API operation to enable a created or deactivated event stream.
16508
- *
16509
- * @param request StartEventStreamingRequest
16510
- * @return StartEventStreamingResponse
17330
+ * @summary Enables a created or deactivated event stream.
17331
+ *
17332
+ * @description You can call this API operation to enable a created or deactivated event stream.
17333
+ *
17334
+ * @param request StartEventStreamingRequest
17335
+ * @return StartEventStreamingResponse
16511
17336
  */
16512
17337
  async startEventStreaming(request: StartEventStreamingRequest): Promise<StartEventStreamingResponse> {
16513
17338
  let runtime = new $Util.RuntimeOptions({ });
@@ -16515,11 +17340,13 @@ export default class Client extends OpenApi {
16515
17340
  }
16516
17341
 
16517
17342
  /**
16518
- * You can call this API operation to check whether the event pattern matches the provided JSON format.
16519
- *
16520
- * @param request TestEventPatternRequest
16521
- * @param runtime runtime options for this request RuntimeOptions
16522
- * @return TestEventPatternResponse
17343
+ * @summary Checks whether the event pattern matches the provided JSON format.
17344
+ *
17345
+ * @description You can call this API operation to check whether the event pattern matches the provided JSON format.
17346
+ *
17347
+ * @param request TestEventPatternRequest
17348
+ * @param runtime runtime options for this request RuntimeOptions
17349
+ * @return TestEventPatternResponse
16523
17350
  */
16524
17351
  async testEventPatternWithOptions(request: TestEventPatternRequest, runtime: $Util.RuntimeOptions): Promise<TestEventPatternResponse> {
16525
17352
  Util.validateModel(request);
@@ -16550,10 +17377,12 @@ export default class Client extends OpenApi {
16550
17377
  }
16551
17378
 
16552
17379
  /**
16553
- * You can call this API operation to check whether the event pattern matches the provided JSON format.
16554
- *
16555
- * @param request TestEventPatternRequest
16556
- * @return TestEventPatternResponse
17380
+ * @summary Checks whether the event pattern matches the provided JSON format.
17381
+ *
17382
+ * @description You can call this API operation to check whether the event pattern matches the provided JSON format.
17383
+ *
17384
+ * @param request TestEventPatternRequest
17385
+ * @return TestEventPatternResponse
16557
17386
  */
16558
17387
  async testEventPattern(request: TestEventPatternRequest): Promise<TestEventPatternResponse> {
16559
17388
  let runtime = new $Util.RuntimeOptions({ });
@@ -16561,11 +17390,13 @@ export default class Client extends OpenApi {
16561
17390
  }
16562
17391
 
16563
17392
  /**
16564
- * You can call this API operation to update an API destination.
16565
- *
16566
- * @param tmpReq UpdateApiDestinationRequest
16567
- * @param runtime runtime options for this request RuntimeOptions
16568
- * @return UpdateApiDestinationResponse
17393
+ * @summary Updates an API destination.
17394
+ *
17395
+ * @description You can call this API operation to update an API destination.
17396
+ *
17397
+ * @param tmpReq UpdateApiDestinationRequest
17398
+ * @param runtime runtime options for this request RuntimeOptions
17399
+ * @return UpdateApiDestinationResponse
16569
17400
  */
16570
17401
  async updateApiDestinationWithOptions(tmpReq: UpdateApiDestinationRequest, runtime: $Util.RuntimeOptions): Promise<UpdateApiDestinationResponse> {
16571
17402
  Util.validateModel(tmpReq);
@@ -16610,10 +17441,12 @@ export default class Client extends OpenApi {
16610
17441
  }
16611
17442
 
16612
17443
  /**
16613
- * You can call this API operation to update an API destination.
16614
- *
16615
- * @param request UpdateApiDestinationRequest
16616
- * @return UpdateApiDestinationResponse
17444
+ * @summary Updates an API destination.
17445
+ *
17446
+ * @description You can call this API operation to update an API destination.
17447
+ *
17448
+ * @param request UpdateApiDestinationRequest
17449
+ * @return UpdateApiDestinationResponse
16617
17450
  */
16618
17451
  async updateApiDestination(request: UpdateApiDestinationRequest): Promise<UpdateApiDestinationResponse> {
16619
17452
  let runtime = new $Util.RuntimeOptions({ });
@@ -16621,11 +17454,13 @@ export default class Client extends OpenApi {
16621
17454
  }
16622
17455
 
16623
17456
  /**
16624
- * You can call this API operation to update a connection.
16625
- *
16626
- * @param tmpReq UpdateConnectionRequest
16627
- * @param runtime runtime options for this request RuntimeOptions
16628
- * @return UpdateConnectionResponse
17457
+ * @summary Updates a connection.
17458
+ *
17459
+ * @description You can call this API operation to update a connection.
17460
+ *
17461
+ * @param tmpReq UpdateConnectionRequest
17462
+ * @param runtime runtime options for this request RuntimeOptions
17463
+ * @return UpdateConnectionResponse
16629
17464
  */
16630
17465
  async updateConnectionWithOptions(tmpReq: UpdateConnectionRequest, runtime: $Util.RuntimeOptions): Promise<UpdateConnectionResponse> {
16631
17466
  Util.validateModel(tmpReq);
@@ -16674,10 +17509,12 @@ export default class Client extends OpenApi {
16674
17509
  }
16675
17510
 
16676
17511
  /**
16677
- * You can call this API operation to update a connection.
16678
- *
16679
- * @param request UpdateConnectionRequest
16680
- * @return UpdateConnectionResponse
17512
+ * @summary Updates a connection.
17513
+ *
17514
+ * @description You can call this API operation to update a connection.
17515
+ *
17516
+ * @param request UpdateConnectionRequest
17517
+ * @return UpdateConnectionResponse
16681
17518
  */
16682
17519
  async updateConnection(request: UpdateConnectionRequest): Promise<UpdateConnectionResponse> {
16683
17520
  let runtime = new $Util.RuntimeOptions({ });
@@ -16685,11 +17522,13 @@ export default class Client extends OpenApi {
16685
17522
  }
16686
17523
 
16687
17524
  /**
16688
- * You can call this API operation to modify an event bus.
16689
- *
16690
- * @param request UpdateEventBusRequest
16691
- * @param runtime runtime options for this request RuntimeOptions
16692
- * @return UpdateEventBusResponse
17525
+ * @summary Modifies an event bus.
17526
+ *
17527
+ * @description You can call this API operation to modify an event bus.
17528
+ *
17529
+ * @param request UpdateEventBusRequest
17530
+ * @param runtime runtime options for this request RuntimeOptions
17531
+ * @return UpdateEventBusResponse
16693
17532
  */
16694
17533
  async updateEventBusWithOptions(request: UpdateEventBusRequest, runtime: $Util.RuntimeOptions): Promise<UpdateEventBusResponse> {
16695
17534
  Util.validateModel(request);
@@ -16720,10 +17559,12 @@ export default class Client extends OpenApi {
16720
17559
  }
16721
17560
 
16722
17561
  /**
16723
- * You can call this API operation to modify an event bus.
16724
- *
16725
- * @param request UpdateEventBusRequest
16726
- * @return UpdateEventBusResponse
17562
+ * @summary Modifies an event bus.
17563
+ *
17564
+ * @description You can call this API operation to modify an event bus.
17565
+ *
17566
+ * @param request UpdateEventBusRequest
17567
+ * @return UpdateEventBusResponse
16727
17568
  */
16728
17569
  async updateEventBus(request: UpdateEventBusRequest): Promise<UpdateEventBusResponse> {
16729
17570
  let runtime = new $Util.RuntimeOptions({ });
@@ -16731,11 +17572,13 @@ export default class Client extends OpenApi {
16731
17572
  }
16732
17573
 
16733
17574
  /**
16734
- * You can call this API operation to update an event source.
16735
- *
16736
- * @param tmpReq UpdateEventSourceRequest
16737
- * @param runtime runtime options for this request RuntimeOptions
16738
- * @return UpdateEventSourceResponse
17575
+ * @summary Updates an event source.
17576
+ *
17577
+ * @description You can call this API operation to update an event source.
17578
+ *
17579
+ * @param tmpReq UpdateEventSourceRequest
17580
+ * @param runtime runtime options for this request RuntimeOptions
17581
+ * @return UpdateEventSourceResponse
16739
17582
  */
16740
17583
  async updateEventSourceWithOptions(tmpReq: UpdateEventSourceRequest, runtime: $Util.RuntimeOptions): Promise<UpdateEventSourceResponse> {
16741
17584
  Util.validateModel(tmpReq);
@@ -16828,10 +17671,12 @@ export default class Client extends OpenApi {
16828
17671
  }
16829
17672
 
16830
17673
  /**
16831
- * You can call this API operation to update an event source.
16832
- *
16833
- * @param request UpdateEventSourceRequest
16834
- * @return UpdateEventSourceResponse
17674
+ * @summary Updates an event source.
17675
+ *
17676
+ * @description You can call this API operation to update an event source.
17677
+ *
17678
+ * @param request UpdateEventSourceRequest
17679
+ * @return UpdateEventSourceResponse
16835
17680
  */
16836
17681
  async updateEventSource(request: UpdateEventSourceRequest): Promise<UpdateEventSourceResponse> {
16837
17682
  let runtime = new $Util.RuntimeOptions({ });
@@ -16839,11 +17684,13 @@ export default class Client extends OpenApi {
16839
17684
  }
16840
17685
 
16841
17686
  /**
16842
- * You can call this API operation to modify the information about an event stream, such as the basic information and the information about the event source, event filtering rule, and event target.
16843
- *
16844
- * @param tmpReq UpdateEventStreamingRequest
16845
- * @param runtime runtime options for this request RuntimeOptions
16846
- * @return UpdateEventStreamingResponse
17687
+ * @summary Modifies the information about an event stream, such as the basic information and the information about the event source, event filtering rule, and event target.
17688
+ *
17689
+ * @description You can call this API operation to modify the information about an event stream, such as the basic information and the information about the event source, event filtering rule, and event target.
17690
+ *
17691
+ * @param tmpReq UpdateEventStreamingRequest
17692
+ * @param runtime runtime options for this request RuntimeOptions
17693
+ * @return UpdateEventStreamingResponse
16847
17694
  */
16848
17695
  async updateEventStreamingWithOptions(tmpReq: UpdateEventStreamingRequest, runtime: $Util.RuntimeOptions): Promise<UpdateEventStreamingResponse> {
16849
17696
  Util.validateModel(tmpReq);
@@ -16912,10 +17759,12 @@ export default class Client extends OpenApi {
16912
17759
  }
16913
17760
 
16914
17761
  /**
16915
- * You can call this API operation to modify the information about an event stream, such as the basic information and the information about the event source, event filtering rule, and event target.
16916
- *
16917
- * @param request UpdateEventStreamingRequest
16918
- * @return UpdateEventStreamingResponse
17762
+ * @summary Modifies the information about an event stream, such as the basic information and the information about the event source, event filtering rule, and event target.
17763
+ *
17764
+ * @description You can call this API operation to modify the information about an event stream, such as the basic information and the information about the event source, event filtering rule, and event target.
17765
+ *
17766
+ * @param request UpdateEventStreamingRequest
17767
+ * @return UpdateEventStreamingResponse
16919
17768
  */
16920
17769
  async updateEventStreaming(request: UpdateEventStreamingRequest): Promise<UpdateEventStreamingResponse> {
16921
17770
  let runtime = new $Util.RuntimeOptions({ });
@@ -16923,11 +17772,13 @@ export default class Client extends OpenApi {
16923
17772
  }
16924
17773
 
16925
17774
  /**
16926
- * You can call this API operation to update the configurations of an event rule.
16927
- *
16928
- * @param request UpdateRuleRequest
16929
- * @param runtime runtime options for this request RuntimeOptions
16930
- * @return UpdateRuleResponse
17775
+ * @summary Updates the configurations of an event rule.
17776
+ *
17777
+ * @description You can call this API operation to update the configurations of an event rule.
17778
+ *
17779
+ * @param request UpdateRuleRequest
17780
+ * @param runtime runtime options for this request RuntimeOptions
17781
+ * @return UpdateRuleResponse
16931
17782
  */
16932
17783
  async updateRuleWithOptions(request: UpdateRuleRequest, runtime: $Util.RuntimeOptions): Promise<UpdateRuleResponse> {
16933
17784
  Util.validateModel(request);
@@ -16970,10 +17821,12 @@ export default class Client extends OpenApi {
16970
17821
  }
16971
17822
 
16972
17823
  /**
16973
- * You can call this API operation to update the configurations of an event rule.
16974
- *
16975
- * @param request UpdateRuleRequest
16976
- * @return UpdateRuleResponse
17824
+ * @summary Updates the configurations of an event rule.
17825
+ *
17826
+ * @description You can call this API operation to update the configurations of an event rule.
17827
+ *
17828
+ * @param request UpdateRuleRequest
17829
+ * @return UpdateRuleResponse
16977
17830
  */
16978
17831
  async updateRule(request: UpdateRuleRequest): Promise<UpdateRuleResponse> {
16979
17832
  let runtime = new $Util.RuntimeOptions({ });