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

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

@@ -1,38 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { DescribePartnerEventSourceRequest, DescribePartnerEventSourceResponse } 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 DescribePartnerEventSourceCommandInput extends DescribePartnerEventSourceRequest {
-}
-export interface DescribePartnerEventSourceCommandOutput extends DescribePartnerEventSourceResponse, __MetadataBearer {
-}
-/**
- * <p>An SaaS partner can use this operation to list details about a partner event source that
- *       they have created. Amazon Web Services customers do not use this operation. Instead, Amazon Web Services customers can use <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_DescribeEventSource.html">DescribeEventSource</a>
- *       to see details about a partner event source that is
- *       shared with them.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, DescribePartnerEventSourceCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, DescribePartnerEventSourceCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new DescribePartnerEventSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribePartnerEventSourceCommandInput} for command's `input` shape.
- * @see {@link DescribePartnerEventSourceCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribePartnerEventSourceCommand extends $Command<DescribePartnerEventSourceCommandInput, DescribePartnerEventSourceCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: DescribePartnerEventSourceCommandInput;
-    constructor(input: DescribePartnerEventSourceCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,43 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { DescribeReplayRequest, DescribeReplayResponse } 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 DescribeReplayCommandInput extends DescribeReplayRequest {
-}
-export interface DescribeReplayCommandOutput extends DescribeReplayResponse, __MetadataBearer {
-}
-/**
- * <p>Retrieves details about a replay. Use <code>DescribeReplay</code> to determine the
- *       progress of a running replay. A replay processes events to replay based on the time in the
- *       event, and replays them using 1 minute intervals. If you use <code>StartReplay</code> and
- *       specify an <code>EventStartTime</code> and an <code>EventEndTime</code> that covers a 20
- *       minute time range, the events are replayed from the first minute of that 20 minute range
- *       first. Then the events from the second minute are replayed. You can use
- *         <code>DescribeReplay</code> to determine the progress of a replay. The value returned for
- *         <code>EventLastReplayedTime</code> indicates the time within the specified time range
- *       associated with the last event replayed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, DescribeReplayCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, DescribeReplayCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new DescribeReplayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeReplayCommandInput} for command's `input` shape.
- * @see {@link DescribeReplayCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeReplayCommand extends $Command<DescribeReplayCommandInput, DescribeReplayCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: DescribeReplayCommandInput;
-    constructor(input: DescribeReplayCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,37 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { DescribeRuleRequest, DescribeRuleResponse } 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 DescribeRuleCommandInput extends DescribeRuleRequest {
-}
-export interface DescribeRuleCommandOutput extends DescribeRuleResponse, __MetadataBearer {
-}
-/**
- * <p>Describes the specified rule.</p>
- *          <p>DescribeRule does not list the targets of a rule. To see the targets associated with a
- *       rule, use <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_ListTargetsByRule.html">ListTargetsByRule</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, DescribeRuleCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, DescribeRuleCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new DescribeRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeRuleCommandInput} for command's `input` shape.
- * @see {@link DescribeRuleCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeRuleCommand extends $Command<DescribeRuleCommandInput, DescribeRuleCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: DescribeRuleCommandInput;
-    constructor(input: DescribeRuleCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,39 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { DisableRuleRequest } 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 DisableRuleCommandInput extends DisableRuleRequest {
-}
-export interface DisableRuleCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Disables the specified rule. A disabled rule won't match any events, and won't
- *       self-trigger if it has a schedule expression.</p>
- *
- *          <p>When you disable a rule, incoming events might continue to match to the disabled rule.
- *       Allow a short period of time for changes to take effect.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, DisableRuleCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, DisableRuleCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new DisableRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableRuleCommandInput} for command's `input` shape.
- * @see {@link DisableRuleCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DisableRuleCommand extends $Command<DisableRuleCommandInput, DisableRuleCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: DisableRuleCommandInput;
-    constructor(input: DisableRuleCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,38 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { EnableRuleRequest } 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 EnableRuleCommandInput extends EnableRuleRequest {
-}
-export interface EnableRuleCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Enables the specified rule. If the rule does not exist, the operation fails.</p>
- *
- *          <p>When you enable a rule, incoming events might not immediately start matching to a newly
- *       enabled rule. Allow a short period of time for changes to take effect.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, EnableRuleCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, EnableRuleCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new EnableRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableRuleCommandInput} for command's `input` shape.
- * @see {@link EnableRuleCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class EnableRuleCommand extends $Command<EnableRuleCommandInput, EnableRuleCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: EnableRuleCommandInput;
-    constructor(input: EnableRuleCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,35 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListApiDestinationsRequest, ListApiDestinationsResponse } 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 ListApiDestinationsCommandInput extends ListApiDestinationsRequest {
-}
-export interface ListApiDestinationsCommandOutput extends ListApiDestinationsResponse, __MetadataBearer {
-}
-/**
- * <p>Retrieves a list of API destination in the account in the current Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListApiDestinationsCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListApiDestinationsCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListApiDestinationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListApiDestinationsCommandInput} for command's `input` shape.
- * @see {@link ListApiDestinationsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListApiDestinationsCommand extends $Command<ListApiDestinationsCommandInput, ListApiDestinationsCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListApiDestinationsCommandInput;
-    constructor(input: ListApiDestinationsCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,36 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListArchivesRequest, ListArchivesResponse } 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 ListArchivesCommandInput extends ListArchivesRequest {
-}
-export interface ListArchivesCommandOutput extends ListArchivesResponse, __MetadataBearer {
-}
-/**
- * <p>Lists your archives. You can either list all the archives or you can provide a prefix to
- *       match to the archive names. Filter parameters are exclusive.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListArchivesCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListArchivesCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListArchivesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListArchivesCommandInput} for command's `input` shape.
- * @see {@link ListArchivesCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListArchivesCommand extends $Command<ListArchivesCommandInput, ListArchivesCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListArchivesCommandInput;
-    constructor(input: ListArchivesCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,35 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListConnectionsRequest, ListConnectionsResponse } 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 ListConnectionsCommandInput extends ListConnectionsRequest {
-}
-export interface ListConnectionsCommandOutput extends ListConnectionsResponse, __MetadataBearer {
-}
-/**
- * <p>Retrieves a list of connections from the account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListConnectionsCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListConnectionsCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListConnectionsCommandInput} for command's `input` shape.
- * @see {@link ListConnectionsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListConnectionsCommand extends $Command<ListConnectionsCommandInput, ListConnectionsCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListConnectionsCommandInput;
-    constructor(input: ListConnectionsCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,36 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListEventBusesRequest, ListEventBusesResponse } 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 ListEventBusesCommandInput extends ListEventBusesRequest {
-}
-export interface ListEventBusesCommandOutput extends ListEventBusesResponse, __MetadataBearer {
-}
-/**
- * <p>Lists all the event buses in your account, including the default event bus, custom event
- *       buses, and partner event buses.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListEventBusesCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListEventBusesCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListEventBusesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEventBusesCommandInput} for command's `input` shape.
- * @see {@link ListEventBusesCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListEventBusesCommand extends $Command<ListEventBusesCommandInput, ListEventBusesCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListEventBusesCommandInput;
-    constructor(input: ListEventBusesCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,36 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListEventSourcesRequest, ListEventSourcesResponse } 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 ListEventSourcesCommandInput extends ListEventSourcesRequest {
-}
-export interface ListEventSourcesCommandOutput extends ListEventSourcesResponse, __MetadataBearer {
-}
-/**
- * <p>You can use this to see all the partner event sources that have been shared with your Amazon Web Services
- *       account. For more information about partner event sources, see <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_CreateEventBus.html">CreateEventBus</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListEventSourcesCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListEventSourcesCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListEventSourcesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEventSourcesCommandInput} for command's `input` shape.
- * @see {@link ListEventSourcesCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListEventSourcesCommand extends $Command<ListEventSourcesCommandInput, ListEventSourcesCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListEventSourcesCommandInput;
-    constructor(input: ListEventSourcesCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,37 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListPartnerEventSourceAccountsRequest, ListPartnerEventSourceAccountsResponse } 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 ListPartnerEventSourceAccountsCommandInput extends ListPartnerEventSourceAccountsRequest {
-}
-export interface ListPartnerEventSourceAccountsCommandOutput extends ListPartnerEventSourceAccountsResponse, __MetadataBearer {
-}
-/**
- * <p>An SaaS partner can use this operation to display the Amazon Web Services account ID that a particular
- *       partner event source name is associated with. This operation is not used by Amazon Web Services
- *       customers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListPartnerEventSourceAccountsCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListPartnerEventSourceAccountsCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListPartnerEventSourceAccountsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListPartnerEventSourceAccountsCommandInput} for command's `input` shape.
- * @see {@link ListPartnerEventSourceAccountsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListPartnerEventSourceAccountsCommand extends $Command<ListPartnerEventSourceAccountsCommandInput, ListPartnerEventSourceAccountsCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListPartnerEventSourceAccountsCommandInput;
-    constructor(input: ListPartnerEventSourceAccountsCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,36 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListPartnerEventSourcesRequest, ListPartnerEventSourcesResponse } 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 ListPartnerEventSourcesCommandInput extends ListPartnerEventSourcesRequest {
-}
-export interface ListPartnerEventSourcesCommandOutput extends ListPartnerEventSourcesResponse, __MetadataBearer {
-}
-/**
- * <p>An SaaS partner can use this operation to list all the partner event source names that
- *       they have created. This operation is not used by Amazon Web Services customers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListPartnerEventSourcesCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListPartnerEventSourcesCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListPartnerEventSourcesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListPartnerEventSourcesCommandInput} for command's `input` shape.
- * @see {@link ListPartnerEventSourcesCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListPartnerEventSourcesCommand extends $Command<ListPartnerEventSourcesCommandInput, ListPartnerEventSourcesCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListPartnerEventSourcesCommandInput;
-    constructor(input: ListPartnerEventSourcesCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,36 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListReplaysRequest, ListReplaysResponse } 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 ListReplaysCommandInput extends ListReplaysRequest {
-}
-export interface ListReplaysCommandOutput extends ListReplaysResponse, __MetadataBearer {
-}
-/**
- * <p>Lists your replays. You can either list all the replays or you can provide a prefix to
- *       match to the replay names. Filter parameters are exclusive.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListReplaysCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListReplaysCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListReplaysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListReplaysCommandInput} for command's `input` shape.
- * @see {@link ListReplaysCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListReplaysCommand extends $Command<ListReplaysCommandInput, ListReplaysCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListReplaysCommandInput;
-    constructor(input: ListReplaysCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,36 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListRuleNamesByTargetRequest, ListRuleNamesByTargetResponse } 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 ListRuleNamesByTargetCommandInput extends ListRuleNamesByTargetRequest {
-}
-export interface ListRuleNamesByTargetCommandOutput extends ListRuleNamesByTargetResponse, __MetadataBearer {
-}
-/**
- * <p>Lists the rules for the specified target. You can see which of the rules in Amazon
- *       EventBridge can invoke a specific target in your account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListRuleNamesByTargetCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListRuleNamesByTargetCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListRuleNamesByTargetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListRuleNamesByTargetCommandInput} for command's `input` shape.
- * @see {@link ListRuleNamesByTargetCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListRuleNamesByTargetCommand extends $Command<ListRuleNamesByTargetCommandInput, ListRuleNamesByTargetCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListRuleNamesByTargetCommandInput;
-    constructor(input: ListRuleNamesByTargetCommandInput);
-    /**
-     * @internal
-     */
-    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

