@aws-sdk/client-network-firewall 3.933.0 → 3.935.0

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

@@ -0,0 +1,403 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const TransitGatewayAttachmentStatus: {
+    readonly CREATING: "CREATING";
+    readonly DELETED: "DELETED";
+    readonly DELETING: "DELETING";
+    readonly ERROR: "ERROR";
+    readonly FAILED: "FAILED";
+    readonly PENDING_ACCEPTANCE: "PENDING_ACCEPTANCE";
+    readonly READY: "READY";
+    readonly REJECTED: "REJECTED";
+    readonly REJECTING: "REJECTING";
+};
+/**
+ * @public
+ */
+export type TransitGatewayAttachmentStatus = (typeof TransitGatewayAttachmentStatus)[keyof typeof TransitGatewayAttachmentStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const EnabledAnalysisType: {
+    readonly HTTP_HOST: "HTTP_HOST";
+    readonly TLS_SNI: "TLS_SNI";
+};
+/**
+ * @public
+ */
+export type EnabledAnalysisType = (typeof EnabledAnalysisType)[keyof typeof EnabledAnalysisType];
+/**
+ * @public
+ * @enum
+ */
+export declare const IdentifiedType: {
+    readonly STATELESS_RULE_CONTAINS_TCP_FLAGS: "STATELESS_RULE_CONTAINS_TCP_FLAGS";
+    readonly STATELESS_RULE_FORWARDING_ASYMMETRICALLY: "STATELESS_RULE_FORWARDING_ASYMMETRICALLY";
+};
+/**
+ * @public
+ */
+export type IdentifiedType = (typeof IdentifiedType)[keyof typeof IdentifiedType];
+/**
+ * @public
+ * @enum
+ */
+export declare const IPAddressType: {
+    readonly DUALSTACK: "DUALSTACK";
+    readonly IPV4: "IPV4";
+    readonly IPV6: "IPV6";
+};
+/**
+ * @public
+ */
+export type IPAddressType = (typeof IPAddressType)[keyof typeof IPAddressType];
+/**
+ * @public
+ * @enum
+ */
+export declare const AttachmentStatus: {
+    readonly CREATING: "CREATING";
+    readonly DELETING: "DELETING";
+    readonly ERROR: "ERROR";
+    readonly FAILED: "FAILED";
+    readonly READY: "READY";
+    readonly SCALING: "SCALING";
+};
+/**
+ * @public
+ */
+export type AttachmentStatus = (typeof AttachmentStatus)[keyof typeof AttachmentStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const RevocationCheckAction: {
+    readonly DROP: "DROP";
+    readonly PASS: "PASS";
+    readonly REJECT: "REJECT";
+};
+/**
+ * @public
+ */
+export type RevocationCheckAction = (typeof RevocationCheckAction)[keyof typeof RevocationCheckAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConfigurationSyncState: {
+    readonly CAPACITY_CONSTRAINED: "CAPACITY_CONSTRAINED";
+    readonly IN_SYNC: "IN_SYNC";
+    readonly PENDING: "PENDING";
+};
+/**
+ * @public
+ */
+export type ConfigurationSyncState = (typeof ConfigurationSyncState)[keyof typeof ConfigurationSyncState];
+/**
+ * @public
+ * @enum
+ */
+export declare const EncryptionType: {
+    readonly AWS_OWNED_KMS_KEY: "AWS_OWNED_KMS_KEY";
+    readonly CUSTOMER_KMS: "CUSTOMER_KMS";
+};
+/**
+ * @public
+ */
+export type EncryptionType = (typeof EncryptionType)[keyof typeof EncryptionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FirewallStatusValue: {
+    readonly DELETING: "DELETING";
+    readonly PROVISIONING: "PROVISIONING";
+    readonly READY: "READY";
+};
+/**
+ * @public
+ */
+export type FirewallStatusValue = (typeof FirewallStatusValue)[keyof typeof FirewallStatusValue];
+/**
+ * @public
+ * @enum
+ */
+export declare const PerObjectSyncStatus: {
+    readonly CAPACITY_CONSTRAINED: "CAPACITY_CONSTRAINED";
+    readonly DEPRECATED: "DEPRECATED";
+    readonly IN_SYNC: "IN_SYNC";
+    readonly NOT_SUBSCRIBED: "NOT_SUBSCRIBED";
+    readonly PENDING: "PENDING";
+};
+/**
+ * @public
+ */
+export type PerObjectSyncStatus = (typeof PerObjectSyncStatus)[keyof typeof PerObjectSyncStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const RuleOrder: {
+    readonly DEFAULT_ACTION_ORDER: "DEFAULT_ACTION_ORDER";
+    readonly STRICT_ORDER: "STRICT_ORDER";
+};
+/**
+ * @public
+ */
+export type RuleOrder = (typeof RuleOrder)[keyof typeof RuleOrder];
+/**
+ * @public
+ * @enum
+ */
+export declare const StreamExceptionPolicy: {
+    readonly CONTINUE: "CONTINUE";
+    readonly DROP: "DROP";
+    readonly REJECT: "REJECT";
+};
+/**
+ * @public
+ */
+export type StreamExceptionPolicy = (typeof StreamExceptionPolicy)[keyof typeof StreamExceptionPolicy];
+/**
+ * @public
+ * @enum
+ */
+export declare const OverrideAction: {
+    readonly DROP_TO_ALERT: "DROP_TO_ALERT";
+};
+/**
+ * @public
+ */
+export type OverrideAction = (typeof OverrideAction)[keyof typeof OverrideAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const ResourceStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly DELETING: "DELETING";
+    readonly ERROR: "ERROR";
+};
+/**
+ * @public
+ */
+export type ResourceStatus = (typeof ResourceStatus)[keyof typeof ResourceStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const GeneratedRulesType: {
+    readonly ALERTLIST: "ALERTLIST";
+    readonly ALLOWLIST: "ALLOWLIST";
+    readonly DENYLIST: "DENYLIST";
+    readonly REJECTLIST: "REJECTLIST";
+};
+/**
+ * @public
+ */
+export type GeneratedRulesType = (typeof GeneratedRulesType)[keyof typeof GeneratedRulesType];
+/**
+ * @public
+ * @enum
+ */
+export declare const TargetType: {
+    readonly HTTP_HOST: "HTTP_HOST";
+    readonly TLS_SNI: "TLS_SNI";
+};
+/**
+ * @public
+ */
+export type TargetType = (typeof TargetType)[keyof typeof TargetType];
+/**
+ * @public
+ * @enum
+ */
+export declare const StatefulAction: {
+    readonly ALERT: "ALERT";
+    readonly DROP: "DROP";
+    readonly PASS: "PASS";
+    readonly REJECT: "REJECT";
+};
+/**
+ * @public
+ */
+export type StatefulAction = (typeof StatefulAction)[keyof typeof StatefulAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const StatefulRuleDirection: {
+    readonly ANY: "ANY";
+    readonly FORWARD: "FORWARD";
+};
+/**
+ * @public
+ */
+export type StatefulRuleDirection = (typeof StatefulRuleDirection)[keyof typeof StatefulRuleDirection];
+/**
+ * @public
+ * @enum
+ */
+export declare const StatefulRuleProtocol: {
+    readonly ANY: "IP";
+    readonly DCERPC: "DCERPC";
+    readonly DHCP: "DHCP";
+    readonly DNS: "DNS";
+    readonly FTP: "FTP";
+    readonly HTTP: "HTTP";
+    readonly HTTP2: "HTTP2";
+    readonly ICMP: "ICMP";
+    readonly IKEV2: "IKEV2";
+    readonly IMAP: "IMAP";
+    readonly KRB5: "KRB5";
+    readonly MSN: "MSN";
+    readonly NTP: "NTP";
+    readonly QUIC: "QUIC";
+    readonly SMB: "SMB";
+    readonly SMTP: "SMTP";
+    readonly SSH: "SSH";
+    readonly TCP: "TCP";
+    readonly TFTP: "TFTP";
+    readonly TLS: "TLS";
+    readonly UDP: "UDP";
+};
+/**
+ * @public
+ */
+export type StatefulRuleProtocol = (typeof StatefulRuleProtocol)[keyof typeof StatefulRuleProtocol];
+/**
+ * @public
+ * @enum
+ */
+export declare const TCPFlag: {
+    readonly ACK: "ACK";
+    readonly CWR: "CWR";
+    readonly ECE: "ECE";
+    readonly FIN: "FIN";
+    readonly PSH: "PSH";
+    readonly RST: "RST";
+    readonly SYN: "SYN";
+    readonly URG: "URG";
+};
+/**
+ * @public
+ */
+export type TCPFlag = (typeof TCPFlag)[keyof typeof TCPFlag];
+/**
+ * @public
+ * @enum
+ */
+export declare const SummaryRuleOption: {
+    readonly METADATA: "METADATA";
+    readonly MSG: "MSG";
+    readonly SID: "SID";
+};
+/**
+ * @public
+ */
+export type SummaryRuleOption = (typeof SummaryRuleOption)[keyof typeof SummaryRuleOption];
+/**
+ * @public
+ * @enum
+ */
+export declare const RuleGroupType: {
+    readonly STATEFUL: "STATEFUL";
+    readonly STATELESS: "STATELESS";
+};
+/**
+ * @public
+ */
+export type RuleGroupType = (typeof RuleGroupType)[keyof typeof RuleGroupType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FlowOperationStatus: {
+    readonly COMPLETED: "COMPLETED";
+    readonly COMPLETED_WITH_ERRORS: "COMPLETED_WITH_ERRORS";
+    readonly FAILED: "FAILED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+};
+/**
+ * @public
+ */
+export type FlowOperationStatus = (typeof FlowOperationStatus)[keyof typeof FlowOperationStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const FlowOperationType: {
+    readonly FLOW_CAPTURE: "FLOW_CAPTURE";
+    readonly FLOW_FLUSH: "FLOW_FLUSH";
+};
+/**
+ * @public
+ */
+export type FlowOperationType = (typeof FlowOperationType)[keyof typeof FlowOperationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const LogDestinationType: {
+    readonly CLOUDWATCH_LOGS: "CloudWatchLogs";
+    readonly KINESIS_DATA_FIREHOSE: "KinesisDataFirehose";
+    readonly S3: "S3";
+};
+/**
+ * @public
+ */
+export type LogDestinationType = (typeof LogDestinationType)[keyof typeof LogDestinationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const LogType: {
+    readonly ALERT: "ALERT";
+    readonly FLOW: "FLOW";
+    readonly TLS: "TLS";
+};
+/**
+ * @public
+ */
+export type LogType = (typeof LogType)[keyof typeof LogType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ResourceManagedType: {
+    readonly ACTIVE_THREAT_DEFENSE: "ACTIVE_THREAT_DEFENSE";
+    readonly AWS_MANAGED_DOMAIN_LISTS: "AWS_MANAGED_DOMAIN_LISTS";
+    readonly AWS_MANAGED_THREAT_SIGNATURES: "AWS_MANAGED_THREAT_SIGNATURES";
+    readonly PARTNER_MANAGED: "PARTNER_MANAGED";
+};
+/**
+ * @public
+ */
+export type ResourceManagedType = (typeof ResourceManagedType)[keyof typeof ResourceManagedType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ResourceManagedStatus: {
+    readonly ACCOUNT: "ACCOUNT";
+    readonly MANAGED: "MANAGED";
+};
+/**
+ * @public
+ */
+export type ResourceManagedStatus = (typeof ResourceManagedStatus)[keyof typeof ResourceManagedStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const SubscriptionStatus: {
+    readonly NOT_SUBSCRIBED: "NOT_SUBSCRIBED";
+    readonly SUBSCRIBED: "SUBSCRIBED";
+};
+/**
+ * @public
+ */
+export type SubscriptionStatus = (typeof SubscriptionStatus)[keyof typeof SubscriptionStatus];

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

@@ -0,0 +1,174 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { NetworkFirewallServiceException as __BaseException } from "./NetworkFirewallServiceException";
+/**
+ * <p>Your request is valid, but Network Firewall couldn't perform the operation because of a
+ *          system problem. Retry your request. </p>
+ * @public
+ */
+export declare class InternalServerError extends __BaseException {
+    readonly name: "InternalServerError";
+    readonly $fault: "server";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerError, __BaseException>);
+}
+/**
+ * <p>The operation failed because of a problem with your request. Examples include: </p>
+ *          <ul>
+ *             <li>
+ *                <p>You specified an unsupported parameter name or value.</p>
+ *             </li>
+ *             <li>
+ *                <p>You tried to update a property with a value that isn't among the available
+ *                types.</p>
+ *             </li>
+ *             <li>
+ *                <p>Your request references an ARN that is malformed, or corresponds to a resource
+ *                that isn't valid in the context of the request.</p>
+ *             </li>
+ *          </ul>
+ * @public
+ */
+export declare class InvalidRequestException extends __BaseException {
+    readonly name: "InvalidRequestException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidRequestException, __BaseException>);
+}
+/**
+ * <p>Unable to locate a resource using the parameters that you provided.</p>
+ * @public
+ */
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+/**
+ * <p>Unable to process the request due to throttling limitations.</p>
+ * @public
+ */
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+/**
+ * <p>Amazon Web Services doesn't currently have enough available capacity to fulfill your request. Try your
+ *          request later. </p>
+ * @public
+ */
+export declare class InsufficientCapacityException extends __BaseException {
+    readonly name: "InsufficientCapacityException";
+    readonly $fault: "server";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InsufficientCapacityException, __BaseException>);
+}
+/**
+ * <p>The operation failed because it's not valid. For example, you might have tried to delete
+ *          a rule group or firewall policy that's in use.</p>
+ * @public
+ */
+export declare class InvalidOperationException extends __BaseException {
+    readonly name: "InvalidOperationException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidOperationException, __BaseException>);
+}
+/**
+ * <p>The token you provided is stale or isn't valid for the operation. </p>
+ * @public
+ */
+export declare class InvalidTokenException extends __BaseException {
+    readonly name: "InvalidTokenException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidTokenException, __BaseException>);
+}
+/**
+ * <p>Unable to perform the operation because doing so would violate a limit setting. </p>
+ * @public
+ */
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+/**
+ * <p>The operation you requested isn't supported by Network Firewall. </p>
+ * @public
+ */
+export declare class UnsupportedOperationException extends __BaseException {
+    readonly name: "UnsupportedOperationException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UnsupportedOperationException, __BaseException>);
+}
+/**
+ * <p>The policy statement failed validation.</p>
+ * @public
+ */
+export declare class InvalidResourcePolicyException extends __BaseException {
+    readonly name: "InvalidResourcePolicyException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidResourcePolicyException, __BaseException>);
+}
+/**
+ * <p>Unable to send logs to a configured logging destination. </p>
+ * @public
+ */
+export declare class LogDestinationPermissionException extends __BaseException {
+    readonly name: "LogDestinationPermissionException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LogDestinationPermissionException, __BaseException>);
+}
+/**
+ * <p>Unable to change the resource because your account doesn't own it. </p>
+ * @public
+ */
+export declare class ResourceOwnerCheckException extends __BaseException {
+    readonly name: "ResourceOwnerCheckException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceOwnerCheckException, __BaseException>);
+}