import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
import { SensitiveString } from "../sensitive.js";
const ns = T.XmlNamespace("http://events.amazonaws.com/doc/2015-10-07");
const svc = T.AwsApiService({
    sdkId: "CloudWatch Events",
    serviceShapeName: "AWSEvents",
});
const auth = T.AwsAuthSigv4({ name: "events" });
const ver = T.ServiceVersion("2015-10-07");
const proto = T.AwsProtocolsAwsJson1_1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://events-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        if (Region === "us-gov-east-1") {
                            return e("https://events.us-gov-east-1.amazonaws.com");
                        }
                        if (Region === "us-gov-west-1") {
                            return e("https://events.us-gov-west-1.amazonaws.com");
                        }
                        return e(`https://events-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://events.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://events.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const ActivateEventSourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ActivateEventSourceRequest",
});
export const ActivateEventSourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "ActivateEventSourceResponse",
});
export const CancelReplayRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ReplayName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelReplayRequest",
});
export const ReplayState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CancelReplayResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReplayArn: S.optional(S.String),
    State: S.optional(ReplayState),
    StateReason: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "CancelReplayResponse",
});
export const ApiDestinationHttpMethod = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CreateApiDestinationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    Description: S.optional(S.String),
    ConnectionArn: S.String,
    InvocationEndpoint: S.String,
    HttpMethod: ApiDestinationHttpMethod,
    InvocationRateLimitPerSecond: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateApiDestinationRequest",
});
export const ApiDestinationState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CreateApiDestinationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ApiDestinationArn: S.optional(S.String),
    ApiDestinationState: S.optional(ApiDestinationState),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "CreateApiDestinationResponse",
});
export const CreateArchiveRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ArchiveName: S.String,
    EventSourceArn: S.String,
    Description: S.optional(S.String),
    EventPattern: S.optional(S.String),
    RetentionDays: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateArchiveRequest",
});
export const ArchiveState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CreateArchiveResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ArchiveArn: S.optional(S.String),
    State: S.optional(ArchiveState),
    StateReason: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "CreateArchiveResponse",
});
export const ConnectionAuthorizationType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CreateConnectionBasicAuthRequestParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Username: S.String, Password: SensitiveString })).annotate({
    identifier: "CreateConnectionBasicAuthRequestParameters",
});
export const CreateConnectionOAuthClientRequestParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ClientID: S.String, ClientSecret: SensitiveString })).annotate({
    identifier: "CreateConnectionOAuthClientRequestParameters",
});
export const ConnectionOAuthHttpMethod = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ConnectionHeaderParameter = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Key: S.optional(S.String),
    Value: S.optional(SensitiveString),
    IsValueSecret: S.optional(S.Boolean),
})).annotate({
    identifier: "ConnectionHeaderParameter",
});
export const ConnectionHeaderParametersList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ConnectionHeaderParameter);
export const ConnectionQueryStringParameter = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Key: S.optional(S.String),
    Value: S.optional(SensitiveString),
    IsValueSecret: S.optional(S.Boolean),
})).annotate({
    identifier: "ConnectionQueryStringParameter",
});
export const ConnectionQueryStringParametersList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ConnectionQueryStringParameter);
export const ConnectionBodyParameter = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Key: S.optional(S.String),
    Value: S.optional(SensitiveString),
    IsValueSecret: S.optional(S.Boolean),
})).annotate({
    identifier: "ConnectionBodyParameter",
});
export const ConnectionBodyParametersList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ConnectionBodyParameter);
export const ConnectionHttpParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    HeaderParameters: S.optional(ConnectionHeaderParametersList),
    QueryStringParameters: S.optional(ConnectionQueryStringParametersList),
    BodyParameters: S.optional(ConnectionBodyParametersList),
})).annotate({
    identifier: "ConnectionHttpParameters",
});
export const CreateConnectionOAuthRequestParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClientParameters: CreateConnectionOAuthClientRequestParameters,
    AuthorizationEndpoint: S.String,
    HttpMethod: ConnectionOAuthHttpMethod,
    OAuthHttpParameters: S.optional(ConnectionHttpParameters),
})).annotate({
    identifier: "CreateConnectionOAuthRequestParameters",
});
export const CreateConnectionApiKeyAuthRequestParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ApiKeyName: S.String, ApiKeyValue: SensitiveString })).annotate({
    identifier: "CreateConnectionApiKeyAuthRequestParameters",
});
export const CreateConnectionAuthRequestParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BasicAuthParameters: S.optional(CreateConnectionBasicAuthRequestParameters),
    OAuthParameters: S.optional(CreateConnectionOAuthRequestParameters),
    ApiKeyAuthParameters: S.optional(CreateConnectionApiKeyAuthRequestParameters),
    InvocationHttpParameters: S.optional(ConnectionHttpParameters),
})).annotate({
    identifier: "CreateConnectionAuthRequestParameters",
});
export const CreateConnectionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    Description: S.optional(S.String),
    AuthorizationType: ConnectionAuthorizationType,
    AuthParameters: CreateConnectionAuthRequestParameters,
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateConnectionRequest",
});
export const ConnectionState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CreateConnectionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConnectionArn: S.optional(S.String),
    ConnectionState: S.optional(ConnectionState),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "CreateConnectionResponse",
});
export const Tag = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Key: S.String, Value: S.String })).annotate({ identifier: "Tag" });
export const TagList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Tag);
export const CreateEventBusRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    EventSourceName: S.optional(S.String),
    Tags: S.optional(TagList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateEventBusRequest",
});
export const CreateEventBusResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EventBusArn: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "CreateEventBusResponse",
});
export const CreatePartnerEventSourceRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String, Account: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreatePartnerEventSourceRequest",
});
export const CreatePartnerEventSourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EventSourceArn: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "CreatePartnerEventSourceResponse",
});
export const DeactivateEventSourceRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeactivateEventSourceRequest",
});
export const DeactivateEventSourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "DeactivateEventSourceResponse",
});
export const DeauthorizeConnectionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeauthorizeConnectionRequest",
});
export const DeauthorizeConnectionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConnectionArn: S.optional(S.String),
    ConnectionState: S.optional(ConnectionState),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastAuthorizedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "DeauthorizeConnectionResponse",
});
export const DeleteApiDestinationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteApiDestinationRequest",
});
export const DeleteApiDestinationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "DeleteApiDestinationResponse",
});
export const DeleteArchiveRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ArchiveName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteArchiveRequest",
});
export const DeleteArchiveResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "DeleteArchiveResponse",
});
export const DeleteConnectionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteConnectionRequest",
});
export const DeleteConnectionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConnectionArn: S.optional(S.String),
    ConnectionState: S.optional(ConnectionState),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastAuthorizedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "DeleteConnectionResponse",
});
export const DeleteEventBusRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteEventBusRequest",
});
export const DeleteEventBusResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "DeleteEventBusResponse",
});
export const DeletePartnerEventSourceRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String, Account: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeletePartnerEventSourceRequest",
});
export const DeletePartnerEventSourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "DeletePartnerEventSourceResponse",
});
export const DeleteRuleRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    EventBusName: S.optional(S.String),
    Force: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteRuleRequest",
});
export const DeleteRuleResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "DeleteRuleResponse",
});
export const DescribeApiDestinationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeApiDestinationRequest",
});
export const DescribeApiDestinationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ApiDestinationArn: S.optional(S.String),
    Name: S.optional(S.String),
    Description: S.optional(S.String),
    ApiDestinationState: S.optional(ApiDestinationState),
    ConnectionArn: S.optional(S.String),
    InvocationEndpoint: S.optional(S.String),
    HttpMethod: S.optional(ApiDestinationHttpMethod),
    InvocationRateLimitPerSecond: S.optional(S.Number),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "DescribeApiDestinationResponse",
});
export const DescribeArchiveRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ArchiveName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeArchiveRequest",
});
export const DescribeArchiveResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ArchiveArn: S.optional(S.String),
    ArchiveName: S.optional(S.String),
    EventSourceArn: S.optional(S.String),
    Description: S.optional(S.String),
    EventPattern: S.optional(S.String),
    State: S.optional(ArchiveState),
    StateReason: S.optional(S.String),
    RetentionDays: S.optional(S.Number),
    SizeBytes: S.optional(S.Number),
    EventCount: S.optional(S.Number),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "DescribeArchiveResponse",
});
export const DescribeConnectionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeConnectionRequest",
});
export const ConnectionBasicAuthResponseParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Username: S.optional(S.String) })).annotate({
    identifier: "ConnectionBasicAuthResponseParameters",
});
export const ConnectionOAuthClientResponseParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ClientID: S.optional(S.String) })).annotate({
    identifier: "ConnectionOAuthClientResponseParameters",
});
export const ConnectionOAuthResponseParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClientParameters: S.optional(ConnectionOAuthClientResponseParameters),
    AuthorizationEndpoint: S.optional(S.String),
    HttpMethod: S.optional(ConnectionOAuthHttpMethod),
    OAuthHttpParameters: S.optional(ConnectionHttpParameters),
})).annotate({
    identifier: "ConnectionOAuthResponseParameters",
});
export const ConnectionApiKeyAuthResponseParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ApiKeyName: S.optional(S.String) })).annotate({
    identifier: "ConnectionApiKeyAuthResponseParameters",
});
export const ConnectionAuthResponseParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BasicAuthParameters: S.optional(ConnectionBasicAuthResponseParameters),
    OAuthParameters: S.optional(ConnectionOAuthResponseParameters),
    ApiKeyAuthParameters: S.optional(ConnectionApiKeyAuthResponseParameters),
    InvocationHttpParameters: S.optional(ConnectionHttpParameters),
})).annotate({
    identifier: "ConnectionAuthResponseParameters",
});
export const DescribeConnectionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConnectionArn: S.optional(S.String),
    Name: S.optional(S.String),
    Description: S.optional(S.String),
    ConnectionState: S.optional(ConnectionState),
    StateReason: S.optional(S.String),
    AuthorizationType: S.optional(ConnectionAuthorizationType),
    SecretArn: S.optional(S.String),
    AuthParameters: S.optional(ConnectionAuthResponseParameters),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastAuthorizedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "DescribeConnectionResponse",
});
export const DescribeEventBusRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.optional(S.String) }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeEventBusRequest",
});
export const DescribeEventBusResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Arn: S.optional(S.String),
    Policy: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "DescribeEventBusResponse",
});
export const DescribeEventSourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeEventSourceRequest",
});
export const EventSourceState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DescribeEventSourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Arn: S.optional(S.String),
    CreatedBy: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    ExpirationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Name: S.optional(S.String),
    State: S.optional(EventSourceState),
}).pipe(ns)).annotate({
    identifier: "DescribeEventSourceResponse",
});
export const DescribePartnerEventSourceRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribePartnerEventSourceRequest",
});
export const DescribePartnerEventSourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Arn: S.optional(S.String), Name: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "DescribePartnerEventSourceResponse",
});
export const DescribeReplayRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ReplayName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeReplayRequest",
});
export const ReplayDestinationFilters = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ReplayDestination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Arn: S.String, FilterArns: S.optional(ReplayDestinationFilters) })).annotate({
    identifier: "ReplayDestination",
});
export const DescribeReplayResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReplayName: S.optional(S.String),
    ReplayArn: S.optional(S.String),
    Description: S.optional(S.String),
    State: S.optional(ReplayState),
    StateReason: S.optional(S.String),
    EventSourceArn: S.optional(S.String),
    Destination: S.optional(ReplayDestination),
    EventStartTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    EventEndTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    EventLastReplayedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    ReplayStartTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    ReplayEndTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "DescribeReplayResponse",
});
export const DescribeRuleRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String, EventBusName: S.optional(S.String) }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeRuleRequest",
});
export const RuleState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DescribeRuleResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Arn: S.optional(S.String),
    EventPattern: S.optional(S.String),
    ScheduleExpression: S.optional(S.String),
    State: S.optional(RuleState),
    Description: S.optional(S.String),
    RoleArn: S.optional(S.String),
    ManagedBy: S.optional(S.String),
    EventBusName: S.optional(S.String),
    CreatedBy: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "DescribeRuleResponse",
});
export const DisableRuleRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String, EventBusName: S.optional(S.String) }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DisableRuleRequest",
});
export const DisableRuleResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "DisableRuleResponse",
});
export const EnableRuleRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String, EventBusName: S.optional(S.String) }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "EnableRuleRequest",
});
export const EnableRuleResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "EnableRuleResponse",
});
export const ListApiDestinationsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NamePrefix: S.optional(S.String),
    ConnectionArn: S.optional(S.String),
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListApiDestinationsRequest",
});
export const ApiDestination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ApiDestinationArn: S.optional(S.String),
    Name: S.optional(S.String),
    ApiDestinationState: S.optional(ApiDestinationState),
    ConnectionArn: S.optional(S.String),
    InvocationEndpoint: S.optional(S.String),
    HttpMethod: S.optional(ApiDestinationHttpMethod),
    InvocationRateLimitPerSecond: S.optional(S.Number),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "ApiDestination" });
export const ApiDestinationResponseList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ApiDestination);
export const ListApiDestinationsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ApiDestinations: S.optional(ApiDestinationResponseList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListApiDestinationsResponse",
});
export const ListArchivesRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NamePrefix: S.optional(S.String),
    EventSourceArn: S.optional(S.String),
    State: S.optional(ArchiveState),
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListArchivesRequest",
});
export const Archive = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ArchiveName: S.optional(S.String),
    EventSourceArn: S.optional(S.String),
    State: S.optional(ArchiveState),
    StateReason: S.optional(S.String),
    RetentionDays: S.optional(S.Number),
    SizeBytes: S.optional(S.Number),
    EventCount: S.optional(S.Number),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "Archive" });
export const ArchiveResponseList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Archive);
export const ListArchivesResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Archives: S.optional(ArchiveResponseList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListArchivesResponse",
});
export const ListConnectionsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NamePrefix: S.optional(S.String),
    ConnectionState: S.optional(ConnectionState),
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListConnectionsRequest",
});
export const Connection = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConnectionArn: S.optional(S.String),
    Name: S.optional(S.String),
    ConnectionState: S.optional(ConnectionState),
    StateReason: S.optional(S.String),
    AuthorizationType: S.optional(ConnectionAuthorizationType),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastAuthorizedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "Connection" });
export const ConnectionResponseList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(Connection);
export const ListConnectionsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Connections: S.optional(ConnectionResponseList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListConnectionsResponse",
});
export const ListEventBusesRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NamePrefix: S.optional(S.String),
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListEventBusesRequest",
});
export const EventBus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Arn: S.optional(S.String),
    Policy: S.optional(S.String),
})).annotate({ identifier: "EventBus" });
export const EventBusList = /*@__PURE__*/ /*#__PURE__*/ S.Array(EventBus);
export const ListEventBusesResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EventBuses: S.optional(EventBusList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListEventBusesResponse",
});
export const ListEventSourcesRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NamePrefix: S.optional(S.String),
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListEventSourcesRequest",
});
export const EventSource = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Arn: S.optional(S.String),
    CreatedBy: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    ExpirationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Name: S.optional(S.String),
    State: S.optional(EventSourceState),
})).annotate({ identifier: "EventSource" });
export const EventSourceList = /*@__PURE__*/ /*#__PURE__*/ S.Array(EventSource);
export const ListEventSourcesResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EventSources: S.optional(EventSourceList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListEventSourcesResponse",
});
export const ListPartnerEventSourceAccountsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EventSourceName: S.String,
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListPartnerEventSourceAccountsRequest",
});
export const PartnerEventSourceAccount = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Account: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    ExpirationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    State: S.optional(EventSourceState),
})).annotate({
    identifier: "PartnerEventSourceAccount",
});
export const PartnerEventSourceAccountList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PartnerEventSourceAccount);
export const ListPartnerEventSourceAccountsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PartnerEventSourceAccounts: S.optional(PartnerEventSourceAccountList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListPartnerEventSourceAccountsResponse",
});
export const ListPartnerEventSourcesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NamePrefix: S.String,
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListPartnerEventSourcesRequest",
});
export const PartnerEventSource = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Arn: S.optional(S.String), Name: S.optional(S.String) })).annotate({
    identifier: "PartnerEventSource",
});
export const PartnerEventSourceList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PartnerEventSource);
export const ListPartnerEventSourcesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PartnerEventSources: S.optional(PartnerEventSourceList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListPartnerEventSourcesResponse",
});
export const ListReplaysRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NamePrefix: S.optional(S.String),
    State: S.optional(ReplayState),
    EventSourceArn: S.optional(S.String),
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListReplaysRequest",
});
export const Replay = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReplayName: S.optional(S.String),
    EventSourceArn: S.optional(S.String),
    State: S.optional(ReplayState),
    StateReason: S.optional(S.String),
    EventStartTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    EventEndTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    EventLastReplayedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    ReplayStartTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    ReplayEndTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "Replay" });
export const ReplayList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Replay);
export const ListReplaysResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Replays: S.optional(ReplayList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListReplaysResponse",
});
export const ListRuleNamesByTargetRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    TargetArn: S.String,
    EventBusName: S.optional(S.String),
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListRuleNamesByTargetRequest",
});
export const RuleNameList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ListRuleNamesByTargetResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    RuleNames: S.optional(RuleNameList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListRuleNamesByTargetResponse",
});
export const ListRulesRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NamePrefix: S.optional(S.String),
    EventBusName: S.optional(S.String),
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListRulesRequest",
});
export const Rule = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Arn: S.optional(S.String),
    EventPattern: S.optional(S.String),
    State: S.optional(RuleState),
    Description: S.optional(S.String),
    ScheduleExpression: S.optional(S.String),
    RoleArn: S.optional(S.String),
    ManagedBy: S.optional(S.String),
    EventBusName: S.optional(S.String),
})).annotate({ identifier: "Rule" });
export const RuleResponseList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Rule);
export const ListRulesResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Rules: S.optional(RuleResponseList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListRulesResponse",
});
export const ListTagsForResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceARN: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListTagsForResourceRequest",
});
export const ListTagsForResourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Tags: S.optional(TagList) }).pipe(ns)).annotate({
    identifier: "ListTagsForResourceResponse",
});
export const ListTargetsByRuleRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Rule: S.String,
    EventBusName: S.optional(S.String),
    NextToken: S.optional(S.String),
    Limit: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListTargetsByRuleRequest",
});
export const TransformerPaths = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const InputTransformer = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    InputPathsMap: S.optional(TransformerPaths),
    InputTemplate: S.String,
})).annotate({
    identifier: "InputTransformer",
});
export const KinesisParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ PartitionKeyPath: S.String })).annotate({
    identifier: "KinesisParameters",
});
export const RunCommandTargetValues = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const RunCommandTarget = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Key: S.String, Values: RunCommandTargetValues })).annotate({
    identifier: "RunCommandTarget",
});
export const RunCommandTargets = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(RunCommandTarget);
export const RunCommandParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ RunCommandTargets: RunCommandTargets })).annotate({
    identifier: "RunCommandParameters",
});
export const LaunchType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const StringList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const AssignPublicIp = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const AwsVpcConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Subnets: StringList,
    SecurityGroups: S.optional(StringList),
    AssignPublicIp: S.optional(AssignPublicIp),
})).annotate({
    identifier: "AwsVpcConfiguration",
});
export const NetworkConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ awsvpcConfiguration: S.optional(AwsVpcConfiguration) })).annotate({
    identifier: "NetworkConfiguration",
});
export const CapacityProviderStrategyItem = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    capacityProvider: S.String,
    weight: S.optional(S.Number),
    base: S.optional(S.Number),
})).annotate({
    identifier: "CapacityProviderStrategyItem",
});
export const CapacityProviderStrategy = /*@__PURE__*/ /*#__PURE__*/ S.Array(CapacityProviderStrategyItem);
export const PlacementConstraintType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PlacementConstraint = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    type: S.optional(PlacementConstraintType),
    expression: S.optional(S.String),
})).annotate({
    identifier: "PlacementConstraint",
});
export const PlacementConstraints = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PlacementConstraint);
export const PlacementStrategyType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PlacementStrategy = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    type: S.optional(PlacementStrategyType),
    field: S.optional(S.String),
})).annotate({
    identifier: "PlacementStrategy",
});
export const PlacementStrategies = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PlacementStrategy);
export const PropagateTags = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const EcsParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    TaskDefinitionArn: S.String,
    TaskCount: S.optional(S.Number),
    LaunchType: S.optional(LaunchType),
    NetworkConfiguration: S.optional(NetworkConfiguration),
    PlatformVersion: S.optional(S.String),
    Group: S.optional(S.String),
    CapacityProviderStrategy: S.optional(CapacityProviderStrategy),
    EnableECSManagedTags: S.optional(S.Boolean),
    EnableExecuteCommand: S.optional(S.Boolean),
    PlacementConstraints: S.optional(PlacementConstraints),
    PlacementStrategy: S.optional(PlacementStrategies),
    PropagateTags: S.optional(PropagateTags),
    ReferenceId: S.optional(S.String),
    Tags: S.optional(TagList),
})).annotate({ identifier: "EcsParameters" });
export const BatchArrayProperties = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Size: S.optional(S.Number) })).annotate({
    identifier: "BatchArrayProperties",
});
export const BatchRetryStrategy = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Attempts: S.optional(S.Number) })).annotate({
    identifier: "BatchRetryStrategy",
});
export const BatchParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    JobDefinition: S.String,
    JobName: S.String,
    ArrayProperties: S.optional(BatchArrayProperties),
    RetryStrategy: S.optional(BatchRetryStrategy),
})).annotate({
    identifier: "BatchParameters",
});
export const SqsParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ MessageGroupId: S.optional(S.String) })).annotate({ identifier: "SqsParameters" });
export const PathParameterList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const HeaderParametersMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const QueryStringParametersMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const HttpParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PathParameterValues: S.optional(PathParameterList),
    HeaderParameters: S.optional(HeaderParametersMap),
    QueryStringParameters: S.optional(QueryStringParametersMap),
})).annotate({ identifier: "HttpParameters" });
export const RedshiftDataParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SecretManagerArn: S.optional(S.String),
    Database: S.String,
    DbUser: S.optional(S.String),
    Sql: S.String,
    StatementName: S.optional(S.String),
    WithEvent: S.optional(S.Boolean),
})).annotate({
    identifier: "RedshiftDataParameters",
});
export const SageMakerPipelineParameter = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String, Value: S.String })).annotate({
    identifier: "SageMakerPipelineParameter",
});
export const SageMakerPipelineParameterList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SageMakerPipelineParameter);
export const SageMakerPipelineParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PipelineParameterList: S.optional(SageMakerPipelineParameterList),
})).annotate({
    identifier: "SageMakerPipelineParameters",
});
export const DeadLetterConfig = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Arn: S.optional(S.String) })).annotate({
    identifier: "DeadLetterConfig",
});
export const RetryPolicy = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MaximumRetryAttempts: S.optional(S.Number),
    MaximumEventAgeInSeconds: S.optional(S.Number),
})).annotate({ identifier: "RetryPolicy" });
export const Target = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Id: S.String,
    Arn: S.String,
    RoleArn: S.optional(S.String),
    Input: S.optional(S.String),
    InputPath: S.optional(S.String),
    InputTransformer: S.optional(InputTransformer),
    KinesisParameters: S.optional(KinesisParameters),
    RunCommandParameters: S.optional(RunCommandParameters),
    EcsParameters: S.optional(EcsParameters),
    BatchParameters: S.optional(BatchParameters),
    SqsParameters: S.optional(SqsParameters),
    HttpParameters: S.optional(HttpParameters),
    RedshiftDataParameters: S.optional(RedshiftDataParameters),
    SageMakerPipelineParameters: S.optional(SageMakerPipelineParameters),
    DeadLetterConfig: S.optional(DeadLetterConfig),
    RetryPolicy: S.optional(RetryPolicy),
})).annotate({ identifier: "Target" });
export const TargetList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Target);
export const ListTargetsByRuleResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Targets: S.optional(TargetList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListTargetsByRuleResponse",
});
export const EventResourceList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const PutEventsRequestEntry = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Time: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Source: S.optional(S.String),
    Resources: S.optional(EventResourceList),
    DetailType: S.optional(S.String),
    Detail: S.optional(S.String),
    EventBusName: S.optional(S.String),
    TraceHeader: S.optional(S.String),
})).annotate({
    identifier: "PutEventsRequestEntry",
});
export const PutEventsRequestEntryList = /*@__PURE__*/ /*#__PURE__*/ S.Array(PutEventsRequestEntry);
export const PutEventsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Entries: PutEventsRequestEntryList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutEventsRequest",
});
export const PutEventsResultEntry = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EventId: S.optional(S.String),
    ErrorCode: S.optional(S.String),
    ErrorMessage: S.optional(S.String),
})).annotate({
    identifier: "PutEventsResultEntry",
});
export const PutEventsResultEntryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PutEventsResultEntry);
export const PutEventsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FailedEntryCount: S.optional(S.Number),
    Entries: S.optional(PutEventsResultEntryList),
}).pipe(ns)).annotate({
    identifier: "PutEventsResponse",
});
export const PutPartnerEventsRequestEntry = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Time: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Source: S.optional(S.String),
    Resources: S.optional(EventResourceList),
    DetailType: S.optional(S.String),
    Detail: S.optional(S.String),
})).annotate({
    identifier: "PutPartnerEventsRequestEntry",
});
export const PutPartnerEventsRequestEntryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PutPartnerEventsRequestEntry);
export const PutPartnerEventsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Entries: PutPartnerEventsRequestEntryList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutPartnerEventsRequest",
});
export const PutPartnerEventsResultEntry = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EventId: S.optional(S.String),
    ErrorCode: S.optional(S.String),
    ErrorMessage: S.optional(S.String),
})).annotate({
    identifier: "PutPartnerEventsResultEntry",
});
export const PutPartnerEventsResultEntryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PutPartnerEventsResultEntry);
export const PutPartnerEventsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FailedEntryCount: S.optional(S.Number),
    Entries: S.optional(PutPartnerEventsResultEntryList),
}).pipe(ns)).annotate({
    identifier: "PutPartnerEventsResponse",
});
export const Condition = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Type: S.String, Key: S.String, Value: S.String })).annotate({ identifier: "Condition" });
export const PutPermissionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EventBusName: S.optional(S.String),
    Action: S.optional(S.String),
    Principal: S.optional(S.String),
    StatementId: S.optional(S.String),
    Condition: S.optional(Condition),
    Policy: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutPermissionRequest",
});
export const PutPermissionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "PutPermissionResponse",
});
export const PutRuleRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    ScheduleExpression: S.optional(S.String),
    EventPattern: S.optional(S.String),
    State: S.optional(RuleState),
    Description: S.optional(S.String),
    RoleArn: S.optional(S.String),
    Tags: S.optional(TagList),
    EventBusName: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({ identifier: "PutRuleRequest" });
export const PutRuleResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ RuleArn: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "PutRuleResponse",
});
export const PutTargetsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Rule: S.String,
    EventBusName: S.optional(S.String),
    Targets: TargetList,
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutTargetsRequest",
});
export const PutTargetsResultEntry = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    TargetId: S.optional(S.String),
    ErrorCode: S.optional(S.String),
    ErrorMessage: S.optional(S.String),
})).annotate({
    identifier: "PutTargetsResultEntry",
});
export const PutTargetsResultEntryList = /*@__PURE__*/ /*#__PURE__*/ S.Array(PutTargetsResultEntry);
export const PutTargetsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FailedEntryCount: S.optional(S.Number),
    FailedEntries: S.optional(PutTargetsResultEntryList),
}).pipe(ns)).annotate({
    identifier: "PutTargetsResponse",
});
export const RemovePermissionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StatementId: S.optional(S.String),
    RemoveAllPermissions: S.optional(S.Boolean),
    EventBusName: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RemovePermissionRequest",
});
export const RemovePermissionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "RemovePermissionResponse",
});
export const TargetIdList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const RemoveTargetsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Rule: S.String,
    EventBusName: S.optional(S.String),
    Ids: TargetIdList,
    Force: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RemoveTargetsRequest",
});
export const RemoveTargetsResultEntry = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    TargetId: S.optional(S.String),
    ErrorCode: S.optional(S.String),
    ErrorMessage: S.optional(S.String),
})).annotate({
    identifier: "RemoveTargetsResultEntry",
});
export const RemoveTargetsResultEntryList = /*@__PURE__*/ /*#__PURE__*/ S.Array(RemoveTargetsResultEntry);
export const RemoveTargetsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FailedEntryCount: S.optional(S.Number),
    FailedEntries: S.optional(RemoveTargetsResultEntryList),
}).pipe(ns)).annotate({
    identifier: "RemoveTargetsResponse",
});
export const StartReplayRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReplayName: S.String,
    Description: S.optional(S.String),
    EventSourceArn: S.String,
    EventStartTime: S.Date.pipe(T.TimestampFormat("epoch-seconds")),
    EventEndTime: S.Date.pipe(T.TimestampFormat("epoch-seconds")),
    Destination: ReplayDestination,
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartReplayRequest",
});
export const StartReplayResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReplayArn: S.optional(S.String),
    State: S.optional(ReplayState),
    StateReason: S.optional(S.String),
    ReplayStartTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "StartReplayResponse",
});
export const TagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceARN: S.String, Tags: TagList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "TagResourceRequest",
});
export const TagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "TagResourceResponse",
});
export const TestEventPatternRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EventPattern: S.String, Event: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "TestEventPatternRequest",
});
export const TestEventPatternResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Result: S.optional(S.Boolean) }).pipe(ns)).annotate({
    identifier: "TestEventPatternResponse",
});
export const TagKeyList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const UntagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceARN: S.String, TagKeys: TagKeyList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UntagResourceRequest",
});
export const UntagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "UntagResourceResponse",
});
export const UpdateApiDestinationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    Description: S.optional(S.String),
    ConnectionArn: S.optional(S.String),
    InvocationEndpoint: S.optional(S.String),
    HttpMethod: S.optional(ApiDestinationHttpMethod),
    InvocationRateLimitPerSecond: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateApiDestinationRequest",
});
export const UpdateApiDestinationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ApiDestinationArn: S.optional(S.String),
    ApiDestinationState: S.optional(ApiDestinationState),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "UpdateApiDestinationResponse",
});
export const UpdateArchiveRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ArchiveName: S.String,
    Description: S.optional(S.String),
    EventPattern: S.optional(S.String),
    RetentionDays: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateArchiveRequest",
});
export const UpdateArchiveResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ArchiveArn: S.optional(S.String),
    State: S.optional(ArchiveState),
    StateReason: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "UpdateArchiveResponse",
});
export const UpdateConnectionBasicAuthRequestParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Username: S.optional(S.String),
    Password: S.optional(SensitiveString),
})).annotate({
    identifier: "UpdateConnectionBasicAuthRequestParameters",
});
export const UpdateConnectionOAuthClientRequestParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClientID: S.optional(S.String),
    ClientSecret: S.optional(SensitiveString),
})).annotate({
    identifier: "UpdateConnectionOAuthClientRequestParameters",
});
export const UpdateConnectionOAuthRequestParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClientParameters: S.optional(UpdateConnectionOAuthClientRequestParameters),
    AuthorizationEndpoint: S.optional(S.String),
    HttpMethod: S.optional(ConnectionOAuthHttpMethod),
    OAuthHttpParameters: S.optional(ConnectionHttpParameters),
})).annotate({
    identifier: "UpdateConnectionOAuthRequestParameters",
});
export const UpdateConnectionApiKeyAuthRequestParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ApiKeyName: S.optional(S.String),
    ApiKeyValue: S.optional(SensitiveString),
})).annotate({
    identifier: "UpdateConnectionApiKeyAuthRequestParameters",
});
export const UpdateConnectionAuthRequestParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BasicAuthParameters: S.optional(UpdateConnectionBasicAuthRequestParameters),
    OAuthParameters: S.optional(UpdateConnectionOAuthRequestParameters),
    ApiKeyAuthParameters: S.optional(UpdateConnectionApiKeyAuthRequestParameters),
    InvocationHttpParameters: S.optional(ConnectionHttpParameters),
})).annotate({
    identifier: "UpdateConnectionAuthRequestParameters",
});
export const UpdateConnectionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    Description: S.optional(S.String),
    AuthorizationType: S.optional(ConnectionAuthorizationType),
    AuthParameters: S.optional(UpdateConnectionAuthRequestParameters),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateConnectionRequest",
});
export const UpdateConnectionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConnectionArn: S.optional(S.String),
    ConnectionState: S.optional(ConnectionState),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastAuthorizedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "UpdateConnectionResponse",
});
//# Errors
export class ConcurrentModificationException extends S.TaggedErrorClass()("ConcurrentModificationException", { message: S.optional(S.String) }) {
}
export class InternalException extends S.TaggedErrorClass()("InternalException", { message: S.optional(S.String) }) {
}
export class InvalidStateException extends S.TaggedErrorClass()("InvalidStateException", { message: S.optional(S.String) }) {
}
export class OperationDisabledException extends S.TaggedErrorClass()("OperationDisabledException", { message: S.optional(S.String) }) {
}
export class ResourceNotFoundException extends S.TaggedErrorClass()("ResourceNotFoundException", { message: S.optional(S.String) }) {
}
export class IllegalStatusException extends S.TaggedErrorClass()("IllegalStatusException", { message: S.optional(S.String) }) {
}
export class LimitExceededException extends S.TaggedErrorClass()("LimitExceededException", { message: S.optional(S.String) }) {
}
export class ResourceAlreadyExistsException extends S.TaggedErrorClass()("ResourceAlreadyExistsException", { message: S.optional(S.String) }).pipe(C.withAlreadyExistsError) {
}
export class InvalidEventPatternException extends S.TaggedErrorClass()("InvalidEventPatternException", { message: S.optional(S.String) }) {
}
export class ManagedRuleException extends S.TaggedErrorClass()("ManagedRuleException", { message: S.optional(S.String) }) {
}
export class PolicyLengthExceededException extends S.TaggedErrorClass()("PolicyLengthExceededException", { message: S.optional(S.String) }) {
}
/**
 * Activates a partner event source that has been deactivated. Once activated, your matching
 * event bus will start receiving events from the event source.
 */
export const activateEventSource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ActivateEventSourceRequest,
    output: ActivateEventSourceResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        InvalidStateException,
        OperationDisabledException,
        ResourceNotFoundException,
    ],
}));
/**
 * Cancels the specified replay.
 */
export const cancelReplay = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelReplayRequest,
    output: CancelReplayResponse,
    errors: [
        ConcurrentModificationException,
        IllegalStatusException,
        InternalException,
        ResourceNotFoundException,
    ],
}));
/**
 * Creates an API destination, which is an HTTP invocation endpoint configured as a target
 * for events.
 */
export const createApiDestination = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateApiDestinationRequest,
    output: CreateApiDestinationResponse,
    errors: [
        InternalException,
        LimitExceededException,
        ResourceAlreadyExistsException,
        ResourceNotFoundException,
    ],
}));
/**
 * Creates an archive of events with the specified settings. When you create an archive,
 * incoming events might not immediately start being sent to the archive. Allow a short period of
 * time for changes to take effect. If you do not specify a pattern to filter events sent to the
 * archive, all events are sent to the archive except replayed events. Replayed events are not
 * sent to an archive.
 */
export const createArchive = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateArchiveRequest,
    output: CreateArchiveResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        InvalidEventPatternException,
        LimitExceededException,
        ResourceAlreadyExistsException,
        ResourceNotFoundException,
    ],
}));
/**
 * Creates a connection. A connection defines the authorization type and credentials to use
 * for authorization with an API destination HTTP endpoint.
 */
export const createConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateConnectionRequest,
    output: CreateConnectionResponse,
    errors: [
        InternalException,
        LimitExceededException,
        ResourceAlreadyExistsException,
    ],
}));
/**
 * Creates a new event bus within your account. This can be a custom event bus which you can
 * use to receive events from your custom applications and services, or it can be a partner event
 * bus which can be matched to a partner event source.
 */
export const createEventBus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateEventBusRequest,
    output: CreateEventBusResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        InvalidStateException,
        LimitExceededException,
        OperationDisabledException,
        ResourceAlreadyExistsException,
        ResourceNotFoundException,
    ],
}));
/**
 * Called by an SaaS partner to create a partner event source. This operation is not used by
 * Amazon Web Services customers.
 *
 * Each partner event source can be used by one Amazon Web Services account to create a matching partner
 * event bus in that Amazon Web Services account. A SaaS partner must create one partner event source for each
 * Amazon Web Services account that wants to receive those event types.
 *
 * A partner event source creates events based on resources within the SaaS partner's service
 * or application.
 *
 * An Amazon Web Services account that creates a partner event bus that matches the partner event source can
 * use that event bus to receive events from the partner, and then process them using Amazon Web Services Events
 * rules and targets.
 *
 * Partner event source names follow this format:
 *
 * *partner_name*\/*event_namespace*\/*event_name*
 *
 * *partner_name* is determined during partner registration and identifies
 * the partner to Amazon Web Services customers. *event_namespace* is determined by the
 * partner and is a way for the partner to categorize their events.
 * *event_name* is determined by the partner, and should uniquely identify
 * an event-generating resource within the partner system. The combination of
 * *event_namespace* and *event_name* should help Amazon Web Services
 * customers decide whether to create an event bus to receive these events.
 */
export const createPartnerEventSource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreatePartnerEventSourceRequest,
    output: CreatePartnerEventSourceResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        LimitExceededException,
        OperationDisabledException,
        ResourceAlreadyExistsException,
    ],
}));
/**
 * You can use this operation to temporarily stop receiving events from the specified partner
 * event source. The matching event bus is not deleted.
 *
 * When you deactivate a partner event source, the source goes into PENDING state. If it
 * remains in PENDING state for more than two weeks, it is deleted.
 *
 * To activate a deactivated partner event source, use ActivateEventSource.
 */
export const deactivateEventSource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeactivateEventSourceRequest,
    output: DeactivateEventSourceResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        InvalidStateException,
        OperationDisabledException,
        ResourceNotFoundException,
    ],
}));
/**
 * Removes all authorization parameters from the connection. This lets you remove the secret
 * from the connection so you can reuse it without having to create a new connection.
 */
export const deauthorizeConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeauthorizeConnectionRequest,
    output: DeauthorizeConnectionResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        ResourceNotFoundException,
    ],
}));
/**
 * Deletes the specified API destination.
 */
export const deleteApiDestination = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteApiDestinationRequest,
    output: DeleteApiDestinationResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        ResourceNotFoundException,
    ],
}));
/**
 * Deletes the specified archive.
 */
export const deleteArchive = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteArchiveRequest,
    output: DeleteArchiveResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        ResourceNotFoundException,
    ],
}));
/**
 * Deletes a connection.
 */
export const deleteConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteConnectionRequest,
    output: DeleteConnectionResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        ResourceNotFoundException,
    ],
}));
/**
 * Deletes the specified custom event bus or partner event bus. All rules associated with
 * this event bus need to be deleted. You can't delete your account's default event bus.
 */
export const deleteEventBus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteEventBusRequest,
    output: DeleteEventBusResponse,
    errors: [ConcurrentModificationException, InternalException],
}));
/**
 * This operation is used by SaaS partners to delete a partner event source. This operation
 * is not used by Amazon Web Services customers.
 *
 * When you delete an event source, the status of the corresponding partner event bus in the
 * Amazon Web Services customer account becomes DELETED.
 */
export const deletePartnerEventSource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeletePartnerEventSourceRequest,
    output: DeletePartnerEventSourceResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        OperationDisabledException,
    ],
}));
/**
 * Deletes the specified rule.
 *
 * Before you can delete the rule, you must remove all targets, using RemoveTargets.
 *
 * When you delete a rule, incoming events might continue to match to the deleted rule. Allow
 * a short period of time for changes to take effect.
 *
 * If you call delete rule multiple times for the same rule, all calls will succeed. When you
 * call delete rule for a non-existent custom eventbus, `ResourceNotFoundException` is
 * returned.
 *
 * Managed rules are rules created and managed by another Amazon Web Services service on your behalf. These
 * rules are created by those other Amazon Web Services services to support functionality in those services. You
 * can delete these rules using the `Force` option, but you should do so only if you
 * are sure the other service is not still using that rule.
 */
export const deleteRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteRuleRequest,
    output: DeleteRuleResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        ManagedRuleException,
        ResourceNotFoundException,
    ],
}));
/**
 * Retrieves details about an API destination.
 */
export const describeApiDestination = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeApiDestinationRequest,
    output: DescribeApiDestinationResponse,
    errors: [InternalException, ResourceNotFoundException],
}));
/**
 * Retrieves details about an archive.
 */
export const describeArchive = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeArchiveRequest,
    output: DescribeArchiveResponse,
    errors: [
        InternalException,
        ResourceAlreadyExistsException,
        ResourceNotFoundException,
    ],
}));
/**
 * Retrieves details about a connection.
 */
export const describeConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeConnectionRequest,
    output: DescribeConnectionResponse,
    errors: [InternalException, ResourceNotFoundException],
}));
/**
 * Displays details about an event bus in your account. This can include the external Amazon Web Services
 * accounts that are permitted to write events to your default event bus, and the associated
 * policy. For custom event buses and partner event buses, it displays the name, ARN, policy,
 * state, and creation time.
 *
 * To enable your account to receive events from other accounts on its default event bus,
 * use PutPermission.
 *
 * For more information about partner event buses, see CreateEventBus.
 */
export const describeEventBus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeEventBusRequest,
    output: DescribeEventBusResponse,
    errors: [InternalException, ResourceNotFoundException],
}));
/**
 * This operation lists details about a partner event source that is shared with your
 * account.
 */
export const describeEventSource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeEventSourceRequest,
    output: DescribeEventSourceResponse,
    errors: [
        InternalException,
        OperationDisabledException,
        ResourceNotFoundException,
    ],
}));
/**
 * 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 DescribeEventSource
 * to see details about a partner event source that is
 * shared with them.
 */
export const describePartnerEventSource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribePartnerEventSourceRequest,
    output: DescribePartnerEventSourceResponse,
    errors: [
        InternalException,
        OperationDisabledException,
        ResourceNotFoundException,
    ],
}));
/**
 * Retrieves details about a replay. Use `DescribeReplay` 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 `StartReplay` and
 * specify an `EventStartTime` and an `EventEndTime` 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
 * `DescribeReplay` to determine the progress of a replay. The value returned for
 * `EventLastReplayedTime` indicates the time within the specified time range
 * associated with the last event replayed.
 */
export const describeReplay = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeReplayRequest,
    output: DescribeReplayResponse,
    errors: [InternalException, ResourceNotFoundException],
}));
/**
 * Describes the specified rule.
 *
 * DescribeRule does not list the targets of a rule. To see the targets associated with a
 * rule, use ListTargetsByRule.
 */
export const describeRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeRuleRequest,
    output: DescribeRuleResponse,
    errors: [InternalException, ResourceNotFoundException],
}));
/**
 * Disables the specified rule. A disabled rule won't match any events, and won't
 * self-trigger if it has a schedule expression.
 *
 * 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.
 */
export const disableRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DisableRuleRequest,
    output: DisableRuleResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        ManagedRuleException,
        ResourceNotFoundException,
    ],
}));
/**
 * Enables the specified rule. If the rule does not exist, the operation fails.
 *
 * 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.
 */
export const enableRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: EnableRuleRequest,
    output: EnableRuleResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        ManagedRuleException,
        ResourceNotFoundException,
    ],
}));
/**
 * Retrieves a list of API destination in the account in the current Region.
 */
export const listApiDestinations = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListApiDestinationsRequest,
    output: ListApiDestinationsResponse,
    errors: [InternalException],
}));
/**
 * 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.
 */
export const listArchives = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListArchivesRequest,
    output: ListArchivesResponse,
    errors: [InternalException, ResourceNotFoundException],
}));
/**
 * Retrieves a list of connections from the account.
 */
export const listConnections = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListConnectionsRequest,
    output: ListConnectionsResponse,
    errors: [InternalException],
}));
/**
 * Lists all the event buses in your account, including the default event bus, custom event
 * buses, and partner event buses.
 */
export const listEventBuses = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListEventBusesRequest,
    output: ListEventBusesResponse,
    errors: [InternalException],
}));
/**
 * 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 CreateEventBus.
 */
export const listEventSources = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListEventSourcesRequest,
    output: ListEventSourcesResponse,
    errors: [InternalException, OperationDisabledException],
}));
/**
 * 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.
 */
export const listPartnerEventSourceAccounts = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListPartnerEventSourceAccountsRequest,
    output: ListPartnerEventSourceAccountsResponse,
    errors: [
        InternalException,
        OperationDisabledException,
        ResourceNotFoundException,
    ],
}));
/**
 * 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.
 */
export const listPartnerEventSources = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListPartnerEventSourcesRequest,
    output: ListPartnerEventSourcesResponse,
    errors: [InternalException, OperationDisabledException],
}));
/**
 * 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.
 */
export const listReplays = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListReplaysRequest,
    output: ListReplaysResponse,
    errors: [InternalException],
}));
/**
 * 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.
 */
export const listRuleNamesByTarget = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListRuleNamesByTargetRequest,
    output: ListRuleNamesByTargetResponse,
    errors: [InternalException, ResourceNotFoundException],
}));
/**
 * Lists your Amazon EventBridge rules. You can either list all the rules or you can provide
 * a prefix to match to the rule names.
 *
 * ListRules does not list the targets of a rule. To see the targets associated with a rule,
 * use ListTargetsByRule.
 */
export const listRules = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListRulesRequest,
    output: ListRulesResponse,
    errors: [InternalException, ResourceNotFoundException],
}));
/**
 * Displays the tags associated with an EventBridge resource. In EventBridge, rules and event
 * buses can be tagged.
 */
export const listTagsForResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTagsForResourceRequest,
    output: ListTagsForResourceResponse,
    errors: [InternalException, ResourceNotFoundException],
}));
/**
 * Lists the targets assigned to the specified rule.
 */
export const listTargetsByRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTargetsByRuleRequest,
    output: ListTargetsByRuleResponse,
    errors: [InternalException, ResourceNotFoundException],
}));
/**
 * Sends custom events to Amazon EventBridge so that they can be matched to rules.
 */
export const putEvents = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutEventsRequest,
    output: PutEventsResponse,
    errors: [InternalException],
}));
/**
 * This is used by SaaS partners to write events to a customer's partner event bus. Amazon Web Services
 * customers do not use this operation.
 */
export const putPartnerEvents = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutPartnerEventsRequest,
    output: PutPartnerEventsResponse,
    errors: [InternalException, OperationDisabledException],
}));
/**
 * Running `PutPermission` permits the specified Amazon Web Services account or Amazon Web Services organization
 * to put events to the specified *event bus*. Amazon EventBridge (CloudWatch
 * Events) rules in your account are triggered by these events arriving to an event bus in your
 * account.
 *
 * For another account to send events to your account, that external account must have an
 * EventBridge rule with your account's event bus as a target.
 *
 * To enable multiple Amazon Web Services accounts to put events to your event bus, run
 * `PutPermission` once for each of these accounts. Or, if all the accounts are
 * members of the same Amazon Web Services organization, you can run `PutPermission` once specifying
 * `Principal` as "*" and specifying the Amazon Web Services organization ID in
 * `Condition`, to grant permissions to all accounts in that organization.
 *
 * If you grant permissions using an organization, then accounts in that organization must
 * specify a `RoleArn` with proper permissions when they use `PutTarget` to
 * add your account's event bus as a target. For more information, see Sending and
 * Receiving Events Between Amazon Web Services Accounts in the Amazon EventBridge User
 * Guide.
 *
 * The permission policy on the event bus cannot exceed 10 KB in size.
 */
export const putPermission = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutPermissionRequest,
    output: PutPermissionResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        OperationDisabledException,
        PolicyLengthExceededException,
        ResourceNotFoundException,
    ],
}));
/**
 * Creates or updates the specified rule. Rules are enabled by default, or based on value of
 * the state. You can disable a rule using DisableRule.
 *
 * A single rule watches for events from a single event bus. Events generated by Amazon Web Services services
 * go to your account's default event bus. Events generated by SaaS partner services or
 * applications go to the matching partner event bus. If you have custom applications or
 * services, you can specify whether their events go to your default event bus or a custom event
 * bus that you have created. For more information, see CreateEventBus.
 *
 * If you are updating an existing rule, the rule is replaced with what you specify in this
 * `PutRule` command. If you omit arguments in `PutRule`, the old values
 * for those arguments are not kept. Instead, they are replaced with null values.
 *
 * When you create or update a rule, incoming events might not immediately start matching to
 * new or updated rules. Allow a short period of time for changes to take effect.
 *
 * A rule must contain at least an EventPattern or ScheduleExpression. Rules with
 * EventPatterns are triggered when a matching event is observed. Rules with ScheduleExpressions
 * self-trigger based on the given schedule. A rule can have both an EventPattern and a
 * ScheduleExpression, in which case the rule triggers on matching events as well as on a
 * schedule.
 *
 * When you initially create a rule, you can optionally assign one or more tags to the rule.
 * Tags can help you organize and categorize your resources. You can also use them to scope user
 * permissions, by granting a user permission to access or change only rules with certain tag
 * values. To use the `PutRule` operation and assign tags, you must have both the
 * `events:PutRule` and `events:TagResource` permissions.
 *
 * If you are updating an existing rule, any tags you specify in the `PutRule`
 * operation are ignored. To update the tags of an existing rule, use TagResource and UntagResource.
 *
 * Most services in Amazon Web Services treat : or / as the same character in Amazon Resource Names (ARNs).
 * However, EventBridge uses an exact match in event patterns and rules. Be sure to use the
 * correct ARN characters when creating event patterns so that they match the ARN syntax in the
 * event you want to match.
 *
 * In EventBridge, it is possible to create rules that lead to infinite loops, where a rule
 * is fired repeatedly. For example, a rule might detect that ACLs have changed on an S3 bucket,
 * and trigger software to change them to the desired state. If the rule is not written
 * carefully, the subsequent change to the ACLs fires the rule again, creating an infinite
 * loop.
 *
 * To prevent this, write the rules so that the triggered actions do not re-fire the same
 * rule. For example, your rule could fire only if ACLs are found to be in a bad state, instead
 * of after any change.
 *
 * An infinite loop can quickly cause higher than expected charges. We recommend that you use
 * budgeting, which alerts you when charges exceed your specified limit. For more information,
 * see Managing Your Costs with
 * Budgets.
 */
export const putRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutRuleRequest,
    output: PutRuleResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        InvalidEventPatternException,
        LimitExceededException,
        ManagedRuleException,
        ResourceNotFoundException,
    ],
}));
/**
 * Adds the specified targets to the specified rule, or updates the targets if they are
 * already associated with the rule.
 *
 * Targets are the resources that are invoked when a rule is triggered.
 *
 * You can configure the following as targets for Events:
 *
 * - API
 * destination
 *
 * - Amazon API Gateway REST API endpoints
 *
 * - API Gateway
 *
 * - Batch job queue
 *
 * - CloudWatch Logs group
 *
 * - CodeBuild project
 *
 * - CodePipeline
 *
 * - Amazon EC2 `CreateSnapshot` API call
 *
 * - Amazon EC2 `RebootInstances` API call
 *
 * - Amazon EC2 `StopInstances` API call
 *
 * - Amazon EC2 `TerminateInstances` API call
 *
 * - Amazon ECS tasks
 *
 * - Event bus in a different Amazon Web Services account or Region.
 *
 * You can use an event bus in the US East (N. Virginia) us-east-1, US West (Oregon)
 * us-west-2, or Europe (Ireland) eu-west-1 Regions as a target for a rule.
 *
 * - Firehose delivery stream (Firehose)
 *
 * - Inspector assessment template (Amazon Inspector)
 *
 * - Kinesis stream (Kinesis Data Stream)
 *
 * - Lambda function
 *
 * - Redshift clusters (Data API statement execution)
 *
 * - Amazon SNS topic
 *
 * - Amazon SQS queues (includes FIFO queues
 *
 * - SSM Automation
 *
 * - SSM OpsItem
 *
 * - SSM Run Command
 *
 * - Step Functions state machines
 *
 * Creating rules with built-in targets is supported only in the Amazon Web Services Management Console. The
 * built-in targets are `EC2 CreateSnapshot API call`, EC2 RebootInstances API
 * call, `EC2 StopInstances API call`, and EC2 TerminateInstances API
 * call.
 *
 * For some target types, `PutTargets` provides target-specific parameters. If the
 * target is a Kinesis data stream, you can optionally specify which shard the event goes to by
 * using the `KinesisParameters` argument. To invoke a command on multiple EC2
 * instances with one rule, you can use the `RunCommandParameters` field.
 *
 * To be able to make API calls against the resources that you own, Amazon EventBridge
 * needs the appropriate permissions. For Lambda and Amazon SNS
 * resources, EventBridge relies on resource-based policies. For EC2 instances, Kinesis Data Streams,
 * Step Functions state machines and API Gateway REST APIs, EventBridge relies on
 * IAM roles that you specify in the `RoleARN` argument in `PutTargets`.
 * For more information, see Authentication
 * and Access Control in the *Amazon EventBridge User Guide*.
 *
 * If another Amazon Web Services account is in the same region and has granted you permission (using
 * `PutPermission`), you can send events to that account. Set that account's event
 * bus as a target of the rules in your account. To send the matched events to the other account,
 * specify that account's event bus as the `Arn` value when you run
 * `PutTargets`. If your account sends events to another account, your account is
 * charged for each sent event. Each event sent to another account is charged as a custom event.
 * The account receiving the event is not charged. For more information, see Amazon EventBridge
 * Pricing.
 *
 * `Input`, `InputPath`, and `InputTransformer` are not
 * available with `PutTarget` if the target is an event bus of a different Amazon Web Services
 * account.
 *
 * If you are setting the event bus of another account as the target, and that account
 * granted permission to your account through an organization instead of directly by the account
 * ID, then you must specify a `RoleArn` with proper permissions in the
 * `Target` structure. For more information, see Sending and
 * Receiving Events Between Amazon Web Services Accounts in the Amazon EventBridge User
 * Guide.
 *
 * For more information about enabling cross-account events, see PutPermission.
 *
 * **Input**, **InputPath**, and
 * **InputTransformer** are mutually exclusive and optional
 * parameters of a target. When a rule is triggered due to a matched event:
 *
 * - If none of the following arguments are specified for a target, then the entire event
 * is passed to the target in JSON format (unless the target is Amazon EC2 Run Command or
 * Amazon ECS task, in which case nothing from the event is passed to the target).
 *
 * - If **Input** is specified in the form of valid JSON, then
 * the matched event is overridden with this constant.
 *
 * - If **InputPath** is specified in the form of JSONPath
 * (for example, `$.detail`), then only the part of the event specified in the
 * path is passed to the target (for example, only the detail part of the event is
 * passed).
 *
 * - If **InputTransformer** is specified, then one or more
 * specified JSONPaths are extracted from the event and used as values in a template that you
 * specify as the input to the target.
 *
 * When you specify `InputPath` or `InputTransformer`, you must use
 * JSON dot notation, not bracket notation.
 *
 * When you add targets to a rule and the associated rule triggers soon after, new or updated
 * targets might not be immediately invoked. Allow a short period of time for changes to take
 * effect.
 *
 * This action can partially fail if too many requests are made at the same time. If that
 * happens, `FailedEntryCount` is non-zero in the response and each entry in
 * `FailedEntries` provides the ID of the failed target and the error code.
 */
export const putTargets = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutTargetsRequest,
    output: PutTargetsResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        LimitExceededException,
        ManagedRuleException,
        ResourceNotFoundException,
    ],
}));
/**
 * Revokes the permission of another Amazon Web Services account to be able to put events to the specified
 * event bus. Specify the account to revoke by the `StatementId` value that you
 * associated with the account when you granted it permission with `PutPermission`.
 * You can find the `StatementId` by using DescribeEventBus.
 */
export const removePermission = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RemovePermissionRequest,
    output: RemovePermissionResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        OperationDisabledException,
        ResourceNotFoundException,
    ],
}));
/**
 * Removes the specified targets from the specified rule. When the rule is triggered, those
 * targets are no longer be invoked.
 *
 * When you remove a target, when the associated rule triggers, removed targets might
 * continue to be invoked. Allow a short period of time for changes to take effect.
 *
 * This action can partially fail if too many requests are made at the same time. If that
 * happens, `FailedEntryCount` is non-zero in the response and each entry in
 * `FailedEntries` provides the ID of the failed target and the error code.
 */
export const removeTargets = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RemoveTargetsRequest,
    output: RemoveTargetsResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        ManagedRuleException,
        ResourceNotFoundException,
    ],
}));
/**
 * Starts the specified replay. Events are not necessarily replayed in the exact same order
 * that they were added to the archive. A replay processes events to replay based on the time in
 * the event, and replays them using 1 minute intervals. If you specify an
 * `EventStartTime` and an `EventEndTime` 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 `DescribeReplay` to
 * determine the progress of a replay. The value returned for `EventLastReplayedTime`
 * indicates the time within the specified time range associated with the last event
 * replayed.
 */
export const startReplay = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartReplayRequest,
    output: StartReplayResponse,
    errors: [
        InternalException,
        InvalidEventPatternException,
        LimitExceededException,
        ResourceAlreadyExistsException,
        ResourceNotFoundException,
    ],
}));
/**
 * Assigns one or more tags (key-value pairs) to the specified EventBridge resource. Tags can
 * help you organize and categorize your resources. You can also use them to scope user
 * permissions by granting a user permission to access or change only resources with certain tag
 * values. In EventBridge, rules and event buses can be tagged.
 *
 * Tags don't have any semantic meaning to Amazon Web Services and are interpreted strictly as strings of
 * characters.
 *
 * You can use the `TagResource` action with a resource that already has tags. If
 * you specify a new tag key, this tag is appended to the list of tags associated with the
 * resource. If you specify a tag key that is already associated with the resource, the new tag
 * value that you specify replaces the previous value for that tag.
 *
 * You can associate as many as 50 tags with a resource.
 */
export const tagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TagResourceRequest,
    output: TagResourceResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        ManagedRuleException,
        ResourceNotFoundException,
    ],
}));
/**
 * Tests whether the specified event pattern matches the provided event.
 *
 * Most services in Amazon Web Services treat : or / as the same character in Amazon Resource Names (ARNs).
 * However, EventBridge uses an exact match in event patterns and rules. Be sure to use the
 * correct ARN characters when creating event patterns so that they match the ARN syntax in the
 * event you want to match.
 */
export const testEventPattern = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TestEventPatternRequest,
    output: TestEventPatternResponse,
    errors: [InternalException, InvalidEventPatternException],
}));
/**
 * Removes one or more tags from the specified EventBridge resource. In Amazon EventBridge
 * (CloudWatch Events), rules and event buses can be tagged.
 */
export const untagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UntagResourceRequest,
    output: UntagResourceResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        ManagedRuleException,
        ResourceNotFoundException,
    ],
}));
/**
 * Updates an API destination.
 */
export const updateApiDestination = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateApiDestinationRequest,
    output: UpdateApiDestinationResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        LimitExceededException,
        ResourceNotFoundException,
    ],
}));
/**
 * Updates the specified archive.
 */
export const updateArchive = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateArchiveRequest,
    output: UpdateArchiveResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        InvalidEventPatternException,
        LimitExceededException,
        ResourceNotFoundException,
    ],
}));
/**
 * Updates settings for a connection.
 */
export const updateConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateConnectionRequest,
    output: UpdateConnectionResponse,
    errors: [
        ConcurrentModificationException,
        InternalException,
        LimitExceededException,
        ResourceNotFoundException,
    ],
}));
//# sourceMappingURL=cloudwatch-events.js.map