@aws-sdk/client-networkmanager 3.934.0 → 3.936.0

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

@@ -0,0 +1,513 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const AttachmentType: {
+    readonly CONNECT: "CONNECT";
+    readonly DIRECT_CONNECT_GATEWAY: "DIRECT_CONNECT_GATEWAY";
+    readonly SITE_TO_SITE_VPN: "SITE_TO_SITE_VPN";
+    readonly TRANSIT_GATEWAY_ROUTE_TABLE: "TRANSIT_GATEWAY_ROUTE_TABLE";
+    readonly VPC: "VPC";
+};
+/**
+ * @public
+ */
+export type AttachmentType = (typeof AttachmentType)[keyof typeof AttachmentType];
+/**
+ * @public
+ * @enum
+ */
+export declare const AttachmentErrorCode: {
+    readonly DIRECT_CONNECT_GATEWAY_EXISTING_ATTACHMENTS: "DIRECT_CONNECT_GATEWAY_EXISTING_ATTACHMENTS";
+    readonly DIRECT_CONNECT_GATEWAY_NOT_FOUND: "DIRECT_CONNECT_GATEWAY_NOT_FOUND";
+    readonly DIRECT_CONNECT_GATEWAY_NO_PRIVATE_VIF: "DIRECT_CONNECT_GATEWAY_NO_PRIVATE_VIF";
+    readonly MAXIMUM_NO_ENCAP_LIMIT_EXCEEDED: "MAXIMUM_NO_ENCAP_LIMIT_EXCEEDED";
+    readonly SUBNET_DUPLICATED_IN_AVAILABILITY_ZONE: "SUBNET_DUPLICATED_IN_AVAILABILITY_ZONE";
+    readonly SUBNET_NOT_FOUND: "SUBNET_NOT_FOUND";
+    readonly SUBNET_NO_FREE_ADDRESSES: "SUBNET_NO_FREE_ADDRESSES";
+    readonly SUBNET_NO_IPV6_CIDRS: "SUBNET_NO_IPV6_CIDRS";
+    readonly SUBNET_UNSUPPORTED_AVAILABILITY_ZONE: "SUBNET_UNSUPPORTED_AVAILABILITY_ZONE";
+    readonly VPC_NOT_FOUND: "VPC_NOT_FOUND";
+    readonly VPN_CONNECTION_NOT_FOUND: "VPN_CONNECTION_NOT_FOUND";
+};
+/**
+ * @public
+ */
+export type AttachmentErrorCode = (typeof AttachmentErrorCode)[keyof typeof AttachmentErrorCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const AttachmentState: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly CREATING: "CREATING";
+    readonly DELETING: "DELETING";
+    readonly FAILED: "FAILED";
+    readonly PENDING_ATTACHMENT_ACCEPTANCE: "PENDING_ATTACHMENT_ACCEPTANCE";
+    readonly PENDING_NETWORK_UPDATE: "PENDING_NETWORK_UPDATE";
+    readonly PENDING_TAG_ACCEPTANCE: "PENDING_TAG_ACCEPTANCE";
+    readonly REJECTED: "REJECTED";
+    readonly UPDATING: "UPDATING";
+};
+/**
+ * @public
+ */
+export type AttachmentState = (typeof AttachmentState)[keyof typeof AttachmentState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ValidationExceptionReason: {
+    readonly CANNOT_PARSE: "CannotParse";
+    readonly FIELD_VALIDATION_FAILED: "FieldValidationFailed";
+    readonly OTHER: "Other";
+    readonly UNKNOWN_OPERATION: "UnknownOperation";
+};
+/**
+ * @public
+ */
+export type ValidationExceptionReason = (typeof ValidationExceptionReason)[keyof typeof ValidationExceptionReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectPeerAssociationState: {
+    readonly available: "AVAILABLE";
+    readonly deleted: "DELETED";
+    readonly deleting: "DELETING";
+    readonly pending: "PENDING";
+};
+/**
+ * @public
+ */
+export type ConnectPeerAssociationState = (typeof ConnectPeerAssociationState)[keyof typeof ConnectPeerAssociationState];
+/**
+ * @public
+ * @enum
+ */
+export declare const CustomerGatewayAssociationState: {
+    readonly available: "AVAILABLE";
+    readonly deleted: "DELETED";
+    readonly deleting: "DELETING";
+    readonly pending: "PENDING";
+};
+/**
+ * @public
+ */
+export type CustomerGatewayAssociationState = (typeof CustomerGatewayAssociationState)[keyof typeof CustomerGatewayAssociationState];
+/**
+ * @public
+ * @enum
+ */
+export declare const LinkAssociationState: {
+    readonly available: "AVAILABLE";
+    readonly deleted: "DELETED";
+    readonly deleting: "DELETING";
+    readonly pending: "PENDING";
+};
+/**
+ * @public
+ */
+export type LinkAssociationState = (typeof LinkAssociationState)[keyof typeof LinkAssociationState];
+/**
+ * @public
+ * @enum
+ */
+export declare const TransitGatewayConnectPeerAssociationState: {
+    readonly available: "AVAILABLE";
+    readonly deleted: "DELETED";
+    readonly deleting: "DELETING";
+    readonly pending: "PENDING";
+};
+/**
+ * @public
+ */
+export type TransitGatewayConnectPeerAssociationState = (typeof TransitGatewayConnectPeerAssociationState)[keyof typeof TransitGatewayConnectPeerAssociationState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChangeAction: {
+    readonly ADD: "ADD";
+    readonly MODIFY: "MODIFY";
+    readonly REMOVE: "REMOVE";
+};
+/**
+ * @public
+ */
+export type ChangeAction = (typeof ChangeAction)[keyof typeof ChangeAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChangeSetState: {
+    readonly EXECUTING: "EXECUTING";
+    readonly EXECUTION_SUCCEEDED: "EXECUTION_SUCCEEDED";
+    readonly FAILED_GENERATION: "FAILED_GENERATION";
+    readonly OUT_OF_DATE: "OUT_OF_DATE";
+    readonly PENDING_GENERATION: "PENDING_GENERATION";
+    readonly READY_TO_EXECUTE: "READY_TO_EXECUTE";
+};
+/**
+ * @public
+ */
+export type ChangeSetState = (typeof ChangeSetState)[keyof typeof ChangeSetState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChangeStatus: {
+    readonly COMPLETE: "COMPLETE";
+    readonly FAILED: "FAILED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+    readonly NOT_STARTED: "NOT_STARTED";
+};
+/**
+ * @public
+ */
+export type ChangeStatus = (typeof ChangeStatus)[keyof typeof ChangeStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChangeType: {
+    readonly ATTACHMENT_MAPPING: "ATTACHMENT_MAPPING";
+    readonly ATTACHMENT_POLICIES_CONFIGURATION: "ATTACHMENT_POLICIES_CONFIGURATION";
+    readonly ATTACHMENT_ROUTE_PROPAGATION: "ATTACHMENT_ROUTE_PROPAGATION";
+    readonly ATTACHMENT_ROUTE_STATIC: "ATTACHMENT_ROUTE_STATIC";
+    readonly CORE_NETWORK_CONFIGURATION: "CORE_NETWORK_CONFIGURATION";
+    readonly CORE_NETWORK_EDGE: "CORE_NETWORK_EDGE";
+    readonly CORE_NETWORK_SEGMENT: "CORE_NETWORK_SEGMENT";
+    readonly NETWORK_FUNCTION_GROUP: "NETWORK_FUNCTION_GROUP";
+    readonly SEGMENTS_CONFIGURATION: "SEGMENTS_CONFIGURATION";
+    readonly SEGMENT_ACTIONS_CONFIGURATION: "SEGMENT_ACTIONS_CONFIGURATION";
+};
+/**
+ * @public
+ */
+export type ChangeType = (typeof ChangeType)[keyof typeof ChangeType];
+/**
+ * @public
+ * @enum
+ */
+export declare const TunnelProtocol: {
+    readonly GRE: "GRE";
+    readonly NO_ENCAP: "NO_ENCAP";
+};
+/**
+ * @public
+ */
+export type TunnelProtocol = (typeof TunnelProtocol)[keyof typeof TunnelProtocol];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectionState: {
+    readonly available: "AVAILABLE";
+    readonly deleting: "DELETING";
+    readonly pending: "PENDING";
+    readonly updating: "UPDATING";
+};
+/**
+ * @public
+ */
+export type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectionStatus: {
+    readonly DOWN: "DOWN";
+    readonly UP: "UP";
+};
+/**
+ * @public
+ */
+export type ConnectionStatus = (typeof ConnectionStatus)[keyof typeof ConnectionStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectionType: {
+    readonly BGP: "BGP";
+    readonly IPSEC: "IPSEC";
+};
+/**
+ * @public
+ */
+export type ConnectionType = (typeof ConnectionType)[keyof typeof ConnectionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectPeerErrorCode: {
+    readonly EDGE_LOCATION_NO_FREE_IPS: "EDGE_LOCATION_NO_FREE_IPS";
+    readonly EDGE_LOCATION_PEER_DUPLICATE: "EDGE_LOCATION_PEER_DUPLICATE";
+    readonly INVALID_INSIDE_CIDR_BLOCK: "INVALID_INSIDE_CIDR_BLOCK";
+    readonly IP_OUTSIDE_SUBNET_CIDR_RANGE: "IP_OUTSIDE_SUBNET_CIDR_RANGE";
+    readonly NO_ASSOCIATED_CIDR_BLOCK: "NO_ASSOCIATED_CIDR_BLOCK";
+    readonly SUBNET_NOT_FOUND: "SUBNET_NOT_FOUND";
+};
+/**
+ * @public
+ */
+export type ConnectPeerErrorCode = (typeof ConnectPeerErrorCode)[keyof typeof ConnectPeerErrorCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectPeerState: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly CREATING: "CREATING";
+    readonly DELETING: "DELETING";
+    readonly FAILED: "FAILED";
+};
+/**
+ * @public
+ */
+export type ConnectPeerState = (typeof ConnectPeerState)[keyof typeof ConnectPeerState];
+/**
+ * @public
+ * @enum
+ */
+export declare const CoreNetworkState: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly CREATING: "CREATING";
+    readonly DELETING: "DELETING";
+    readonly UPDATING: "UPDATING";
+};
+/**
+ * @public
+ */
+export type CoreNetworkState = (typeof CoreNetworkState)[keyof typeof CoreNetworkState];
+/**
+ * @public
+ * @enum
+ */
+export declare const SegmentActionServiceInsertion: {
+    readonly SEND_TO: "send-to";
+    readonly SEND_VIA: "send-via";
+};
+/**
+ * @public
+ */
+export type SegmentActionServiceInsertion = (typeof SegmentActionServiceInsertion)[keyof typeof SegmentActionServiceInsertion];
+/**
+ * @public
+ * @enum
+ */
+export declare const SendViaMode: {
+    readonly DUAL_HOP: "dual-hop";
+    readonly SINGLE_HOP: "single-hop";
+};
+/**
+ * @public
+ */
+export type SendViaMode = (typeof SendViaMode)[keyof typeof SendViaMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const CoreNetworkPolicyAlias: {
+    readonly LATEST: "LATEST";
+    readonly LIVE: "LIVE";
+};
+/**
+ * @public
+ */
+export type CoreNetworkPolicyAlias = (typeof CoreNetworkPolicyAlias)[keyof typeof CoreNetworkPolicyAlias];
+/**
+ * @public
+ * @enum
+ */
+export declare const DeviceState: {
+    readonly available: "AVAILABLE";
+    readonly deleting: "DELETING";
+    readonly pending: "PENDING";
+    readonly updating: "UPDATING";
+};
+/**
+ * @public
+ */
+export type DeviceState = (typeof DeviceState)[keyof typeof DeviceState];
+/**
+ * @public
+ * @enum
+ */
+export declare const GlobalNetworkState: {
+    readonly available: "AVAILABLE";
+    readonly deleting: "DELETING";
+    readonly pending: "PENDING";
+    readonly updating: "UPDATING";
+};
+/**
+ * @public
+ */
+export type GlobalNetworkState = (typeof GlobalNetworkState)[keyof typeof GlobalNetworkState];
+/**
+ * @public
+ * @enum
+ */
+export declare const LinkState: {
+    readonly available: "AVAILABLE";
+    readonly deleting: "DELETING";
+    readonly pending: "PENDING";
+    readonly updating: "UPDATING";
+};
+/**
+ * @public
+ */
+export type LinkState = (typeof LinkState)[keyof typeof LinkState];
+/**
+ * @public
+ * @enum
+ */
+export declare const SiteState: {
+    readonly available: "AVAILABLE";
+    readonly deleting: "DELETING";
+    readonly pending: "PENDING";
+    readonly updating: "UPDATING";
+};
+/**
+ * @public
+ */
+export type SiteState = (typeof SiteState)[keyof typeof SiteState];
+/**
+ * @public
+ * @enum
+ */
+export declare const PeeringErrorCode: {
+    readonly EDGE_LOCATION_PEER_DUPLICATE: "EDGE_LOCATION_PEER_DUPLICATE";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly INVALID_TRANSIT_GATEWAY_STATE: "INVALID_TRANSIT_GATEWAY_STATE";
+    readonly MISSING_REQUIRED_PERMISSIONS: "MISSING_PERMISSIONS";
+    readonly TRANSIT_GATEWAY_NOT_FOUND: "TRANSIT_GATEWAY_NOT_FOUND";
+    readonly TRANSIT_GATEWAY_PEERS_LIMIT_EXCEEDED: "TRANSIT_GATEWAY_PEERS_LIMIT_EXCEEDED";
+};
+/**
+ * @public
+ */
+export type PeeringErrorCode = (typeof PeeringErrorCode)[keyof typeof PeeringErrorCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const PeeringType: {
+    readonly TRANSIT_GATEWAY: "TRANSIT_GATEWAY";
+};
+/**
+ * @public
+ */
+export type PeeringType = (typeof PeeringType)[keyof typeof PeeringType];
+/**
+ * @public
+ * @enum
+ */
+export declare const PeeringState: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly CREATING: "CREATING";
+    readonly DELETING: "DELETING";
+    readonly FAILED: "FAILED";
+};
+/**
+ * @public
+ */
+export type PeeringState = (typeof PeeringState)[keyof typeof PeeringState];
+/**
+ * @public
+ * @enum
+ */
+export declare const TransitGatewayRegistrationState: {
+    readonly available: "AVAILABLE";
+    readonly deleted: "DELETED";
+    readonly deleting: "DELETING";
+    readonly failed: "FAILED";
+    readonly pending: "PENDING";
+};
+/**
+ * @public
+ */
+export type TransitGatewayRegistrationState = (typeof TransitGatewayRegistrationState)[keyof typeof TransitGatewayRegistrationState];
+/**
+ * @public
+ * @enum
+ */
+export declare const RouteState: {
+    readonly ACTIVE: "ACTIVE";
+    readonly BLACKHOLE: "BLACKHOLE";
+};
+/**
+ * @public
+ */
+export type RouteState = (typeof RouteState)[keyof typeof RouteState];
+/**
+ * @public
+ * @enum
+ */
+export declare const RouteType: {
+    readonly PROPAGATED: "PROPAGATED";
+    readonly STATIC: "STATIC";
+};
+/**
+ * @public
+ */
+export type RouteType = (typeof RouteType)[keyof typeof RouteType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RouteTableType: {
+    readonly CORE_NETWORK_SEGMENT: "CORE_NETWORK_SEGMENT";
+    readonly NETWORK_FUNCTION_GROUP: "NETWORK_FUNCTION_GROUP";
+    readonly TRANSIT_GATEWAY_ROUTE_TABLE: "TRANSIT_GATEWAY_ROUTE_TABLE";
+};
+/**
+ * @public
+ */
+export type RouteTableType = (typeof RouteTableType)[keyof typeof RouteTableType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RouteAnalysisCompletionReasonCode: {
+    readonly BLACKHOLE_ROUTE_FOR_DESTINATION_FOUND: "BLACKHOLE_ROUTE_FOR_DESTINATION_FOUND";
+    readonly CYCLIC_PATH_DETECTED: "CYCLIC_PATH_DETECTED";
+    readonly INACTIVE_ROUTE_FOR_DESTINATION_FOUND: "INACTIVE_ROUTE_FOR_DESTINATION_FOUND";
+    readonly MAX_HOPS_EXCEEDED: "MAX_HOPS_EXCEEDED";
+    readonly NO_DESTINATION_ARN_PROVIDED: "NO_DESTINATION_ARN_PROVIDED";
+    readonly POSSIBLE_MIDDLEBOX: "POSSIBLE_MIDDLEBOX";
+    readonly ROUTE_NOT_FOUND: "ROUTE_NOT_FOUND";
+    readonly TRANSIT_GATEWAY_ATTACHMENT: "TRANSIT_GATEWAY_ATTACHMENT_ATTACH_ARN_NO_MATCH";
+    readonly TRANSIT_GATEWAY_ATTACHMENT_NOT_FOUND: "TRANSIT_GATEWAY_ATTACHMENT_NOT_FOUND";
+    readonly TRANSIT_GATEWAY_ATTACHMENT_NOT_IN_TRANSIT_GATEWAY: "TRANSIT_GATEWAY_ATTACHMENT_NOT_IN_TRANSIT_GATEWAY";
+    readonly TRANSIT_GATEWAY_ATTACHMENT_STABLE_ROUTE_TABLE_NOT_FOUND: "TRANSIT_GATEWAY_ATTACHMENT_STABLE_ROUTE_TABLE_NOT_FOUND";
+};
+/**
+ * @public
+ */
+export type RouteAnalysisCompletionReasonCode = (typeof RouteAnalysisCompletionReasonCode)[keyof typeof RouteAnalysisCompletionReasonCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const RouteAnalysisCompletionResultCode: {
+    readonly CONNECTED: "CONNECTED";
+    readonly NOT_CONNECTED: "NOT_CONNECTED";
+};
+/**
+ * @public
+ */
+export type RouteAnalysisCompletionResultCode = (typeof RouteAnalysisCompletionResultCode)[keyof typeof RouteAnalysisCompletionResultCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const RouteAnalysisStatus: {
+    readonly completed: "COMPLETED";
+    readonly failed: "FAILED";
+    readonly running: "RUNNING";
+};
+/**
+ * @public
+ */
+export type RouteAnalysisStatus = (typeof RouteAnalysisStatus)[keyof typeof RouteAnalysisStatus];

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

@@ -0,0 +1,183 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { ValidationExceptionReason } from "./enums";
+import { CoreNetworkPolicyError, ValidationExceptionField } from "./models_0";
+import { NetworkManagerServiceException as __BaseException } from "./NetworkManagerServiceException";
+/**
+ * <p>You do not have sufficient access to perform this action.</p>
+ * @public
+ */
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+/**
+ * <p>There was a conflict processing the request. Updating or deleting the resource can
+ *             cause an inconsistent state.</p>
+ * @public
+ */
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    /**
+     * <p>The ID of the resource.</p>
+     * @public
+     */
+    ResourceId: string | undefined;
+    /**
+     * <p>The resource type.</p>
+     * @public
+     */
+    ResourceType: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+/**
+ * <p>The request has failed due to an internal error.</p>
+ * @public
+ */
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    Message: string | undefined;
+    /**
+     * <p>Indicates when to retry the request.</p>
+     * @public
+     */
+    RetryAfterSeconds?: number | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+/**
+ * <p>The specified resource could not be found.</p>
+ * @public
+ */
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    /**
+     * <p>The ID of the resource.</p>
+     * @public
+     */
+    ResourceId: string | undefined;
+    /**
+     * <p>The resource type.</p>
+     * @public
+     */
+    ResourceType: string | undefined;
+    /**
+     * <p>The specified resource could not be found.</p>
+     * @public
+     */
+    Context?: Record<string, string> | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+/**
+ * <p>The request was denied due to request throttling.</p>
+ * @public
+ */
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    /**
+     * <p>Indicates when to retry the request.</p>
+     * @public
+     */
+    RetryAfterSeconds?: number | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+/**
+ * <p>The input fails to satisfy the constraints.</p>
+ * @public
+ */
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    /**
+     * <p>The reason for the error.</p>
+     * @public
+     */
+    Reason?: ValidationExceptionReason | undefined;
+    /**
+     * <p>The fields that caused the error, if applicable.</p>
+     * @public
+     */
+    Fields?: ValidationExceptionField[] | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+/**
+ * <p>A service limit was exceeded.</p>
+ * @public
+ */
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    /**
+     * <p>The error message.</p>
+     * @public
+     */
+    Message: string | undefined;
+    /**
+     * <p>The ID of the resource.</p>
+     * @public
+     */
+    ResourceId?: string | undefined;
+    /**
+     * <p>The resource type.</p>
+     * @public
+     */
+    ResourceType?: string | undefined;
+    /**
+     * <p>The limit code.</p>
+     * @public
+     */
+    LimitCode: string | undefined;
+    /**
+     * <p>The service code.</p>
+     * @public
+     */
+    ServiceCode: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+/**
+ * <p>Describes a core network policy exception.</p>
+ * @public
+ */
+export declare class CoreNetworkPolicyException extends __BaseException {
+    readonly name: "CoreNetworkPolicyException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    /**
+     * <p>Describes a core network policy exception.</p>
+     * @public
+     */
+    Errors?: CoreNetworkPolicyError[] | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CoreNetworkPolicyException, __BaseException>);
+}