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

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2143 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export interface ActivateEventSourceRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace ActivateEventSourceRequest {
+    
+    const filterSensitiveLog: (obj: ActivateEventSourceRequest) => any;
+}
+
+export interface ConcurrentModificationException extends __SmithyException, $MetadataBearer {
+    name: "ConcurrentModificationException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ConcurrentModificationException {
+    
+    const filterSensitiveLog: (obj: ConcurrentModificationException) => any;
+}
+
+export interface InternalException extends __SmithyException, $MetadataBearer {
+    name: "InternalException";
+    $fault: "server";
+    message?: string;
+}
+export declare namespace InternalException {
+    
+    const filterSensitiveLog: (obj: InternalException) => any;
+}
+
+export interface InvalidStateException extends __SmithyException, $MetadataBearer {
+    name: "InvalidStateException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidStateException {
+    
+    const filterSensitiveLog: (obj: InvalidStateException) => any;
+}
+
+export interface OperationDisabledException extends __SmithyException, $MetadataBearer {
+    name: "OperationDisabledException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace OperationDisabledException {
+    
+    const filterSensitiveLog: (obj: OperationDisabledException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+export declare enum ApiDestinationState {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+export declare enum ApiDestinationHttpMethod {
+    DELETE = "DELETE",
+    GET = "GET",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS",
+    PATCH = "PATCH",
+    POST = "POST",
+    PUT = "PUT"
+}
+
+export interface ApiDestination {
+    
+    ApiDestinationArn?: string;
+    
+    Name?: string;
+    
+    ApiDestinationState?: ApiDestinationState | string;
+    
+    ConnectionArn?: string;
+    
+    InvocationEndpoint?: string;
+    
+    HttpMethod?: ApiDestinationHttpMethod | string;
+    
+    InvocationRateLimitPerSecond?: number;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace ApiDestination {
+    
+    const filterSensitiveLog: (obj: ApiDestination) => any;
+}
+export declare enum ArchiveState {
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATING = "CREATING",
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATING = "UPDATING"
+}
+
+export interface Archive {
+    
+    ArchiveName?: string;
+    
+    EventSourceArn?: string;
+    
+    State?: ArchiveState | string;
+    
+    StateReason?: string;
+    
+    RetentionDays?: number;
+    
+    SizeBytes?: number;
+    
+    EventCount?: number;
+    
+    CreationTime?: Date;
+}
+export declare namespace Archive {
+    
+    const filterSensitiveLog: (obj: Archive) => any;
+}
+export declare enum AssignPublicIp {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export interface CancelReplayRequest {
+    
+    ReplayName: string | undefined;
+}
+export declare namespace CancelReplayRequest {
+    
+    const filterSensitiveLog: (obj: CancelReplayRequest) => any;
+}
+export declare enum ReplayState {
+    CANCELLED = "CANCELLED",
+    CANCELLING = "CANCELLING",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    RUNNING = "RUNNING",
+    STARTING = "STARTING"
+}
+export interface CancelReplayResponse {
+    
+    ReplayArn?: string;
+    
+    State?: ReplayState | string;
+    
+    StateReason?: string;
+}
+export declare namespace CancelReplayResponse {
+    
+    const filterSensitiveLog: (obj: CancelReplayResponse) => any;
+}
+
+export interface IllegalStatusException extends __SmithyException, $MetadataBearer {
+    name: "IllegalStatusException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace IllegalStatusException {
+    
+    const filterSensitiveLog: (obj: IllegalStatusException) => any;
+}
+export interface CreateApiDestinationRequest {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    ConnectionArn: string | undefined;
+    
+    InvocationEndpoint: string | undefined;
+    
+    HttpMethod: ApiDestinationHttpMethod | string | undefined;
+    
+    InvocationRateLimitPerSecond?: number;
+}
+export declare namespace CreateApiDestinationRequest {
+    
+    const filterSensitiveLog: (obj: CreateApiDestinationRequest) => any;
+}
+export interface CreateApiDestinationResponse {
+    
+    ApiDestinationArn?: string;
+    
+    ApiDestinationState?: ApiDestinationState | string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace CreateApiDestinationResponse {
+    
+    const filterSensitiveLog: (obj: CreateApiDestinationResponse) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace LimitExceededException {
+    
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+
+export interface ResourceAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "ResourceAlreadyExistsException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ResourceAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: ResourceAlreadyExistsException) => any;
+}
+export interface CreateArchiveRequest {
+    
+    ArchiveName: string | undefined;
+    
+    EventSourceArn: string | undefined;
+    
+    Description?: string;
+    
+    EventPattern?: string;
+    
+    RetentionDays?: number;
+}
+export declare namespace CreateArchiveRequest {
+    
+    const filterSensitiveLog: (obj: CreateArchiveRequest) => any;
+}
+export interface CreateArchiveResponse {
+    
+    ArchiveArn?: string;
+    
+    State?: ArchiveState | string;
+    
+    StateReason?: string;
+    
+    CreationTime?: Date;
+}
+export declare namespace CreateArchiveResponse {
+    
+    const filterSensitiveLog: (obj: CreateArchiveResponse) => any;
+}
+
+export interface InvalidEventPatternException extends __SmithyException, $MetadataBearer {
+    name: "InvalidEventPatternException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidEventPatternException {
+    
+    const filterSensitiveLog: (obj: InvalidEventPatternException) => any;
+}
+export declare enum ConnectionAuthorizationType {
+    API_KEY = "API_KEY",
+    BASIC = "BASIC",
+    OAUTH_CLIENT_CREDENTIALS = "OAUTH_CLIENT_CREDENTIALS"
+}
+
+export interface CreateConnectionApiKeyAuthRequestParameters {
+    
+    ApiKeyName: string | undefined;
+    
+    ApiKeyValue: string | undefined;
+}
+export declare namespace CreateConnectionApiKeyAuthRequestParameters {
+    
+    const filterSensitiveLog: (obj: CreateConnectionApiKeyAuthRequestParameters) => any;
+}
+
+export interface CreateConnectionBasicAuthRequestParameters {
+    
+    Username: string | undefined;
+    
+    Password: string | undefined;
+}
+export declare namespace CreateConnectionBasicAuthRequestParameters {
+    
+    const filterSensitiveLog: (obj: CreateConnectionBasicAuthRequestParameters) => any;
+}
+
+export interface ConnectionBodyParameter {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    IsValueSecret?: boolean;
+}
+export declare namespace ConnectionBodyParameter {
+    
+    const filterSensitiveLog: (obj: ConnectionBodyParameter) => any;
+}
+
+export interface ConnectionHeaderParameter {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    IsValueSecret?: boolean;
+}
+export declare namespace ConnectionHeaderParameter {
+    
+    const filterSensitiveLog: (obj: ConnectionHeaderParameter) => any;
+}
+
+export interface ConnectionQueryStringParameter {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    IsValueSecret?: boolean;
+}
+export declare namespace ConnectionQueryStringParameter {
+    
+    const filterSensitiveLog: (obj: ConnectionQueryStringParameter) => any;
+}
+
+export interface ConnectionHttpParameters {
+    
+    HeaderParameters?: ConnectionHeaderParameter[];
+    
+    QueryStringParameters?: ConnectionQueryStringParameter[];
+    
+    BodyParameters?: ConnectionBodyParameter[];
+}
+export declare namespace ConnectionHttpParameters {
+    
+    const filterSensitiveLog: (obj: ConnectionHttpParameters) => any;
+}
+
+export interface CreateConnectionOAuthClientRequestParameters {
+    
+    ClientID: string | undefined;
+    
+    ClientSecret: string | undefined;
+}
+export declare namespace CreateConnectionOAuthClientRequestParameters {
+    
+    const filterSensitiveLog: (obj: CreateConnectionOAuthClientRequestParameters) => any;
+}
+export declare enum ConnectionOAuthHttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT"
+}
+
+export interface CreateConnectionOAuthRequestParameters {
+    
+    ClientParameters: CreateConnectionOAuthClientRequestParameters | undefined;
+    
+    AuthorizationEndpoint: string | undefined;
+    
+    HttpMethod: ConnectionOAuthHttpMethod | string | undefined;
+    
+    OAuthHttpParameters?: ConnectionHttpParameters;
+}
+export declare namespace CreateConnectionOAuthRequestParameters {
+    
+    const filterSensitiveLog: (obj: CreateConnectionOAuthRequestParameters) => any;
+}
+
+export interface CreateConnectionAuthRequestParameters {
+    
+    BasicAuthParameters?: CreateConnectionBasicAuthRequestParameters;
+    
+    OAuthParameters?: CreateConnectionOAuthRequestParameters;
+    
+    ApiKeyAuthParameters?: CreateConnectionApiKeyAuthRequestParameters;
+    
+    InvocationHttpParameters?: ConnectionHttpParameters;
+}
+export declare namespace CreateConnectionAuthRequestParameters {
+    
+    const filterSensitiveLog: (obj: CreateConnectionAuthRequestParameters) => any;
+}
+export interface CreateConnectionRequest {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    AuthorizationType: ConnectionAuthorizationType | string | undefined;
+    
+    AuthParameters: CreateConnectionAuthRequestParameters | undefined;
+}
+export declare namespace CreateConnectionRequest {
+    
+    const filterSensitiveLog: (obj: CreateConnectionRequest) => any;
+}
+export declare enum ConnectionState {
+    AUTHORIZED = "AUTHORIZED",
+    AUTHORIZING = "AUTHORIZING",
+    CREATING = "CREATING",
+    DEAUTHORIZED = "DEAUTHORIZED",
+    DEAUTHORIZING = "DEAUTHORIZING",
+    DELETING = "DELETING",
+    UPDATING = "UPDATING"
+}
+export interface CreateConnectionResponse {
+    
+    ConnectionArn?: string;
+    
+    ConnectionState?: ConnectionState | string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace CreateConnectionResponse {
+    
+    const filterSensitiveLog: (obj: CreateConnectionResponse) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateEventBusRequest {
+    
+    Name: string | undefined;
+    
+    EventSourceName?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateEventBusRequest {
+    
+    const filterSensitiveLog: (obj: CreateEventBusRequest) => any;
+}
+export interface CreateEventBusResponse {
+    
+    EventBusArn?: string;
+}
+export declare namespace CreateEventBusResponse {
+    
+    const filterSensitiveLog: (obj: CreateEventBusResponse) => any;
+}
+export interface CreatePartnerEventSourceRequest {
+    
+    Name: string | undefined;
+    
+    Account: string | undefined;
+}
+export declare namespace CreatePartnerEventSourceRequest {
+    
+    const filterSensitiveLog: (obj: CreatePartnerEventSourceRequest) => any;
+}
+export interface CreatePartnerEventSourceResponse {
+    
+    EventSourceArn?: string;
+}
+export declare namespace CreatePartnerEventSourceResponse {
+    
+    const filterSensitiveLog: (obj: CreatePartnerEventSourceResponse) => any;
+}
+export interface DeactivateEventSourceRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeactivateEventSourceRequest {
+    
+    const filterSensitiveLog: (obj: DeactivateEventSourceRequest) => any;
+}
+export interface DeauthorizeConnectionRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeauthorizeConnectionRequest {
+    
+    const filterSensitiveLog: (obj: DeauthorizeConnectionRequest) => any;
+}
+export interface DeauthorizeConnectionResponse {
+    
+    ConnectionArn?: string;
+    
+    ConnectionState?: ConnectionState | string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    LastAuthorizedTime?: Date;
+}
+export declare namespace DeauthorizeConnectionResponse {
+    
+    const filterSensitiveLog: (obj: DeauthorizeConnectionResponse) => any;
+}
+export interface DeleteApiDestinationRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteApiDestinationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApiDestinationRequest) => any;
+}
+export interface DeleteApiDestinationResponse {
+}
+export declare namespace DeleteApiDestinationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApiDestinationResponse) => any;
+}
+export interface DeleteArchiveRequest {
+    
+    ArchiveName: string | undefined;
+}
+export declare namespace DeleteArchiveRequest {
+    
+    const filterSensitiveLog: (obj: DeleteArchiveRequest) => any;
+}
+export interface DeleteArchiveResponse {
+}
+export declare namespace DeleteArchiveResponse {
+    
+    const filterSensitiveLog: (obj: DeleteArchiveResponse) => any;
+}
+export interface DeleteConnectionRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteConnectionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConnectionRequest) => any;
+}
+export interface DeleteConnectionResponse {
+    
+    ConnectionArn?: string;
+    
+    ConnectionState?: ConnectionState | string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    LastAuthorizedTime?: Date;
+}
+export declare namespace DeleteConnectionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteConnectionResponse) => any;
+}
+export interface DeleteEventBusRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteEventBusRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEventBusRequest) => any;
+}
+export interface DeletePartnerEventSourceRequest {
+    
+    Name: string | undefined;
+    
+    Account: string | undefined;
+}
+export declare namespace DeletePartnerEventSourceRequest {
+    
+    const filterSensitiveLog: (obj: DeletePartnerEventSourceRequest) => any;
+}
+export interface DeleteRuleRequest {
+    
+    Name: string | undefined;
+    
+    EventBusName?: string;
+    
+    Force?: boolean;
+}
+export declare namespace DeleteRuleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRuleRequest) => any;
+}
+
+export interface ManagedRuleException extends __SmithyException, $MetadataBearer {
+    name: "ManagedRuleException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ManagedRuleException {
+    
+    const filterSensitiveLog: (obj: ManagedRuleException) => any;
+}
+export interface DescribeApiDestinationRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DescribeApiDestinationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeApiDestinationRequest) => any;
+}
+export interface DescribeApiDestinationResponse {
+    
+    ApiDestinationArn?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    ApiDestinationState?: ApiDestinationState | string;
+    
+    ConnectionArn?: string;
+    
+    InvocationEndpoint?: string;
+    
+    HttpMethod?: ApiDestinationHttpMethod | string;
+    
+    InvocationRateLimitPerSecond?: number;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace DescribeApiDestinationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeApiDestinationResponse) => any;
+}
+export interface DescribeArchiveRequest {
+    
+    ArchiveName: string | undefined;
+}
+export declare namespace DescribeArchiveRequest {
+    
+    const filterSensitiveLog: (obj: DescribeArchiveRequest) => any;
+}
+export interface DescribeArchiveResponse {
+    
+    ArchiveArn?: string;
+    
+    ArchiveName?: string;
+    
+    EventSourceArn?: string;
+    
+    Description?: string;
+    
+    EventPattern?: string;
+    
+    State?: ArchiveState | string;
+    
+    StateReason?: string;
+    
+    RetentionDays?: number;
+    
+    SizeBytes?: number;
+    
+    EventCount?: number;
+    
+    CreationTime?: Date;
+}
+export declare namespace DescribeArchiveResponse {
+    
+    const filterSensitiveLog: (obj: DescribeArchiveResponse) => any;
+}
+export interface DescribeConnectionRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DescribeConnectionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConnectionRequest) => any;
+}
+
+export interface ConnectionApiKeyAuthResponseParameters {
+    
+    ApiKeyName?: string;
+}
+export declare namespace ConnectionApiKeyAuthResponseParameters {
+    
+    const filterSensitiveLog: (obj: ConnectionApiKeyAuthResponseParameters) => any;
+}
+
+export interface ConnectionBasicAuthResponseParameters {
+    
+    Username?: string;
+}
+export declare namespace ConnectionBasicAuthResponseParameters {
+    
+    const filterSensitiveLog: (obj: ConnectionBasicAuthResponseParameters) => any;
+}
+
+export interface ConnectionOAuthClientResponseParameters {
+    
+    ClientID?: string;
+}
+export declare namespace ConnectionOAuthClientResponseParameters {
+    
+    const filterSensitiveLog: (obj: ConnectionOAuthClientResponseParameters) => any;
+}
+
+export interface ConnectionOAuthResponseParameters {
+    
+    ClientParameters?: ConnectionOAuthClientResponseParameters;
+    
+    AuthorizationEndpoint?: string;
+    
+    HttpMethod?: ConnectionOAuthHttpMethod | string;
+    
+    OAuthHttpParameters?: ConnectionHttpParameters;
+}
+export declare namespace ConnectionOAuthResponseParameters {
+    
+    const filterSensitiveLog: (obj: ConnectionOAuthResponseParameters) => any;
+}
+
+export interface ConnectionAuthResponseParameters {
+    
+    BasicAuthParameters?: ConnectionBasicAuthResponseParameters;
+    
+    OAuthParameters?: ConnectionOAuthResponseParameters;
+    
+    ApiKeyAuthParameters?: ConnectionApiKeyAuthResponseParameters;
+    
+    InvocationHttpParameters?: ConnectionHttpParameters;
+}
+export declare namespace ConnectionAuthResponseParameters {
+    
+    const filterSensitiveLog: (obj: ConnectionAuthResponseParameters) => any;
+}
+export interface DescribeConnectionResponse {
+    
+    ConnectionArn?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    ConnectionState?: ConnectionState | string;
+    
+    StateReason?: string;
+    
+    AuthorizationType?: ConnectionAuthorizationType | string;
+    
+    SecretArn?: string;
+    
+    AuthParameters?: ConnectionAuthResponseParameters;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    LastAuthorizedTime?: Date;
+}
+export declare namespace DescribeConnectionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConnectionResponse) => any;
+}
+export interface DescribeEventBusRequest {
+    
+    Name?: string;
+}
+export declare namespace DescribeEventBusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEventBusRequest) => any;
+}
+export interface DescribeEventBusResponse {
+    
+    Name?: string;
+    
+    Arn?: string;
+    
+    Policy?: string;
+}
+export declare namespace DescribeEventBusResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEventBusResponse) => any;
+}
+export interface DescribeEventSourceRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DescribeEventSourceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEventSourceRequest) => any;
+}
+export declare enum EventSourceState {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    PENDING = "PENDING"
+}
+export interface DescribeEventSourceResponse {
+    
+    Arn?: string;
+    
+    CreatedBy?: string;
+    
+    CreationTime?: Date;
+    
+    ExpirationTime?: Date;
+    
+    Name?: string;
+    
+    State?: EventSourceState | string;
+}
+export declare namespace DescribeEventSourceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEventSourceResponse) => any;
+}
+export interface DescribePartnerEventSourceRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DescribePartnerEventSourceRequest {
+    
+    const filterSensitiveLog: (obj: DescribePartnerEventSourceRequest) => any;
+}
+export interface DescribePartnerEventSourceResponse {
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace DescribePartnerEventSourceResponse {
+    
+    const filterSensitiveLog: (obj: DescribePartnerEventSourceResponse) => any;
+}
+export interface DescribeReplayRequest {
+    
+    ReplayName: string | undefined;
+}
+export declare namespace DescribeReplayRequest {
+    
+    const filterSensitiveLog: (obj: DescribeReplayRequest) => any;
+}
+
+export interface ReplayDestination {
+    
+    Arn: string | undefined;
+    
+    FilterArns?: string[];
+}
+export declare namespace ReplayDestination {
+    
+    const filterSensitiveLog: (obj: ReplayDestination) => any;
+}
+export interface DescribeReplayResponse {
+    
+    ReplayName?: string;
+    
+    ReplayArn?: string;
+    
+    Description?: string;
+    
+    State?: ReplayState | string;
+    
+    StateReason?: string;
+    
+    EventSourceArn?: string;
+    
+    Destination?: ReplayDestination;
+    
+    EventStartTime?: Date;
+    
+    EventEndTime?: Date;
+    
+    EventLastReplayedTime?: Date;
+    
+    ReplayStartTime?: Date;
+    
+    ReplayEndTime?: Date;
+}
+export declare namespace DescribeReplayResponse {
+    
+    const filterSensitiveLog: (obj: DescribeReplayResponse) => any;
+}
+export interface DescribeRuleRequest {
+    
+    Name: string | undefined;
+    
+    EventBusName?: string;
+}
+export declare namespace DescribeRuleRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRuleRequest) => any;
+}
+export declare enum RuleState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export interface DescribeRuleResponse {
+    
+    Name?: string;
+    
+    Arn?: string;
+    
+    EventPattern?: string;
+    
+    ScheduleExpression?: string;
+    
+    State?: RuleState | string;
+    
+    Description?: string;
+    
+    RoleArn?: string;
+    
+    ManagedBy?: string;
+    
+    EventBusName?: string;
+    
+    CreatedBy?: string;
+}
+export declare namespace DescribeRuleResponse {
+    
+    const filterSensitiveLog: (obj: DescribeRuleResponse) => any;
+}
+export interface DisableRuleRequest {
+    
+    Name: string | undefined;
+    
+    EventBusName?: string;
+}
+export declare namespace DisableRuleRequest {
+    
+    const filterSensitiveLog: (obj: DisableRuleRequest) => any;
+}
+export interface EnableRuleRequest {
+    
+    Name: string | undefined;
+    
+    EventBusName?: string;
+}
+export declare namespace EnableRuleRequest {
+    
+    const filterSensitiveLog: (obj: EnableRuleRequest) => any;
+}
+export interface ListApiDestinationsRequest {
+    
+    NamePrefix?: string;
+    
+    ConnectionArn?: string;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListApiDestinationsRequest {
+    
+    const filterSensitiveLog: (obj: ListApiDestinationsRequest) => any;
+}
+export interface ListApiDestinationsResponse {
+    
+    ApiDestinations?: ApiDestination[];
+    
+    NextToken?: string;
+}
+export declare namespace ListApiDestinationsResponse {
+    
+    const filterSensitiveLog: (obj: ListApiDestinationsResponse) => any;
+}
+export interface ListArchivesRequest {
+    
+    NamePrefix?: string;
+    
+    EventSourceArn?: string;
+    
+    State?: ArchiveState | string;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListArchivesRequest {
+    
+    const filterSensitiveLog: (obj: ListArchivesRequest) => any;
+}
+export interface ListArchivesResponse {
+    
+    Archives?: Archive[];
+    
+    NextToken?: string;
+}
+export declare namespace ListArchivesResponse {
+    
+    const filterSensitiveLog: (obj: ListArchivesResponse) => any;
+}
+export interface ListConnectionsRequest {
+    
+    NamePrefix?: string;
+    
+    ConnectionState?: ConnectionState | string;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListConnectionsRequest {
+    
+    const filterSensitiveLog: (obj: ListConnectionsRequest) => any;
+}
+
+export interface Connection {
+    
+    ConnectionArn?: string;
+    
+    Name?: string;
+    
+    ConnectionState?: ConnectionState | string;
+    
+    StateReason?: string;
+    
+    AuthorizationType?: ConnectionAuthorizationType | string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    LastAuthorizedTime?: Date;
+}
+export declare namespace Connection {
+    
+    const filterSensitiveLog: (obj: Connection) => any;
+}
+export interface ListConnectionsResponse {
+    
+    Connections?: Connection[];
+    
+    NextToken?: string;
+}
+export declare namespace ListConnectionsResponse {
+    
+    const filterSensitiveLog: (obj: ListConnectionsResponse) => any;
+}
+export interface ListEventBusesRequest {
+    
+    NamePrefix?: string;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListEventBusesRequest {
+    
+    const filterSensitiveLog: (obj: ListEventBusesRequest) => any;
+}
+
+export interface EventBus {
+    
+    Name?: string;
+    
+    Arn?: string;
+    
+    Policy?: string;
+}
+export declare namespace EventBus {
+    
+    const filterSensitiveLog: (obj: EventBus) => any;
+}
+export interface ListEventBusesResponse {
+    
+    EventBuses?: EventBus[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEventBusesResponse {
+    
+    const filterSensitiveLog: (obj: ListEventBusesResponse) => any;
+}
+export interface ListEventSourcesRequest {
+    
+    NamePrefix?: string;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListEventSourcesRequest {
+    
+    const filterSensitiveLog: (obj: ListEventSourcesRequest) => any;
+}
+
+export interface EventSource {
+    
+    Arn?: string;
+    
+    CreatedBy?: string;
+    
+    CreationTime?: Date;
+    
+    ExpirationTime?: Date;
+    
+    Name?: string;
+    
+    State?: EventSourceState | string;
+}
+export declare namespace EventSource {
+    
+    const filterSensitiveLog: (obj: EventSource) => any;
+}
+export interface ListEventSourcesResponse {
+    
+    EventSources?: EventSource[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEventSourcesResponse {
+    
+    const filterSensitiveLog: (obj: ListEventSourcesResponse) => any;
+}
+export interface ListPartnerEventSourceAccountsRequest {
+    
+    EventSourceName: string | undefined;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListPartnerEventSourceAccountsRequest {
+    
+    const filterSensitiveLog: (obj: ListPartnerEventSourceAccountsRequest) => any;
+}
+
+export interface PartnerEventSourceAccount {
+    
+    Account?: string;
+    
+    CreationTime?: Date;
+    
+    ExpirationTime?: Date;
+    
+    State?: EventSourceState | string;
+}
+export declare namespace PartnerEventSourceAccount {
+    
+    const filterSensitiveLog: (obj: PartnerEventSourceAccount) => any;
+}
+export interface ListPartnerEventSourceAccountsResponse {
+    
+    PartnerEventSourceAccounts?: PartnerEventSourceAccount[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPartnerEventSourceAccountsResponse {
+    
+    const filterSensitiveLog: (obj: ListPartnerEventSourceAccountsResponse) => any;
+}
+export interface ListPartnerEventSourcesRequest {
+    
+    NamePrefix: string | undefined;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListPartnerEventSourcesRequest {
+    
+    const filterSensitiveLog: (obj: ListPartnerEventSourcesRequest) => any;
+}
+
+export interface PartnerEventSource {
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace PartnerEventSource {
+    
+    const filterSensitiveLog: (obj: PartnerEventSource) => any;
+}
+export interface ListPartnerEventSourcesResponse {
+    
+    PartnerEventSources?: PartnerEventSource[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPartnerEventSourcesResponse {
+    
+    const filterSensitiveLog: (obj: ListPartnerEventSourcesResponse) => any;
+}
+export interface ListReplaysRequest {
+    
+    NamePrefix?: string;
+    
+    State?: ReplayState | string;
+    
+    EventSourceArn?: string;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListReplaysRequest {
+    
+    const filterSensitiveLog: (obj: ListReplaysRequest) => any;
+}
+
+export interface Replay {
+    
+    ReplayName?: string;
+    
+    EventSourceArn?: string;
+    
+    State?: ReplayState | string;
+    
+    StateReason?: string;
+    
+    EventStartTime?: Date;
+    
+    EventEndTime?: Date;
+    
+    EventLastReplayedTime?: Date;
+    
+    ReplayStartTime?: Date;
+    
+    ReplayEndTime?: Date;
+}
+export declare namespace Replay {
+    
+    const filterSensitiveLog: (obj: Replay) => any;
+}
+export interface ListReplaysResponse {
+    
+    Replays?: Replay[];
+    
+    NextToken?: string;
+}
+export declare namespace ListReplaysResponse {
+    
+    const filterSensitiveLog: (obj: ListReplaysResponse) => any;
+}
+export interface ListRuleNamesByTargetRequest {
+    
+    TargetArn: string | undefined;
+    
+    EventBusName?: string;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListRuleNamesByTargetRequest {
+    
+    const filterSensitiveLog: (obj: ListRuleNamesByTargetRequest) => any;
+}
+export interface ListRuleNamesByTargetResponse {
+    
+    RuleNames?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListRuleNamesByTargetResponse {
+    
+    const filterSensitiveLog: (obj: ListRuleNamesByTargetResponse) => any;
+}
+export interface ListRulesRequest {
+    
+    NamePrefix?: string;
+    
+    EventBusName?: string;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListRulesRequest {
+    
+    const filterSensitiveLog: (obj: ListRulesRequest) => any;
+}
+
+export interface Rule {
+    
+    Name?: string;
+    
+    Arn?: string;
+    
+    EventPattern?: string;
+    
+    State?: RuleState | string;
+    
+    Description?: string;
+    
+    ScheduleExpression?: string;
+    
+    RoleArn?: string;
+    
+    ManagedBy?: string;
+    
+    EventBusName?: string;
+}
+export declare namespace Rule {
+    
+    const filterSensitiveLog: (obj: Rule) => any;
+}
+export interface ListRulesResponse {
+    
+    Rules?: Rule[];
+    
+    NextToken?: string;
+}
+export declare namespace ListRulesResponse {
+    
+    const filterSensitiveLog: (obj: ListRulesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListTargetsByRuleRequest {
+    
+    Rule: string | undefined;
+    
+    EventBusName?: string;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace ListTargetsByRuleRequest {
+    
+    const filterSensitiveLog: (obj: ListTargetsByRuleRequest) => any;
+}
+
+export interface BatchArrayProperties {
+    
+    Size?: number;
+}
+export declare namespace BatchArrayProperties {
+    
+    const filterSensitiveLog: (obj: BatchArrayProperties) => any;
+}
+
+export interface BatchRetryStrategy {
+    
+    Attempts?: number;
+}
+export declare namespace BatchRetryStrategy {
+    
+    const filterSensitiveLog: (obj: BatchRetryStrategy) => any;
+}
+
+export interface BatchParameters {
+    
+    JobDefinition: string | undefined;
+    
+    JobName: string | undefined;
+    
+    ArrayProperties?: BatchArrayProperties;
+    
+    RetryStrategy?: BatchRetryStrategy;
+}
+export declare namespace BatchParameters {
+    
+    const filterSensitiveLog: (obj: BatchParameters) => any;
+}
+
+export interface DeadLetterConfig {
+    
+    Arn?: string;
+}
+export declare namespace DeadLetterConfig {
+    
+    const filterSensitiveLog: (obj: DeadLetterConfig) => any;
+}
+
+export interface CapacityProviderStrategyItem {
+    
+    capacityProvider: string | undefined;
+    
+    weight?: number;
+    
+    base?: number;
+}
+export declare namespace CapacityProviderStrategyItem {
+    
+    const filterSensitiveLog: (obj: CapacityProviderStrategyItem) => any;
+}
+export declare enum LaunchType {
+    EC2 = "EC2",
+    EXTERNAL = "EXTERNAL",
+    FARGATE = "FARGATE"
+}
+
+export interface AwsVpcConfiguration {
+    
+    Subnets: string[] | undefined;
+    
+    SecurityGroups?: string[];
+    
+    AssignPublicIp?: AssignPublicIp | string;
+}
+export declare namespace AwsVpcConfiguration {
+    
+    const filterSensitiveLog: (obj: AwsVpcConfiguration) => any;
+}
+
+export interface NetworkConfiguration {
+    
+    awsvpcConfiguration?: AwsVpcConfiguration;
+}
+export declare namespace NetworkConfiguration {
+    
+    const filterSensitiveLog: (obj: NetworkConfiguration) => any;
+}
+export declare enum PlacementConstraintType {
+    DISTINCT_INSTANCE = "distinctInstance",
+    MEMBER_OF = "memberOf"
+}
+
+export interface PlacementConstraint {
+    
+    type?: PlacementConstraintType | string;
+    
+    expression?: string;
+}
+export declare namespace PlacementConstraint {
+    
+    const filterSensitiveLog: (obj: PlacementConstraint) => any;
+}
+export declare enum PlacementStrategyType {
+    BINPACK = "binpack",
+    RANDOM = "random",
+    SPREAD = "spread"
+}
+
+export interface PlacementStrategy {
+    
+    type?: PlacementStrategyType | string;
+    
+    field?: string;
+}
+export declare namespace PlacementStrategy {
+    
+    const filterSensitiveLog: (obj: PlacementStrategy) => any;
+}
+export declare enum PropagateTags {
+    TASK_DEFINITION = "TASK_DEFINITION"
+}
+
+export interface EcsParameters {
+    
+    TaskDefinitionArn: string | undefined;
+    
+    TaskCount?: number;
+    
+    LaunchType?: LaunchType | string;
+    
+    NetworkConfiguration?: NetworkConfiguration;
+    
+    PlatformVersion?: string;
+    
+    Group?: string;
+    
+    CapacityProviderStrategy?: CapacityProviderStrategyItem[];
+    
+    EnableECSManagedTags?: boolean;
+    
+    EnableExecuteCommand?: boolean;
+    
+    PlacementConstraints?: PlacementConstraint[];
+    
+    PlacementStrategy?: PlacementStrategy[];
+    
+    PropagateTags?: PropagateTags | string;
+    
+    ReferenceId?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace EcsParameters {
+    
+    const filterSensitiveLog: (obj: EcsParameters) => any;
+}
+
+export interface HttpParameters {
+    
+    PathParameterValues?: string[];
+    
+    HeaderParameters?: {
+        [key: string]: string;
+    };
+    
+    QueryStringParameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace HttpParameters {
+    
+    const filterSensitiveLog: (obj: HttpParameters) => any;
+}
+
+export interface InputTransformer {
+    
+    InputPathsMap?: {
+        [key: string]: string;
+    };
+    
+    InputTemplate: string | undefined;
+}
+export declare namespace InputTransformer {
+    
+    const filterSensitiveLog: (obj: InputTransformer) => any;
+}
+
+export interface KinesisParameters {
+    
+    PartitionKeyPath: string | undefined;
+}
+export declare namespace KinesisParameters {
+    
+    const filterSensitiveLog: (obj: KinesisParameters) => any;
+}
+
+export interface RedshiftDataParameters {
+    
+    SecretManagerArn?: string;
+    
+    Database: string | undefined;
+    
+    DbUser?: string;
+    
+    Sql: string | undefined;
+    
+    StatementName?: string;
+    
+    WithEvent?: boolean;
+}
+export declare namespace RedshiftDataParameters {
+    
+    const filterSensitiveLog: (obj: RedshiftDataParameters) => any;
+}
+
+export interface RetryPolicy {
+    
+    MaximumRetryAttempts?: number;
+    
+    MaximumEventAgeInSeconds?: number;
+}
+export declare namespace RetryPolicy {
+    
+    const filterSensitiveLog: (obj: RetryPolicy) => any;
+}
+
+export interface RunCommandTarget {
+    
+    Key: string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace RunCommandTarget {
+    
+    const filterSensitiveLog: (obj: RunCommandTarget) => any;
+}
+
+export interface RunCommandParameters {
+    
+    RunCommandTargets: RunCommandTarget[] | undefined;
+}
+export declare namespace RunCommandParameters {
+    
+    const filterSensitiveLog: (obj: RunCommandParameters) => any;
+}
+
+export interface SageMakerPipelineParameter {
+    
+    Name: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace SageMakerPipelineParameter {
+    
+    const filterSensitiveLog: (obj: SageMakerPipelineParameter) => any;
+}
+
+export interface SageMakerPipelineParameters {
+    
+    PipelineParameterList?: SageMakerPipelineParameter[];
+}
+export declare namespace SageMakerPipelineParameters {
+    
+    const filterSensitiveLog: (obj: SageMakerPipelineParameters) => any;
+}
+
+export interface SqsParameters {
+    
+    MessageGroupId?: string;
+}
+export declare namespace SqsParameters {
+    
+    const filterSensitiveLog: (obj: SqsParameters) => any;
+}
+
+export interface Target {
+    
+    Id: string | undefined;
+    
+    Arn: string | undefined;
+    
+    RoleArn?: string;
+    
+    Input?: string;
+    
+    InputPath?: string;
+    
+    InputTransformer?: InputTransformer;
+    
+    KinesisParameters?: KinesisParameters;
+    
+    RunCommandParameters?: RunCommandParameters;
+    
+    EcsParameters?: EcsParameters;
+    
+    BatchParameters?: BatchParameters;
+    
+    SqsParameters?: SqsParameters;
+    
+    HttpParameters?: HttpParameters;
+    
+    RedshiftDataParameters?: RedshiftDataParameters;
+    
+    SageMakerPipelineParameters?: SageMakerPipelineParameters;
+    
+    DeadLetterConfig?: DeadLetterConfig;
+    
+    RetryPolicy?: RetryPolicy;
+}
+export declare namespace Target {
+    
+    const filterSensitiveLog: (obj: Target) => any;
+}
+export interface ListTargetsByRuleResponse {
+    
+    Targets?: Target[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTargetsByRuleResponse {
+    
+    const filterSensitiveLog: (obj: ListTargetsByRuleResponse) => any;
+}
+
+export interface PutEventsRequestEntry {
+    
+    Time?: Date;
+    
+    Source?: string;
+    
+    Resources?: string[];
+    
+    DetailType?: string;
+    
+    Detail?: string;
+    
+    EventBusName?: string;
+    
+    TraceHeader?: string;
+}
+export declare namespace PutEventsRequestEntry {
+    
+    const filterSensitiveLog: (obj: PutEventsRequestEntry) => any;
+}
+export interface PutEventsRequest {
+    
+    Entries: PutEventsRequestEntry[] | undefined;
+}
+export declare namespace PutEventsRequest {
+    
+    const filterSensitiveLog: (obj: PutEventsRequest) => any;
+}
+
+export interface PutEventsResultEntry {
+    
+    EventId?: string;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace PutEventsResultEntry {
+    
+    const filterSensitiveLog: (obj: PutEventsResultEntry) => any;
+}
+export interface PutEventsResponse {
+    
+    FailedEntryCount?: number;
+    
+    Entries?: PutEventsResultEntry[];
+}
+export declare namespace PutEventsResponse {
+    
+    const filterSensitiveLog: (obj: PutEventsResponse) => any;
+}
+
+export interface PutPartnerEventsRequestEntry {
+    
+    Time?: Date;
+    
+    Source?: string;
+    
+    Resources?: string[];
+    
+    DetailType?: string;
+    
+    Detail?: string;
+}
+export declare namespace PutPartnerEventsRequestEntry {
+    
+    const filterSensitiveLog: (obj: PutPartnerEventsRequestEntry) => any;
+}
+export interface PutPartnerEventsRequest {
+    
+    Entries: PutPartnerEventsRequestEntry[] | undefined;
+}
+export declare namespace PutPartnerEventsRequest {
+    
+    const filterSensitiveLog: (obj: PutPartnerEventsRequest) => any;
+}
+
+export interface PutPartnerEventsResultEntry {
+    
+    EventId?: string;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace PutPartnerEventsResultEntry {
+    
+    const filterSensitiveLog: (obj: PutPartnerEventsResultEntry) => any;
+}
+export interface PutPartnerEventsResponse {
+    
+    FailedEntryCount?: number;
+    
+    Entries?: PutPartnerEventsResultEntry[];
+}
+export declare namespace PutPartnerEventsResponse {
+    
+    const filterSensitiveLog: (obj: PutPartnerEventsResponse) => any;
+}
+
+export interface PolicyLengthExceededException extends __SmithyException, $MetadataBearer {
+    name: "PolicyLengthExceededException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace PolicyLengthExceededException {
+    
+    const filterSensitiveLog: (obj: PolicyLengthExceededException) => any;
+}
+
+export interface Condition {
+    
+    Type: string | undefined;
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Condition {
+    
+    const filterSensitiveLog: (obj: Condition) => any;
+}
+export interface PutPermissionRequest {
+    
+    EventBusName?: string;
+    
+    Action?: string;
+    
+    Principal?: string;
+    
+    StatementId?: string;
+    
+    Condition?: Condition;
+    
+    Policy?: string;
+}
+export declare namespace PutPermissionRequest {
+    
+    const filterSensitiveLog: (obj: PutPermissionRequest) => any;
+}
+export interface PutRuleRequest {
+    
+    Name: string | undefined;
+    
+    ScheduleExpression?: string;
+    
+    EventPattern?: string;
+    
+    State?: RuleState | string;
+    
+    Description?: string;
+    
+    RoleArn?: string;
+    
+    Tags?: Tag[];
+    
+    EventBusName?: string;
+}
+export declare namespace PutRuleRequest {
+    
+    const filterSensitiveLog: (obj: PutRuleRequest) => any;
+}
+export interface PutRuleResponse {
+    
+    RuleArn?: string;
+}
+export declare namespace PutRuleResponse {
+    
+    const filterSensitiveLog: (obj: PutRuleResponse) => any;
+}
+export interface PutTargetsRequest {
+    
+    Rule: string | undefined;
+    
+    EventBusName?: string;
+    
+    Targets: Target[] | undefined;
+}
+export declare namespace PutTargetsRequest {
+    
+    const filterSensitiveLog: (obj: PutTargetsRequest) => any;
+}
+
+export interface PutTargetsResultEntry {
+    
+    TargetId?: string;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace PutTargetsResultEntry {
+    
+    const filterSensitiveLog: (obj: PutTargetsResultEntry) => any;
+}
+export interface PutTargetsResponse {
+    
+    FailedEntryCount?: number;
+    
+    FailedEntries?: PutTargetsResultEntry[];
+}
+export declare namespace PutTargetsResponse {
+    
+    const filterSensitiveLog: (obj: PutTargetsResponse) => any;
+}
+export interface RemovePermissionRequest {
+    
+    StatementId?: string;
+    
+    RemoveAllPermissions?: boolean;
+    
+    EventBusName?: string;
+}
+export declare namespace RemovePermissionRequest {
+    
+    const filterSensitiveLog: (obj: RemovePermissionRequest) => any;
+}
+export interface RemoveTargetsRequest {
+    
+    Rule: string | undefined;
+    
+    EventBusName?: string;
+    
+    Ids: string[] | undefined;
+    
+    Force?: boolean;
+}
+export declare namespace RemoveTargetsRequest {
+    
+    const filterSensitiveLog: (obj: RemoveTargetsRequest) => any;
+}
+
+export interface RemoveTargetsResultEntry {
+    
+    TargetId?: string;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace RemoveTargetsResultEntry {
+    
+    const filterSensitiveLog: (obj: RemoveTargetsResultEntry) => any;
+}
+export interface RemoveTargetsResponse {
+    
+    FailedEntryCount?: number;
+    
+    FailedEntries?: RemoveTargetsResultEntry[];
+}
+export declare namespace RemoveTargetsResponse {
+    
+    const filterSensitiveLog: (obj: RemoveTargetsResponse) => any;
+}
+export interface StartReplayRequest {
+    
+    ReplayName: string | undefined;
+    
+    Description?: string;
+    
+    EventSourceArn: string | undefined;
+    
+    EventStartTime: Date | undefined;
+    
+    EventEndTime: Date | undefined;
+    
+    Destination: ReplayDestination | undefined;
+}
+export declare namespace StartReplayRequest {
+    
+    const filterSensitiveLog: (obj: StartReplayRequest) => any;
+}
+export interface StartReplayResponse {
+    
+    ReplayArn?: string;
+    
+    State?: ReplayState | string;
+    
+    StateReason?: string;
+    
+    ReplayStartTime?: Date;
+}
+export declare namespace StartReplayResponse {
+    
+    const filterSensitiveLog: (obj: StartReplayResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceARN: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface TestEventPatternRequest {
+    
+    EventPattern: string | undefined;
+    
+    Event: string | undefined;
+}
+export declare namespace TestEventPatternRequest {
+    
+    const filterSensitiveLog: (obj: TestEventPatternRequest) => any;
+}
+export interface TestEventPatternResponse {
+    
+    Result?: boolean;
+}
+export declare namespace TestEventPatternResponse {
+    
+    const filterSensitiveLog: (obj: TestEventPatternResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceARN: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateApiDestinationRequest {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    ConnectionArn?: string;
+    
+    InvocationEndpoint?: string;
+    
+    HttpMethod?: ApiDestinationHttpMethod | string;
+    
+    InvocationRateLimitPerSecond?: number;
+}
+export declare namespace UpdateApiDestinationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateApiDestinationRequest) => any;
+}
+export interface UpdateApiDestinationResponse {
+    
+    ApiDestinationArn?: string;
+    
+    ApiDestinationState?: ApiDestinationState | string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace UpdateApiDestinationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateApiDestinationResponse) => any;
+}
+export interface UpdateArchiveRequest {
+    
+    ArchiveName: string | undefined;
+    
+    Description?: string;
+    
+    EventPattern?: string;
+    
+    RetentionDays?: number;
+}
+export declare namespace UpdateArchiveRequest {
+    
+    const filterSensitiveLog: (obj: UpdateArchiveRequest) => any;
+}
+export interface UpdateArchiveResponse {
+    
+    ArchiveArn?: string;
+    
+    State?: ArchiveState | string;
+    
+    StateReason?: string;
+    
+    CreationTime?: Date;
+}
+export declare namespace UpdateArchiveResponse {
+    
+    const filterSensitiveLog: (obj: UpdateArchiveResponse) => any;
+}
+
+export interface UpdateConnectionApiKeyAuthRequestParameters {
+    
+    ApiKeyName?: string;
+    
+    ApiKeyValue?: string;
+}
+export declare namespace UpdateConnectionApiKeyAuthRequestParameters {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionApiKeyAuthRequestParameters) => any;
+}
+
+export interface UpdateConnectionBasicAuthRequestParameters {
+    
+    Username?: string;
+    
+    Password?: string;
+}
+export declare namespace UpdateConnectionBasicAuthRequestParameters {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionBasicAuthRequestParameters) => any;
+}
+
+export interface UpdateConnectionOAuthClientRequestParameters {
+    
+    ClientID?: string;
+    
+    ClientSecret?: string;
+}
+export declare namespace UpdateConnectionOAuthClientRequestParameters {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionOAuthClientRequestParameters) => any;
+}
+
+export interface UpdateConnectionOAuthRequestParameters {
+    
+    ClientParameters?: UpdateConnectionOAuthClientRequestParameters;
+    
+    AuthorizationEndpoint?: string;
+    
+    HttpMethod?: ConnectionOAuthHttpMethod | string;
+    
+    OAuthHttpParameters?: ConnectionHttpParameters;
+}
+export declare namespace UpdateConnectionOAuthRequestParameters {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionOAuthRequestParameters) => any;
+}
+
+export interface UpdateConnectionAuthRequestParameters {
+    
+    BasicAuthParameters?: UpdateConnectionBasicAuthRequestParameters;
+    
+    OAuthParameters?: UpdateConnectionOAuthRequestParameters;
+    
+    ApiKeyAuthParameters?: UpdateConnectionApiKeyAuthRequestParameters;
+    
+    InvocationHttpParameters?: ConnectionHttpParameters;
+}
+export declare namespace UpdateConnectionAuthRequestParameters {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionAuthRequestParameters) => any;
+}
+export interface UpdateConnectionRequest {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    AuthorizationType?: ConnectionAuthorizationType | string;
+    
+    AuthParameters?: UpdateConnectionAuthRequestParameters;
+}
+export declare namespace UpdateConnectionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionRequest) => any;
+}
+export interface UpdateConnectionResponse {
+    
+    ConnectionArn?: string;
+    
+    ConnectionState?: ConnectionState | string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    LastAuthorizedTime?: Date;
+}
+export declare namespace UpdateConnectionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionResponse) => any;
+}