@aws-sdk/client-cloudwatch-events 3.933.0 → 3.935.0

package/dist-types/models/enums.d.ts

@@ -0,0 +1,190 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const ApiDestinationState: {
+    readonly ACTIVE: "ACTIVE";
+    readonly INACTIVE: "INACTIVE";
+};
+/**
+ * @public
+ */
+export type ApiDestinationState = (typeof ApiDestinationState)[keyof typeof ApiDestinationState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ApiDestinationHttpMethod: {
+    readonly DELETE: "DELETE";
+    readonly GET: "GET";
+    readonly HEAD: "HEAD";
+    readonly OPTIONS: "OPTIONS";
+    readonly PATCH: "PATCH";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+};
+/**
+ * @public
+ */
+export type ApiDestinationHttpMethod = (typeof ApiDestinationHttpMethod)[keyof typeof ApiDestinationHttpMethod];
+/**
+ * @public
+ * @enum
+ */
+export declare const ArchiveState: {
+    readonly CREATE_FAILED: "CREATE_FAILED";
+    readonly CREATING: "CREATING";
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+    readonly UPDATE_FAILED: "UPDATE_FAILED";
+    readonly UPDATING: "UPDATING";
+};
+/**
+ * @public
+ */
+export type ArchiveState = (typeof ArchiveState)[keyof typeof ArchiveState];
+/**
+ * @public
+ * @enum
+ */
+export declare const AssignPublicIp: {
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+};
+/**
+ * @public
+ */
+export type AssignPublicIp = (typeof AssignPublicIp)[keyof typeof AssignPublicIp];
+/**
+ * @public
+ * @enum
+ */
+export declare const ReplayState: {
+    readonly CANCELLED: "CANCELLED";
+    readonly CANCELLING: "CANCELLING";
+    readonly COMPLETED: "COMPLETED";
+    readonly FAILED: "FAILED";
+    readonly RUNNING: "RUNNING";
+    readonly STARTING: "STARTING";
+};
+/**
+ * @public
+ */
+export type ReplayState = (typeof ReplayState)[keyof typeof ReplayState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectionAuthorizationType: {
+    readonly API_KEY: "API_KEY";
+    readonly BASIC: "BASIC";
+    readonly OAUTH_CLIENT_CREDENTIALS: "OAUTH_CLIENT_CREDENTIALS";
+};
+/**
+ * @public
+ */
+export type ConnectionAuthorizationType = (typeof ConnectionAuthorizationType)[keyof typeof ConnectionAuthorizationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectionOAuthHttpMethod: {
+    readonly GET: "GET";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+};
+/**
+ * @public
+ */
+export type ConnectionOAuthHttpMethod = (typeof ConnectionOAuthHttpMethod)[keyof typeof ConnectionOAuthHttpMethod];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectionState: {
+    readonly AUTHORIZED: "AUTHORIZED";
+    readonly AUTHORIZING: "AUTHORIZING";
+    readonly CREATING: "CREATING";
+    readonly DEAUTHORIZED: "DEAUTHORIZED";
+    readonly DEAUTHORIZING: "DEAUTHORIZING";
+    readonly DELETING: "DELETING";
+    readonly UPDATING: "UPDATING";
+};
+/**
+ * @public
+ */
+export type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+/**
+ * @public
+ * @enum
+ */
+export declare const EventSourceState: {
+    readonly ACTIVE: "ACTIVE";
+    readonly DELETED: "DELETED";
+    readonly PENDING: "PENDING";
+};
+/**
+ * @public
+ */
+export type EventSourceState = (typeof EventSourceState)[keyof typeof EventSourceState];
+/**
+ * @public
+ * @enum
+ */
+export declare const RuleState: {
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+};
+/**
+ * @public
+ */
+export type RuleState = (typeof RuleState)[keyof typeof RuleState];
+/**
+ * @public
+ * @enum
+ */
+export declare const LaunchType: {
+    readonly EC2: "EC2";
+    readonly EXTERNAL: "EXTERNAL";
+    readonly FARGATE: "FARGATE";
+};
+/**
+ * @public
+ */
+export type LaunchType = (typeof LaunchType)[keyof typeof LaunchType];
+/**
+ * @public
+ * @enum
+ */
+export declare const PlacementConstraintType: {
+    readonly DISTINCT_INSTANCE: "distinctInstance";
+    readonly MEMBER_OF: "memberOf";
+};
+/**
+ * @public
+ */
+export type PlacementConstraintType = (typeof PlacementConstraintType)[keyof typeof PlacementConstraintType];
+/**
+ * @public
+ * @enum
+ */
+export declare const PlacementStrategyType: {
+    readonly BINPACK: "binpack";
+    readonly RANDOM: "random";
+    readonly SPREAD: "spread";
+};
+/**
+ * @public
+ */
+export type PlacementStrategyType = (typeof PlacementStrategyType)[keyof typeof PlacementStrategyType];
+/**
+ * @public
+ * @enum
+ */
+export declare const PropagateTags: {
+    readonly TASK_DEFINITION: "TASK_DEFINITION";
+};
+/**
+ * @public
+ */
+export type PropagateTags = (typeof PropagateTags)[keyof typeof PropagateTags];

package/dist-types/models/errors.d.ts

@@ -0,0 +1,141 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { CloudWatchEventsServiceException as __BaseException } from "./CloudWatchEventsServiceException";
+/**
+ * <p>There is concurrent modification on a rule, target, archive, or replay.</p>
+ * @public
+ */
+export declare class ConcurrentModificationException extends __BaseException {
+    readonly name: "ConcurrentModificationException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ConcurrentModificationException, __BaseException>);
+}
+/**
+ * <p>This exception occurs due to unexpected causes.</p>
+ * @public
+ */
+export declare class InternalException extends __BaseException {
+    readonly name: "InternalException";
+    readonly $fault: "server";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalException, __BaseException>);
+}
+/**
+ * <p>The specified state is not a valid state for an event source.</p>
+ * @public
+ */
+export declare class InvalidStateException extends __BaseException {
+    readonly name: "InvalidStateException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidStateException, __BaseException>);
+}
+/**
+ * <p>The operation you are attempting is not available in this region.</p>
+ * @public
+ */
+export declare class OperationDisabledException extends __BaseException {
+    readonly name: "OperationDisabledException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<OperationDisabledException, __BaseException>);
+}
+/**
+ * <p>An entity that you specified does not exist.</p>
+ * @public
+ */
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+/**
+ * <p>An error occurred because a replay can be canceled only when the state is Running or
+ *       Starting.</p>
+ * @public
+ */
+export declare class IllegalStatusException extends __BaseException {
+    readonly name: "IllegalStatusException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<IllegalStatusException, __BaseException>);
+}
+/**
+ * <p>The request failed because it attempted to create resource beyond the allowed service
+ *       quota.</p>
+ * @public
+ */
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+/**
+ * <p>The resource you are trying to create already exists.</p>
+ * @public
+ */
+export declare class ResourceAlreadyExistsException extends __BaseException {
+    readonly name: "ResourceAlreadyExistsException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceAlreadyExistsException, __BaseException>);
+}
+/**
+ * <p>The event pattern is not valid.</p>
+ * @public
+ */
+export declare class InvalidEventPatternException extends __BaseException {
+    readonly name: "InvalidEventPatternException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidEventPatternException, __BaseException>);
+}
+/**
+ * <p>This rule was created by an Amazon Web Services service on behalf of your account. It is managed by that
+ *       service. If you see this error in response to <code>DeleteRule</code> or
+ *         <code>RemoveTargets</code>, you can use the <code>Force</code> parameter in those calls to
+ *       delete the rule or remove targets from the rule. You cannot modify these managed rules by
+ *       using <code>DisableRule</code>, <code>EnableRule</code>, <code>PutTargets</code>,
+ *         <code>PutRule</code>, <code>TagResource</code>, or <code>UntagResource</code>. </p>
+ * @public
+ */
+export declare class ManagedRuleException extends __BaseException {
+    readonly name: "ManagedRuleException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ManagedRuleException, __BaseException>);
+}
+/**
+ * <p>The event bus policy is too long. For more information, see the limits.</p>
+ * @public
+ */
+export declare class PolicyLengthExceededException extends __BaseException {
+    readonly name: "PolicyLengthExceededException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<PolicyLengthExceededException, __BaseException>);
+}