@aws-sdk/client-cloudwatch-events 3.34.0 → 3.37.0

package/dist-types/ts3.4/commands/DeauthorizeConnectionCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DeauthorizeConnectionRequest, DeauthorizeConnectionResponse } from "../models/models_0";
+export interface DeauthorizeConnectionCommandInput extends DeauthorizeConnectionRequest {
+}
+export interface DeauthorizeConnectionCommandOutput extends DeauthorizeConnectionResponse, __MetadataBearer {
+}
+
+export declare class DeauthorizeConnectionCommand extends $Command<DeauthorizeConnectionCommandInput, DeauthorizeConnectionCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DeauthorizeConnectionCommandInput;
+    constructor(input: DeauthorizeConnectionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeauthorizeConnectionCommandInput, DeauthorizeConnectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/DeleteApiDestinationCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
 import { DeleteApiDestinationRequest, DeleteApiDestinationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DeleteApiDestinationCommandInput extends DeleteApiDestinationRequest {
 }
 export interface DeleteApiDestinationCommandOutput extends DeleteApiDestinationResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified API destination.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, DeleteApiDestinationCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, DeleteApiDestinationCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new DeleteApiDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteApiDestinationCommandInput} for command's `input` shape.
- * @see {@link DeleteApiDestinationCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteApiDestinationCommand extends $Command<DeleteApiDestinationCommandInput, DeleteApiDestinationCommandOutput, CloudWatchEventsClientResolvedConfig> {
     readonly input: DeleteApiDestinationCommandInput;
     constructor(input: DeleteApiDestinationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApiDestinationCommandInput, DeleteApiDestinationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteArchiveCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DeleteArchiveRequest, DeleteArchiveResponse } from "../models/models_0";
+export interface DeleteArchiveCommandInput extends DeleteArchiveRequest {
+}
+export interface DeleteArchiveCommandOutput extends DeleteArchiveResponse, __MetadataBearer {
+}
+
+export declare class DeleteArchiveCommand extends $Command<DeleteArchiveCommandInput, DeleteArchiveCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DeleteArchiveCommandInput;
+    constructor(input: DeleteArchiveCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteArchiveCommandInput, DeleteArchiveCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/DeleteConnectionCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
 import { DeleteConnectionRequest, DeleteConnectionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DeleteConnectionCommandInput extends DeleteConnectionRequest {
 }
 export interface DeleteConnectionCommandOutput extends DeleteConnectionResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a connection.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, DeleteConnectionCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, DeleteConnectionCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new DeleteConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteConnectionCommandInput} for command's `input` shape.
- * @see {@link DeleteConnectionCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteConnectionCommand extends $Command<DeleteConnectionCommandInput, DeleteConnectionCommandOutput, CloudWatchEventsClientResolvedConfig> {
     readonly input: DeleteConnectionCommandInput;
     constructor(input: DeleteConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConnectionCommandInput, DeleteConnectionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteEventBusCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DeleteEventBusRequest } from "../models/models_0";
+export interface DeleteEventBusCommandInput extends DeleteEventBusRequest {
+}
+export interface DeleteEventBusCommandOutput extends __MetadataBearer {
+}
+
+export declare class DeleteEventBusCommand extends $Command<DeleteEventBusCommandInput, DeleteEventBusCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DeleteEventBusCommandInput;
+    constructor(input: DeleteEventBusCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEventBusCommandInput, DeleteEventBusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeletePartnerEventSourceCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DeletePartnerEventSourceRequest } from "../models/models_0";
+export interface DeletePartnerEventSourceCommandInput extends DeletePartnerEventSourceRequest {
+}
+export interface DeletePartnerEventSourceCommandOutput extends __MetadataBearer {
+}
+
+export declare class DeletePartnerEventSourceCommand extends $Command<DeletePartnerEventSourceCommandInput, DeletePartnerEventSourceCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DeletePartnerEventSourceCommandInput;
+    constructor(input: DeletePartnerEventSourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePartnerEventSourceCommandInput, DeletePartnerEventSourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteRuleCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DeleteRuleRequest } from "../models/models_0";
+export interface DeleteRuleCommandInput extends DeleteRuleRequest {
+}
+export interface DeleteRuleCommandOutput extends __MetadataBearer {
+}
+
+export declare class DeleteRuleCommand extends $Command<DeleteRuleCommandInput, DeleteRuleCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DeleteRuleCommandInput;
+    constructor(input: DeleteRuleCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRuleCommandInput, DeleteRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/DescribeApiDestinationCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
 import { DescribeApiDestinationRequest, DescribeApiDestinationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DescribeApiDestinationCommandInput extends DescribeApiDestinationRequest {
 }
 export interface DescribeApiDestinationCommandOutput extends DescribeApiDestinationResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves details about an API destination.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, DescribeApiDestinationCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, DescribeApiDestinationCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new DescribeApiDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeApiDestinationCommandInput} for command's `input` shape.
- * @see {@link DescribeApiDestinationCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeApiDestinationCommand extends $Command<DescribeApiDestinationCommandInput, DescribeApiDestinationCommandOutput, CloudWatchEventsClientResolvedConfig> {
     readonly input: DescribeApiDestinationCommandInput;
     constructor(input: DescribeApiDestinationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeApiDestinationCommandInput, DescribeApiDestinationCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/DescribeArchiveCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
 import { DescribeArchiveRequest, DescribeArchiveResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DescribeArchiveCommandInput extends DescribeArchiveRequest {
 }
 export interface DescribeArchiveCommandOutput extends DescribeArchiveResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves details about an archive.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, DescribeArchiveCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, DescribeArchiveCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new DescribeArchiveCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeArchiveCommandInput} for command's `input` shape.
- * @see {@link DescribeArchiveCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeArchiveCommand extends $Command<DescribeArchiveCommandInput, DescribeArchiveCommandOutput, CloudWatchEventsClientResolvedConfig> {
     readonly input: DescribeArchiveCommandInput;
     constructor(input: DescribeArchiveCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeArchiveCommandInput, DescribeArchiveCommandOutput>;
     private serialize;
     private deserialize;

package/{dist/types → dist-types}/ts3.4/commands/DescribeConnectionCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
 import { DescribeConnectionRequest, DescribeConnectionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DescribeConnectionCommandInput extends DescribeConnectionRequest {
 }
 export interface DescribeConnectionCommandOutput extends DescribeConnectionResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves details about a connection.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, DescribeConnectionCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, DescribeConnectionCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new DescribeConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConnectionCommandInput} for command's `input` shape.
- * @see {@link DescribeConnectionCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeConnectionCommand extends $Command<DescribeConnectionCommandInput, DescribeConnectionCommandOutput, CloudWatchEventsClientResolvedConfig> {
     readonly input: DescribeConnectionCommandInput;
     constructor(input: DescribeConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConnectionCommandInput, DescribeConnectionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeEventBusCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DescribeEventBusRequest, DescribeEventBusResponse } from "../models/models_0";
+export interface DescribeEventBusCommandInput extends DescribeEventBusRequest {
+}
+export interface DescribeEventBusCommandOutput extends DescribeEventBusResponse, __MetadataBearer {
+}
+
+export declare class DescribeEventBusCommand extends $Command<DescribeEventBusCommandInput, DescribeEventBusCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DescribeEventBusCommandInput;
+    constructor(input: DescribeEventBusCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventBusCommandInput, DescribeEventBusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeEventSourceCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DescribeEventSourceRequest, DescribeEventSourceResponse } from "../models/models_0";
+export interface DescribeEventSourceCommandInput extends DescribeEventSourceRequest {
+}
+export interface DescribeEventSourceCommandOutput extends DescribeEventSourceResponse, __MetadataBearer {
+}
+
+export declare class DescribeEventSourceCommand extends $Command<DescribeEventSourceCommandInput, DescribeEventSourceCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DescribeEventSourceCommandInput;
+    constructor(input: DescribeEventSourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventSourceCommandInput, DescribeEventSourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribePartnerEventSourceCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DescribePartnerEventSourceRequest, DescribePartnerEventSourceResponse } from "../models/models_0";
+export interface DescribePartnerEventSourceCommandInput extends DescribePartnerEventSourceRequest {
+}
+export interface DescribePartnerEventSourceCommandOutput extends DescribePartnerEventSourceResponse, __MetadataBearer {
+}
+
+export declare class DescribePartnerEventSourceCommand extends $Command<DescribePartnerEventSourceCommandInput, DescribePartnerEventSourceCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DescribePartnerEventSourceCommandInput;
+    constructor(input: DescribePartnerEventSourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePartnerEventSourceCommandInput, DescribePartnerEventSourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeReplayCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DescribeReplayRequest, DescribeReplayResponse } from "../models/models_0";
+export interface DescribeReplayCommandInput extends DescribeReplayRequest {
+}
+export interface DescribeReplayCommandOutput extends DescribeReplayResponse, __MetadataBearer {
+}
+
+export declare class DescribeReplayCommand extends $Command<DescribeReplayCommandInput, DescribeReplayCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DescribeReplayCommandInput;
+    constructor(input: DescribeReplayCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeReplayCommandInput, DescribeReplayCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeRuleCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DescribeRuleRequest, DescribeRuleResponse } from "../models/models_0";
+export interface DescribeRuleCommandInput extends DescribeRuleRequest {
+}
+export interface DescribeRuleCommandOutput extends DescribeRuleResponse, __MetadataBearer {
+}
+
+export declare class DescribeRuleCommand extends $Command<DescribeRuleCommandInput, DescribeRuleCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DescribeRuleCommandInput;
+    constructor(input: DescribeRuleCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRuleCommandInput, DescribeRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DisableRuleCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { DisableRuleRequest } from "../models/models_0";
+export interface DisableRuleCommandInput extends DisableRuleRequest {
+}
+export interface DisableRuleCommandOutput extends __MetadataBearer {
+}
+
+export declare class DisableRuleCommand extends $Command<DisableRuleCommandInput, DisableRuleCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: DisableRuleCommandInput;
+    constructor(input: DisableRuleCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableRuleCommandInput, DisableRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/EnableRuleCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { EnableRuleRequest } from "../models/models_0";
+export interface EnableRuleCommandInput extends EnableRuleRequest {
+}
+export interface EnableRuleCommandOutput extends __MetadataBearer {
+}
+
+export declare class EnableRuleCommand extends $Command<EnableRuleCommandInput, EnableRuleCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: EnableRuleCommandInput;
+    constructor(input: EnableRuleCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableRuleCommandInput, EnableRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListApiDestinationsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { ListApiDestinationsRequest, ListApiDestinationsResponse } from "../models/models_0";
+export interface ListApiDestinationsCommandInput extends ListApiDestinationsRequest {
+}
+export interface ListApiDestinationsCommandOutput extends ListApiDestinationsResponse, __MetadataBearer {
+}
+
+export declare class ListApiDestinationsCommand extends $Command<ListApiDestinationsCommandInput, ListApiDestinationsCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: ListApiDestinationsCommandInput;
+    constructor(input: ListApiDestinationsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListApiDestinationsCommandInput, ListApiDestinationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListArchivesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { ListArchivesRequest, ListArchivesResponse } from "../models/models_0";
+export interface ListArchivesCommandInput extends ListArchivesRequest {
+}
+export interface ListArchivesCommandOutput extends ListArchivesResponse, __MetadataBearer {
+}
+
+export declare class ListArchivesCommand extends $Command<ListArchivesCommandInput, ListArchivesCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: ListArchivesCommandInput;
+    constructor(input: ListArchivesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListArchivesCommandInput, ListArchivesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListConnectionsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { ListConnectionsRequest, ListConnectionsResponse } from "../models/models_0";
+export interface ListConnectionsCommandInput extends ListConnectionsRequest {
+}
+export interface ListConnectionsCommandOutput extends ListConnectionsResponse, __MetadataBearer {
+}
+
+export declare class ListConnectionsCommand extends $Command<ListConnectionsCommandInput, ListConnectionsCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: ListConnectionsCommandInput;
+    constructor(input: ListConnectionsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConnectionsCommandInput, ListConnectionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListEventBusesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { ListEventBusesRequest, ListEventBusesResponse } from "../models/models_0";
+export interface ListEventBusesCommandInput extends ListEventBusesRequest {
+}
+export interface ListEventBusesCommandOutput extends ListEventBusesResponse, __MetadataBearer {
+}
+
+export declare class ListEventBusesCommand extends $Command<ListEventBusesCommandInput, ListEventBusesCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: ListEventBusesCommandInput;
+    constructor(input: ListEventBusesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEventBusesCommandInput, ListEventBusesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListEventSourcesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { ListEventSourcesRequest, ListEventSourcesResponse } from "../models/models_0";
+export interface ListEventSourcesCommandInput extends ListEventSourcesRequest {
+}
+export interface ListEventSourcesCommandOutput extends ListEventSourcesResponse, __MetadataBearer {
+}
+
+export declare class ListEventSourcesCommand extends $Command<ListEventSourcesCommandInput, ListEventSourcesCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: ListEventSourcesCommandInput;
+    constructor(input: ListEventSourcesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEventSourcesCommandInput, ListEventSourcesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListPartnerEventSourceAccountsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { ListPartnerEventSourceAccountsRequest, ListPartnerEventSourceAccountsResponse } from "../models/models_0";
+export interface ListPartnerEventSourceAccountsCommandInput extends ListPartnerEventSourceAccountsRequest {
+}
+export interface ListPartnerEventSourceAccountsCommandOutput extends ListPartnerEventSourceAccountsResponse, __MetadataBearer {
+}
+
+export declare class ListPartnerEventSourceAccountsCommand extends $Command<ListPartnerEventSourceAccountsCommandInput, ListPartnerEventSourceAccountsCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: ListPartnerEventSourceAccountsCommandInput;
+    constructor(input: ListPartnerEventSourceAccountsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPartnerEventSourceAccountsCommandInput, ListPartnerEventSourceAccountsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListPartnerEventSourcesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { ListPartnerEventSourcesRequest, ListPartnerEventSourcesResponse } from "../models/models_0";
+export interface ListPartnerEventSourcesCommandInput extends ListPartnerEventSourcesRequest {
+}
+export interface ListPartnerEventSourcesCommandOutput extends ListPartnerEventSourcesResponse, __MetadataBearer {
+}
+
+export declare class ListPartnerEventSourcesCommand extends $Command<ListPartnerEventSourcesCommandInput, ListPartnerEventSourcesCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: ListPartnerEventSourcesCommandInput;
+    constructor(input: ListPartnerEventSourcesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPartnerEventSourcesCommandInput, ListPartnerEventSourcesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListReplaysCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { ListReplaysRequest, ListReplaysResponse } from "../models/models_0";
+export interface ListReplaysCommandInput extends ListReplaysRequest {
+}
+export interface ListReplaysCommandOutput extends ListReplaysResponse, __MetadataBearer {
+}
+
+export declare class ListReplaysCommand extends $Command<ListReplaysCommandInput, ListReplaysCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: ListReplaysCommandInput;
+    constructor(input: ListReplaysCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListReplaysCommandInput, ListReplaysCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListRuleNamesByTargetCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { ListRuleNamesByTargetRequest, ListRuleNamesByTargetResponse } from "../models/models_0";
+export interface ListRuleNamesByTargetCommandInput extends ListRuleNamesByTargetRequest {
+}
+export interface ListRuleNamesByTargetCommandOutput extends ListRuleNamesByTargetResponse, __MetadataBearer {
+}
+
+export declare class ListRuleNamesByTargetCommand extends $Command<ListRuleNamesByTargetCommandInput, ListRuleNamesByTargetCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: ListRuleNamesByTargetCommandInput;
+    constructor(input: ListRuleNamesByTargetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRuleNamesByTargetCommandInput, ListRuleNamesByTargetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListRulesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
+import { ListRulesRequest, ListRulesResponse } from "../models/models_0";
+export interface ListRulesCommandInput extends ListRulesRequest {
+}
+export interface ListRulesCommandOutput extends ListRulesResponse, __MetadataBearer {
+}
+
+export declare class ListRulesCommand extends $Command<ListRulesCommandInput, ListRulesCommandOutput, CloudWatchEventsClientResolvedConfig> {
+    readonly input: ListRulesCommandInput;
+    constructor(input: ListRulesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRulesCommandInput, ListRulesCommandOutput>;
+    private serialize;
+    private deserialize;
+}