@@ -1,39 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListRulesRequest, ListRulesResponse } 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 ListRulesCommandInput extends ListRulesRequest {
-}
-export interface ListRulesCommandOutput extends ListRulesResponse, __MetadataBearer {
-}
-/**
- * <p>Lists your Amazon EventBridge rules. You can either list all the rules or you can provide
- *       a prefix to match to the rule names.</p>
- *
- *          <p>ListRules does not list the targets of a rule. To see the targets associated with a rule,
- *       use <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_ListTargetsByRule.html">ListTargetsByRule</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListRulesCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListRulesCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListRulesCommandInput} for command's `input` shape.
- * @see {@link ListRulesCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListRulesCommand extends $Command<ListRulesCommandInput, ListRulesCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListRulesCommandInput;
-    constructor(input: ListRulesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRulesCommandInput, ListRulesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListTagsForResourceCommand.d.ts

@@ -1,36 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListTagsForResourceRequest, ListTagsForResourceResponse } 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 ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
-}
-export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
-}
-/**
- * <p>Displays the tags associated with an EventBridge resource. In EventBridge, rules and event
- *       buses can be tagged.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListTagsForResourceCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListTagsForResourceCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, CloudWatchEventsClientResolvedConfig> {
-    readonly input: ListTagsForResourceCommandInput;
-    constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchEventsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}