@aws-sdk/client-app-mesh 3.50.0 → 3.53.0

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

@@ -0,0 +1,3352 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { AppMeshServiceException as __BaseException } from "./AppMeshServiceException";
+
+export interface FileAccessLog {
+    
+    path: string | undefined;
+}
+export declare namespace FileAccessLog {
+    
+    const filterSensitiveLog: (obj: FileAccessLog) => any;
+}
+
+export declare type AccessLog = AccessLog.FileMember | AccessLog.$UnknownMember;
+export declare namespace AccessLog {
+    
+    interface FileMember {
+        file: FileAccessLog;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        file?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        file: (value: FileAccessLog) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: AccessLog, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: AccessLog) => any;
+}
+
+export declare class BadRequestException extends __BaseException {
+    readonly name: "BadRequestException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BadRequestException, __BaseException>);
+}
+
+export declare class ForbiddenException extends __BaseException {
+    readonly name: "ForbiddenException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ForbiddenException, __BaseException>);
+}
+
+export declare class InternalServerErrorException extends __BaseException {
+    readonly name: "InternalServerErrorException";
+    readonly $fault: "server";
+    $retryable: {};
+    
+    constructor(opts: __ExceptionOptionType<InternalServerErrorException, __BaseException>);
+}
+
+export interface ListTagsForResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    nextToken?: string;
+    
+    limit?: number;
+}
+export declare namespace ListTagsForResourceInput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceInput) => any;
+}
+
+export interface TagRef {
+    
+    key: string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace TagRef {
+    
+    const filterSensitiveLog: (obj: TagRef) => any;
+}
+
+export interface ListTagsForResourceOutput {
+    
+    tags: TagRef[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceOutput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceOutput) => any;
+}
+
+export declare class NotFoundException extends __BaseException {
+    readonly name: "NotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NotFoundException, __BaseException>);
+}
+
+export declare class ServiceUnavailableException extends __BaseException {
+    readonly name: "ServiceUnavailableException";
+    readonly $fault: "server";
+    $retryable: {};
+    
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
+}
+
+export declare class TooManyRequestsException extends __BaseException {
+    readonly name: "TooManyRequestsException";
+    readonly $fault: "client";
+    $retryable: {
+        throttling: boolean;
+    };
+    
+    constructor(opts: __ExceptionOptionType<TooManyRequestsException, __BaseException>);
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+export declare enum EgressFilterType {
+    ALLOW_ALL = "ALLOW_ALL",
+    DROP_ALL = "DROP_ALL"
+}
+
+export interface EgressFilter {
+    
+    type: EgressFilterType | string | undefined;
+}
+export declare namespace EgressFilter {
+    
+    const filterSensitiveLog: (obj: EgressFilter) => any;
+}
+
+export interface MeshSpec {
+    
+    egressFilter?: EgressFilter;
+}
+export declare namespace MeshSpec {
+    
+    const filterSensitiveLog: (obj: MeshSpec) => any;
+}
+
+export interface CreateMeshInput {
+    
+    meshName: string | undefined;
+    
+    spec?: MeshSpec;
+    
+    tags?: TagRef[];
+    
+    clientToken?: string;
+}
+export declare namespace CreateMeshInput {
+    
+    const filterSensitiveLog: (obj: CreateMeshInput) => any;
+}
+
+export interface ResourceMetadata {
+    
+    arn: string | undefined;
+    
+    version: number | undefined;
+    
+    uid: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastUpdatedAt: Date | undefined;
+    
+    meshOwner: string | undefined;
+    
+    resourceOwner: string | undefined;
+}
+export declare namespace ResourceMetadata {
+    
+    const filterSensitiveLog: (obj: ResourceMetadata) => any;
+}
+export declare enum MeshStatusCode {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    INACTIVE = "INACTIVE"
+}
+
+export interface MeshStatus {
+    
+    status?: MeshStatusCode | string;
+}
+export declare namespace MeshStatus {
+    
+    const filterSensitiveLog: (obj: MeshStatus) => any;
+}
+
+export interface MeshData {
+    
+    meshName: string | undefined;
+    
+    spec: MeshSpec | undefined;
+    
+    metadata: ResourceMetadata | undefined;
+    
+    status: MeshStatus | undefined;
+}
+export declare namespace MeshData {
+    
+    const filterSensitiveLog: (obj: MeshData) => any;
+}
+
+export interface CreateMeshOutput {
+    
+    mesh: MeshData | undefined;
+}
+export declare namespace CreateMeshOutput {
+    
+    const filterSensitiveLog: (obj: CreateMeshOutput) => any;
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+
+export interface DeleteMeshInput {
+    
+    meshName: string | undefined;
+}
+export declare namespace DeleteMeshInput {
+    
+    const filterSensitiveLog: (obj: DeleteMeshInput) => any;
+}
+
+export interface DeleteMeshOutput {
+    
+    mesh: MeshData | undefined;
+}
+export declare namespace DeleteMeshOutput {
+    
+    const filterSensitiveLog: (obj: DeleteMeshOutput) => any;
+}
+
+export declare class ResourceInUseException extends __BaseException {
+    readonly name: "ResourceInUseException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceInUseException, __BaseException>);
+}
+
+export interface DescribeMeshInput {
+    
+    meshName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DescribeMeshInput {
+    
+    const filterSensitiveLog: (obj: DescribeMeshInput) => any;
+}
+
+export interface DescribeMeshOutput {
+    
+    mesh: MeshData | undefined;
+}
+export declare namespace DescribeMeshOutput {
+    
+    const filterSensitiveLog: (obj: DescribeMeshOutput) => any;
+}
+
+export interface ListMeshesInput {
+    
+    nextToken?: string;
+    
+    limit?: number;
+}
+export declare namespace ListMeshesInput {
+    
+    const filterSensitiveLog: (obj: ListMeshesInput) => any;
+}
+
+export interface MeshRef {
+    
+    meshName: string | undefined;
+    
+    meshOwner: string | undefined;
+    
+    resourceOwner: string | undefined;
+    
+    arn: string | undefined;
+    
+    version: number | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastUpdatedAt: Date | undefined;
+}
+export declare namespace MeshRef {
+    
+    const filterSensitiveLog: (obj: MeshRef) => any;
+}
+
+export interface ListMeshesOutput {
+    
+    meshes: MeshRef[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListMeshesOutput {
+    
+    const filterSensitiveLog: (obj: ListMeshesOutput) => any;
+}
+
+export interface UpdateMeshInput {
+    
+    meshName: string | undefined;
+    
+    spec?: MeshSpec;
+    
+    clientToken?: string;
+}
+export declare namespace UpdateMeshInput {
+    
+    const filterSensitiveLog: (obj: UpdateMeshInput) => any;
+}
+
+export interface UpdateMeshOutput {
+    
+    mesh: MeshData | undefined;
+}
+export declare namespace UpdateMeshOutput {
+    
+    const filterSensitiveLog: (obj: UpdateMeshOutput) => any;
+}
+
+export interface VirtualGatewayListenerTlsFileCertificate {
+    
+    certificateChain: string | undefined;
+    
+    privateKey: string | undefined;
+}
+export declare namespace VirtualGatewayListenerTlsFileCertificate {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayListenerTlsFileCertificate) => any;
+}
+
+export interface VirtualGatewayListenerTlsSdsCertificate {
+    
+    secretName: string | undefined;
+}
+export declare namespace VirtualGatewayListenerTlsSdsCertificate {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayListenerTlsSdsCertificate) => any;
+}
+
+export declare type VirtualGatewayClientTlsCertificate = VirtualGatewayClientTlsCertificate.FileMember | VirtualGatewayClientTlsCertificate.SdsMember | VirtualGatewayClientTlsCertificate.$UnknownMember;
+export declare namespace VirtualGatewayClientTlsCertificate {
+    
+    interface FileMember {
+        file: VirtualGatewayListenerTlsFileCertificate;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface SdsMember {
+        file?: never;
+        sds: VirtualGatewayListenerTlsSdsCertificate;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        file?: never;
+        sds?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        file: (value: VirtualGatewayListenerTlsFileCertificate) => T;
+        sds: (value: VirtualGatewayListenerTlsSdsCertificate) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: VirtualGatewayClientTlsCertificate, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: VirtualGatewayClientTlsCertificate) => any;
+}
+
+export interface SubjectAlternativeNameMatchers {
+    
+    exact: string[] | undefined;
+}
+export declare namespace SubjectAlternativeNameMatchers {
+    
+    const filterSensitiveLog: (obj: SubjectAlternativeNameMatchers) => any;
+}
+
+export interface SubjectAlternativeNames {
+    
+    match: SubjectAlternativeNameMatchers | undefined;
+}
+export declare namespace SubjectAlternativeNames {
+    
+    const filterSensitiveLog: (obj: SubjectAlternativeNames) => any;
+}
+
+export interface VirtualGatewayTlsValidationContextAcmTrust {
+    
+    certificateAuthorityArns: string[] | undefined;
+}
+export declare namespace VirtualGatewayTlsValidationContextAcmTrust {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayTlsValidationContextAcmTrust) => any;
+}
+
+export interface VirtualGatewayTlsValidationContextFileTrust {
+    
+    certificateChain: string | undefined;
+}
+export declare namespace VirtualGatewayTlsValidationContextFileTrust {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayTlsValidationContextFileTrust) => any;
+}
+
+export interface VirtualGatewayTlsValidationContextSdsTrust {
+    
+    secretName: string | undefined;
+}
+export declare namespace VirtualGatewayTlsValidationContextSdsTrust {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayTlsValidationContextSdsTrust) => any;
+}
+
+export declare type VirtualGatewayTlsValidationContextTrust = VirtualGatewayTlsValidationContextTrust.AcmMember | VirtualGatewayTlsValidationContextTrust.FileMember | VirtualGatewayTlsValidationContextTrust.SdsMember | VirtualGatewayTlsValidationContextTrust.$UnknownMember;
+export declare namespace VirtualGatewayTlsValidationContextTrust {
+    
+    interface AcmMember {
+        acm: VirtualGatewayTlsValidationContextAcmTrust;
+        file?: never;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface FileMember {
+        acm?: never;
+        file: VirtualGatewayTlsValidationContextFileTrust;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface SdsMember {
+        acm?: never;
+        file?: never;
+        sds: VirtualGatewayTlsValidationContextSdsTrust;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        acm?: never;
+        file?: never;
+        sds?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        acm: (value: VirtualGatewayTlsValidationContextAcmTrust) => T;
+        file: (value: VirtualGatewayTlsValidationContextFileTrust) => T;
+        sds: (value: VirtualGatewayTlsValidationContextSdsTrust) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: VirtualGatewayTlsValidationContextTrust, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: VirtualGatewayTlsValidationContextTrust) => any;
+}
+
+export interface VirtualGatewayTlsValidationContext {
+    
+    trust: VirtualGatewayTlsValidationContextTrust | undefined;
+    
+    subjectAlternativeNames?: SubjectAlternativeNames;
+}
+export declare namespace VirtualGatewayTlsValidationContext {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayTlsValidationContext) => any;
+}
+
+export interface VirtualGatewayClientPolicyTls {
+    
+    enforce?: boolean;
+    
+    ports?: number[];
+    
+    certificate?: VirtualGatewayClientTlsCertificate;
+    
+    validation: VirtualGatewayTlsValidationContext | undefined;
+}
+export declare namespace VirtualGatewayClientPolicyTls {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayClientPolicyTls) => any;
+}
+
+export interface VirtualGatewayClientPolicy {
+    
+    tls?: VirtualGatewayClientPolicyTls;
+}
+export declare namespace VirtualGatewayClientPolicy {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayClientPolicy) => any;
+}
+
+export interface VirtualGatewayBackendDefaults {
+    
+    clientPolicy?: VirtualGatewayClientPolicy;
+}
+export declare namespace VirtualGatewayBackendDefaults {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayBackendDefaults) => any;
+}
+
+export interface VirtualGatewayGrpcConnectionPool {
+    
+    maxRequests: number | undefined;
+}
+export declare namespace VirtualGatewayGrpcConnectionPool {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayGrpcConnectionPool) => any;
+}
+
+export interface VirtualGatewayHttpConnectionPool {
+    
+    maxConnections: number | undefined;
+    
+    maxPendingRequests?: number;
+}
+export declare namespace VirtualGatewayHttpConnectionPool {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayHttpConnectionPool) => any;
+}
+
+export interface VirtualGatewayHttp2ConnectionPool {
+    
+    maxRequests: number | undefined;
+}
+export declare namespace VirtualGatewayHttp2ConnectionPool {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayHttp2ConnectionPool) => any;
+}
+
+export declare type VirtualGatewayConnectionPool = VirtualGatewayConnectionPool.GrpcMember | VirtualGatewayConnectionPool.HttpMember | VirtualGatewayConnectionPool.Http2Member | VirtualGatewayConnectionPool.$UnknownMember;
+export declare namespace VirtualGatewayConnectionPool {
+    
+    interface HttpMember {
+        http: VirtualGatewayHttpConnectionPool;
+        http2?: never;
+        grpc?: never;
+        $unknown?: never;
+    }
+    
+    interface Http2Member {
+        http?: never;
+        http2: VirtualGatewayHttp2ConnectionPool;
+        grpc?: never;
+        $unknown?: never;
+    }
+    
+    interface GrpcMember {
+        http?: never;
+        http2?: never;
+        grpc: VirtualGatewayGrpcConnectionPool;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        http?: never;
+        http2?: never;
+        grpc?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        http: (value: VirtualGatewayHttpConnectionPool) => T;
+        http2: (value: VirtualGatewayHttp2ConnectionPool) => T;
+        grpc: (value: VirtualGatewayGrpcConnectionPool) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: VirtualGatewayConnectionPool, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: VirtualGatewayConnectionPool) => any;
+}
+export declare enum VirtualGatewayPortProtocol {
+    GRPC = "grpc",
+    HTTP = "http",
+    HTTP2 = "http2"
+}
+
+export interface VirtualGatewayHealthCheckPolicy {
+    
+    timeoutMillis: number | undefined;
+    
+    intervalMillis: number | undefined;
+    
+    protocol: VirtualGatewayPortProtocol | string | undefined;
+    
+    port?: number;
+    
+    path?: string;
+    
+    healthyThreshold: number | undefined;
+    
+    unhealthyThreshold: number | undefined;
+}
+export declare namespace VirtualGatewayHealthCheckPolicy {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayHealthCheckPolicy) => any;
+}
+
+export interface VirtualGatewayPortMapping {
+    
+    port: number | undefined;
+    
+    protocol: VirtualGatewayPortProtocol | string | undefined;
+}
+export declare namespace VirtualGatewayPortMapping {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayPortMapping) => any;
+}
+
+export interface VirtualGatewayListenerTlsAcmCertificate {
+    
+    certificateArn: string | undefined;
+}
+export declare namespace VirtualGatewayListenerTlsAcmCertificate {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayListenerTlsAcmCertificate) => any;
+}
+
+export declare type VirtualGatewayListenerTlsCertificate = VirtualGatewayListenerTlsCertificate.AcmMember | VirtualGatewayListenerTlsCertificate.FileMember | VirtualGatewayListenerTlsCertificate.SdsMember | VirtualGatewayListenerTlsCertificate.$UnknownMember;
+export declare namespace VirtualGatewayListenerTlsCertificate {
+    
+    interface AcmMember {
+        acm: VirtualGatewayListenerTlsAcmCertificate;
+        file?: never;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface FileMember {
+        acm?: never;
+        file: VirtualGatewayListenerTlsFileCertificate;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface SdsMember {
+        acm?: never;
+        file?: never;
+        sds: VirtualGatewayListenerTlsSdsCertificate;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        acm?: never;
+        file?: never;
+        sds?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        acm: (value: VirtualGatewayListenerTlsAcmCertificate) => T;
+        file: (value: VirtualGatewayListenerTlsFileCertificate) => T;
+        sds: (value: VirtualGatewayListenerTlsSdsCertificate) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: VirtualGatewayListenerTlsCertificate, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: VirtualGatewayListenerTlsCertificate) => any;
+}
+export declare enum VirtualGatewayListenerTlsMode {
+    DISABLED = "DISABLED",
+    PERMISSIVE = "PERMISSIVE",
+    STRICT = "STRICT"
+}
+
+export declare type VirtualGatewayListenerTlsValidationContextTrust = VirtualGatewayListenerTlsValidationContextTrust.FileMember | VirtualGatewayListenerTlsValidationContextTrust.SdsMember | VirtualGatewayListenerTlsValidationContextTrust.$UnknownMember;
+export declare namespace VirtualGatewayListenerTlsValidationContextTrust {
+    
+    interface FileMember {
+        file: VirtualGatewayTlsValidationContextFileTrust;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface SdsMember {
+        file?: never;
+        sds: VirtualGatewayTlsValidationContextSdsTrust;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        file?: never;
+        sds?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        file: (value: VirtualGatewayTlsValidationContextFileTrust) => T;
+        sds: (value: VirtualGatewayTlsValidationContextSdsTrust) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: VirtualGatewayListenerTlsValidationContextTrust, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: VirtualGatewayListenerTlsValidationContextTrust) => any;
+}
+
+export interface VirtualGatewayListenerTlsValidationContext {
+    
+    trust: VirtualGatewayListenerTlsValidationContextTrust | undefined;
+    
+    subjectAlternativeNames?: SubjectAlternativeNames;
+}
+export declare namespace VirtualGatewayListenerTlsValidationContext {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayListenerTlsValidationContext) => any;
+}
+
+export interface VirtualGatewayListenerTls {
+    
+    mode: VirtualGatewayListenerTlsMode | string | undefined;
+    
+    validation?: VirtualGatewayListenerTlsValidationContext;
+    
+    certificate: VirtualGatewayListenerTlsCertificate | undefined;
+}
+export declare namespace VirtualGatewayListenerTls {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayListenerTls) => any;
+}
+
+export interface VirtualGatewayListener {
+    
+    healthCheck?: VirtualGatewayHealthCheckPolicy;
+    
+    portMapping: VirtualGatewayPortMapping | undefined;
+    
+    tls?: VirtualGatewayListenerTls;
+    
+    connectionPool?: VirtualGatewayConnectionPool;
+}
+export declare namespace VirtualGatewayListener {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayListener) => any;
+}
+
+export interface VirtualGatewayFileAccessLog {
+    
+    path: string | undefined;
+}
+export declare namespace VirtualGatewayFileAccessLog {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayFileAccessLog) => any;
+}
+
+export declare type VirtualGatewayAccessLog = VirtualGatewayAccessLog.FileMember | VirtualGatewayAccessLog.$UnknownMember;
+export declare namespace VirtualGatewayAccessLog {
+    
+    interface FileMember {
+        file: VirtualGatewayFileAccessLog;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        file?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        file: (value: VirtualGatewayFileAccessLog) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: VirtualGatewayAccessLog, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: VirtualGatewayAccessLog) => any;
+}
+
+export interface VirtualGatewayLogging {
+    
+    accessLog?: VirtualGatewayAccessLog;
+}
+export declare namespace VirtualGatewayLogging {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayLogging) => any;
+}
+
+export interface VirtualGatewaySpec {
+    
+    backendDefaults?: VirtualGatewayBackendDefaults;
+    
+    listeners: VirtualGatewayListener[] | undefined;
+    
+    logging?: VirtualGatewayLogging;
+}
+export declare namespace VirtualGatewaySpec {
+    
+    const filterSensitiveLog: (obj: VirtualGatewaySpec) => any;
+}
+export interface CreateVirtualGatewayInput {
+    
+    virtualGatewayName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    spec: VirtualGatewaySpec | undefined;
+    
+    tags?: TagRef[];
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace CreateVirtualGatewayInput {
+    
+    const filterSensitiveLog: (obj: CreateVirtualGatewayInput) => any;
+}
+export declare enum VirtualGatewayStatusCode {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    INACTIVE = "INACTIVE"
+}
+
+export interface VirtualGatewayStatus {
+    
+    status: VirtualGatewayStatusCode | string | undefined;
+}
+export declare namespace VirtualGatewayStatus {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayStatus) => any;
+}
+
+export interface VirtualGatewayData {
+    
+    meshName: string | undefined;
+    
+    virtualGatewayName: string | undefined;
+    
+    spec: VirtualGatewaySpec | undefined;
+    
+    metadata: ResourceMetadata | undefined;
+    
+    status: VirtualGatewayStatus | undefined;
+}
+export declare namespace VirtualGatewayData {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayData) => any;
+}
+export interface CreateVirtualGatewayOutput {
+    
+    virtualGateway: VirtualGatewayData | undefined;
+}
+export declare namespace CreateVirtualGatewayOutput {
+    
+    const filterSensitiveLog: (obj: CreateVirtualGatewayOutput) => any;
+}
+export interface DeleteVirtualGatewayInput {
+    
+    virtualGatewayName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DeleteVirtualGatewayInput {
+    
+    const filterSensitiveLog: (obj: DeleteVirtualGatewayInput) => any;
+}
+export interface DeleteVirtualGatewayOutput {
+    
+    virtualGateway: VirtualGatewayData | undefined;
+}
+export declare namespace DeleteVirtualGatewayOutput {
+    
+    const filterSensitiveLog: (obj: DeleteVirtualGatewayOutput) => any;
+}
+export interface DescribeVirtualGatewayInput {
+    
+    virtualGatewayName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DescribeVirtualGatewayInput {
+    
+    const filterSensitiveLog: (obj: DescribeVirtualGatewayInput) => any;
+}
+export interface DescribeVirtualGatewayOutput {
+    
+    virtualGateway: VirtualGatewayData | undefined;
+}
+export declare namespace DescribeVirtualGatewayOutput {
+    
+    const filterSensitiveLog: (obj: DescribeVirtualGatewayOutput) => any;
+}
+export declare enum DefaultGatewayRouteRewrite {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface GatewayRouteHostnameRewrite {
+    
+    defaultTargetHostname?: DefaultGatewayRouteRewrite | string;
+}
+export declare namespace GatewayRouteHostnameRewrite {
+    
+    const filterSensitiveLog: (obj: GatewayRouteHostnameRewrite) => any;
+}
+
+export interface GrpcGatewayRouteRewrite {
+    
+    hostname?: GatewayRouteHostnameRewrite;
+}
+export declare namespace GrpcGatewayRouteRewrite {
+    
+    const filterSensitiveLog: (obj: GrpcGatewayRouteRewrite) => any;
+}
+
+export interface GatewayRouteVirtualService {
+    
+    virtualServiceName: string | undefined;
+}
+export declare namespace GatewayRouteVirtualService {
+    
+    const filterSensitiveLog: (obj: GatewayRouteVirtualService) => any;
+}
+
+export interface GatewayRouteTarget {
+    
+    virtualService: GatewayRouteVirtualService | undefined;
+}
+export declare namespace GatewayRouteTarget {
+    
+    const filterSensitiveLog: (obj: GatewayRouteTarget) => any;
+}
+
+export interface GrpcGatewayRouteAction {
+    
+    target: GatewayRouteTarget | undefined;
+    
+    rewrite?: GrpcGatewayRouteRewrite;
+}
+export declare namespace GrpcGatewayRouteAction {
+    
+    const filterSensitiveLog: (obj: GrpcGatewayRouteAction) => any;
+}
+
+export interface GatewayRouteHostnameMatch {
+    
+    exact?: string;
+    
+    suffix?: string;
+}
+export declare namespace GatewayRouteHostnameMatch {
+    
+    const filterSensitiveLog: (obj: GatewayRouteHostnameMatch) => any;
+}
+
+export interface MatchRange {
+    
+    start: number | undefined;
+    
+    end: number | undefined;
+}
+export declare namespace MatchRange {
+    
+    const filterSensitiveLog: (obj: MatchRange) => any;
+}
+
+export declare type GrpcMetadataMatchMethod = GrpcMetadataMatchMethod.ExactMember | GrpcMetadataMatchMethod.PrefixMember | GrpcMetadataMatchMethod.RangeMember | GrpcMetadataMatchMethod.RegexMember | GrpcMetadataMatchMethod.SuffixMember | GrpcMetadataMatchMethod.$UnknownMember;
+export declare namespace GrpcMetadataMatchMethod {
+    
+    interface ExactMember {
+        exact: string;
+        regex?: never;
+        range?: never;
+        prefix?: never;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface RegexMember {
+        exact?: never;
+        regex: string;
+        range?: never;
+        prefix?: never;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface RangeMember {
+        exact?: never;
+        regex?: never;
+        range: MatchRange;
+        prefix?: never;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface PrefixMember {
+        exact?: never;
+        regex?: never;
+        range?: never;
+        prefix: string;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface SuffixMember {
+        exact?: never;
+        regex?: never;
+        range?: never;
+        prefix?: never;
+        suffix: string;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        exact?: never;
+        regex?: never;
+        range?: never;
+        prefix?: never;
+        suffix?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        exact: (value: string) => T;
+        regex: (value: string) => T;
+        range: (value: MatchRange) => T;
+        prefix: (value: string) => T;
+        suffix: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: GrpcMetadataMatchMethod, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: GrpcMetadataMatchMethod) => any;
+}
+
+export interface GrpcGatewayRouteMetadata {
+    
+    name: string | undefined;
+    
+    invert?: boolean;
+    
+    match?: GrpcMetadataMatchMethod;
+}
+export declare namespace GrpcGatewayRouteMetadata {
+    
+    const filterSensitiveLog: (obj: GrpcGatewayRouteMetadata) => any;
+}
+
+export interface GrpcGatewayRouteMatch {
+    
+    serviceName?: string;
+    
+    hostname?: GatewayRouteHostnameMatch;
+    
+    metadata?: GrpcGatewayRouteMetadata[];
+}
+export declare namespace GrpcGatewayRouteMatch {
+    
+    const filterSensitiveLog: (obj: GrpcGatewayRouteMatch) => any;
+}
+
+export interface GrpcGatewayRoute {
+    
+    match: GrpcGatewayRouteMatch | undefined;
+    
+    action: GrpcGatewayRouteAction | undefined;
+}
+export declare namespace GrpcGatewayRoute {
+    
+    const filterSensitiveLog: (obj: GrpcGatewayRoute) => any;
+}
+
+export interface HttpGatewayRoutePathRewrite {
+    
+    exact?: string;
+}
+export declare namespace HttpGatewayRoutePathRewrite {
+    
+    const filterSensitiveLog: (obj: HttpGatewayRoutePathRewrite) => any;
+}
+
+export interface HttpGatewayRoutePrefixRewrite {
+    
+    defaultPrefix?: DefaultGatewayRouteRewrite | string;
+    
+    value?: string;
+}
+export declare namespace HttpGatewayRoutePrefixRewrite {
+    
+    const filterSensitiveLog: (obj: HttpGatewayRoutePrefixRewrite) => any;
+}
+
+export interface HttpGatewayRouteRewrite {
+    
+    prefix?: HttpGatewayRoutePrefixRewrite;
+    
+    path?: HttpGatewayRoutePathRewrite;
+    
+    hostname?: GatewayRouteHostnameRewrite;
+}
+export declare namespace HttpGatewayRouteRewrite {
+    
+    const filterSensitiveLog: (obj: HttpGatewayRouteRewrite) => any;
+}
+
+export interface HttpGatewayRouteAction {
+    
+    target: GatewayRouteTarget | undefined;
+    
+    rewrite?: HttpGatewayRouteRewrite;
+}
+export declare namespace HttpGatewayRouteAction {
+    
+    const filterSensitiveLog: (obj: HttpGatewayRouteAction) => any;
+}
+
+export declare type HeaderMatchMethod = HeaderMatchMethod.ExactMember | HeaderMatchMethod.PrefixMember | HeaderMatchMethod.RangeMember | HeaderMatchMethod.RegexMember | HeaderMatchMethod.SuffixMember | HeaderMatchMethod.$UnknownMember;
+export declare namespace HeaderMatchMethod {
+    
+    interface ExactMember {
+        exact: string;
+        regex?: never;
+        range?: never;
+        prefix?: never;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface RegexMember {
+        exact?: never;
+        regex: string;
+        range?: never;
+        prefix?: never;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface RangeMember {
+        exact?: never;
+        regex?: never;
+        range: MatchRange;
+        prefix?: never;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface PrefixMember {
+        exact?: never;
+        regex?: never;
+        range?: never;
+        prefix: string;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface SuffixMember {
+        exact?: never;
+        regex?: never;
+        range?: never;
+        prefix?: never;
+        suffix: string;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        exact?: never;
+        regex?: never;
+        range?: never;
+        prefix?: never;
+        suffix?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        exact: (value: string) => T;
+        regex: (value: string) => T;
+        range: (value: MatchRange) => T;
+        prefix: (value: string) => T;
+        suffix: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: HeaderMatchMethod, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: HeaderMatchMethod) => any;
+}
+
+export interface HttpGatewayRouteHeader {
+    
+    name: string | undefined;
+    
+    invert?: boolean;
+    
+    match?: HeaderMatchMethod;
+}
+export declare namespace HttpGatewayRouteHeader {
+    
+    const filterSensitiveLog: (obj: HttpGatewayRouteHeader) => any;
+}
+export declare enum HttpMethod {
+    CONNECT = "CONNECT",
+    DELETE = "DELETE",
+    GET = "GET",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS",
+    PATCH = "PATCH",
+    POST = "POST",
+    PUT = "PUT",
+    TRACE = "TRACE"
+}
+
+export interface HttpPathMatch {
+    
+    exact?: string;
+    
+    regex?: string;
+}
+export declare namespace HttpPathMatch {
+    
+    const filterSensitiveLog: (obj: HttpPathMatch) => any;
+}
+
+export interface QueryParameterMatch {
+    
+    exact?: string;
+}
+export declare namespace QueryParameterMatch {
+    
+    const filterSensitiveLog: (obj: QueryParameterMatch) => any;
+}
+
+export interface HttpQueryParameter {
+    
+    name: string | undefined;
+    
+    match?: QueryParameterMatch;
+}
+export declare namespace HttpQueryParameter {
+    
+    const filterSensitiveLog: (obj: HttpQueryParameter) => any;
+}
+
+export interface HttpGatewayRouteMatch {
+    
+    prefix?: string;
+    
+    path?: HttpPathMatch;
+    
+    queryParameters?: HttpQueryParameter[];
+    
+    method?: HttpMethod | string;
+    
+    hostname?: GatewayRouteHostnameMatch;
+    
+    headers?: HttpGatewayRouteHeader[];
+}
+export declare namespace HttpGatewayRouteMatch {
+    
+    const filterSensitiveLog: (obj: HttpGatewayRouteMatch) => any;
+}
+
+export interface HttpGatewayRoute {
+    
+    match: HttpGatewayRouteMatch | undefined;
+    
+    action: HttpGatewayRouteAction | undefined;
+}
+export declare namespace HttpGatewayRoute {
+    
+    const filterSensitiveLog: (obj: HttpGatewayRoute) => any;
+}
+
+export interface GatewayRouteSpec {
+    
+    priority?: number;
+    
+    httpRoute?: HttpGatewayRoute;
+    
+    http2Route?: HttpGatewayRoute;
+    
+    grpcRoute?: GrpcGatewayRoute;
+}
+export declare namespace GatewayRouteSpec {
+    
+    const filterSensitiveLog: (obj: GatewayRouteSpec) => any;
+}
+export interface CreateGatewayRouteInput {
+    
+    gatewayRouteName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    virtualGatewayName: string | undefined;
+    
+    spec: GatewayRouteSpec | undefined;
+    
+    tags?: TagRef[];
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace CreateGatewayRouteInput {
+    
+    const filterSensitiveLog: (obj: CreateGatewayRouteInput) => any;
+}
+export declare enum GatewayRouteStatusCode {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    INACTIVE = "INACTIVE"
+}
+
+export interface GatewayRouteStatus {
+    
+    status: GatewayRouteStatusCode | string | undefined;
+}
+export declare namespace GatewayRouteStatus {
+    
+    const filterSensitiveLog: (obj: GatewayRouteStatus) => any;
+}
+
+export interface GatewayRouteData {
+    
+    meshName: string | undefined;
+    
+    gatewayRouteName: string | undefined;
+    
+    virtualGatewayName: string | undefined;
+    
+    spec: GatewayRouteSpec | undefined;
+    
+    metadata: ResourceMetadata | undefined;
+    
+    status: GatewayRouteStatus | undefined;
+}
+export declare namespace GatewayRouteData {
+    
+    const filterSensitiveLog: (obj: GatewayRouteData) => any;
+}
+export interface CreateGatewayRouteOutput {
+    
+    gatewayRoute: GatewayRouteData | undefined;
+}
+export declare namespace CreateGatewayRouteOutput {
+    
+    const filterSensitiveLog: (obj: CreateGatewayRouteOutput) => any;
+}
+export interface DeleteGatewayRouteInput {
+    
+    gatewayRouteName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    virtualGatewayName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DeleteGatewayRouteInput {
+    
+    const filterSensitiveLog: (obj: DeleteGatewayRouteInput) => any;
+}
+export interface DeleteGatewayRouteOutput {
+    
+    gatewayRoute: GatewayRouteData | undefined;
+}
+export declare namespace DeleteGatewayRouteOutput {
+    
+    const filterSensitiveLog: (obj: DeleteGatewayRouteOutput) => any;
+}
+export interface DescribeGatewayRouteInput {
+    
+    gatewayRouteName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    virtualGatewayName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DescribeGatewayRouteInput {
+    
+    const filterSensitiveLog: (obj: DescribeGatewayRouteInput) => any;
+}
+export interface DescribeGatewayRouteOutput {
+    
+    gatewayRoute: GatewayRouteData | undefined;
+}
+export declare namespace DescribeGatewayRouteOutput {
+    
+    const filterSensitiveLog: (obj: DescribeGatewayRouteOutput) => any;
+}
+export interface ListGatewayRoutesInput {
+    
+    meshName: string | undefined;
+    
+    virtualGatewayName: string | undefined;
+    
+    nextToken?: string;
+    
+    limit?: number;
+    
+    meshOwner?: string;
+}
+export declare namespace ListGatewayRoutesInput {
+    
+    const filterSensitiveLog: (obj: ListGatewayRoutesInput) => any;
+}
+
+export interface GatewayRouteRef {
+    
+    meshName: string | undefined;
+    
+    gatewayRouteName: string | undefined;
+    
+    virtualGatewayName: string | undefined;
+    
+    meshOwner: string | undefined;
+    
+    resourceOwner: string | undefined;
+    
+    arn: string | undefined;
+    
+    version: number | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastUpdatedAt: Date | undefined;
+}
+export declare namespace GatewayRouteRef {
+    
+    const filterSensitiveLog: (obj: GatewayRouteRef) => any;
+}
+export interface ListGatewayRoutesOutput {
+    
+    gatewayRoutes: GatewayRouteRef[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListGatewayRoutesOutput {
+    
+    const filterSensitiveLog: (obj: ListGatewayRoutesOutput) => any;
+}
+export interface UpdateGatewayRouteInput {
+    
+    gatewayRouteName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    virtualGatewayName: string | undefined;
+    
+    spec: GatewayRouteSpec | undefined;
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace UpdateGatewayRouteInput {
+    
+    const filterSensitiveLog: (obj: UpdateGatewayRouteInput) => any;
+}
+export interface UpdateGatewayRouteOutput {
+    
+    gatewayRoute: GatewayRouteData | undefined;
+}
+export declare namespace UpdateGatewayRouteOutput {
+    
+    const filterSensitiveLog: (obj: UpdateGatewayRouteOutput) => any;
+}
+export interface ListVirtualGatewaysInput {
+    
+    meshName: string | undefined;
+    
+    nextToken?: string;
+    
+    limit?: number;
+    
+    meshOwner?: string;
+}
+export declare namespace ListVirtualGatewaysInput {
+    
+    const filterSensitiveLog: (obj: ListVirtualGatewaysInput) => any;
+}
+
+export interface VirtualGatewayRef {
+    
+    meshName: string | undefined;
+    
+    virtualGatewayName: string | undefined;
+    
+    meshOwner: string | undefined;
+    
+    resourceOwner: string | undefined;
+    
+    arn: string | undefined;
+    
+    version: number | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastUpdatedAt: Date | undefined;
+}
+export declare namespace VirtualGatewayRef {
+    
+    const filterSensitiveLog: (obj: VirtualGatewayRef) => any;
+}
+export interface ListVirtualGatewaysOutput {
+    
+    virtualGateways: VirtualGatewayRef[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListVirtualGatewaysOutput {
+    
+    const filterSensitiveLog: (obj: ListVirtualGatewaysOutput) => any;
+}
+export interface UpdateVirtualGatewayInput {
+    
+    virtualGatewayName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    spec: VirtualGatewaySpec | undefined;
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace UpdateVirtualGatewayInput {
+    
+    const filterSensitiveLog: (obj: UpdateVirtualGatewayInput) => any;
+}
+export interface UpdateVirtualGatewayOutput {
+    
+    virtualGateway: VirtualGatewayData | undefined;
+}
+export declare namespace UpdateVirtualGatewayOutput {
+    
+    const filterSensitiveLog: (obj: UpdateVirtualGatewayOutput) => any;
+}
+
+export interface ListenerTlsFileCertificate {
+    
+    certificateChain: string | undefined;
+    
+    privateKey: string | undefined;
+}
+export declare namespace ListenerTlsFileCertificate {
+    
+    const filterSensitiveLog: (obj: ListenerTlsFileCertificate) => any;
+}
+
+export interface ListenerTlsSdsCertificate {
+    
+    secretName: string | undefined;
+}
+export declare namespace ListenerTlsSdsCertificate {
+    
+    const filterSensitiveLog: (obj: ListenerTlsSdsCertificate) => any;
+}
+
+export declare type ClientTlsCertificate = ClientTlsCertificate.FileMember | ClientTlsCertificate.SdsMember | ClientTlsCertificate.$UnknownMember;
+export declare namespace ClientTlsCertificate {
+    
+    interface FileMember {
+        file: ListenerTlsFileCertificate;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface SdsMember {
+        file?: never;
+        sds: ListenerTlsSdsCertificate;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        file?: never;
+        sds?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        file: (value: ListenerTlsFileCertificate) => T;
+        sds: (value: ListenerTlsSdsCertificate) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ClientTlsCertificate, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: ClientTlsCertificate) => any;
+}
+
+export interface TlsValidationContextAcmTrust {
+    
+    certificateAuthorityArns: string[] | undefined;
+}
+export declare namespace TlsValidationContextAcmTrust {
+    
+    const filterSensitiveLog: (obj: TlsValidationContextAcmTrust) => any;
+}
+
+export interface TlsValidationContextFileTrust {
+    
+    certificateChain: string | undefined;
+}
+export declare namespace TlsValidationContextFileTrust {
+    
+    const filterSensitiveLog: (obj: TlsValidationContextFileTrust) => any;
+}
+
+export interface TlsValidationContextSdsTrust {
+    
+    secretName: string | undefined;
+}
+export declare namespace TlsValidationContextSdsTrust {
+    
+    const filterSensitiveLog: (obj: TlsValidationContextSdsTrust) => any;
+}
+
+export declare type TlsValidationContextTrust = TlsValidationContextTrust.AcmMember | TlsValidationContextTrust.FileMember | TlsValidationContextTrust.SdsMember | TlsValidationContextTrust.$UnknownMember;
+export declare namespace TlsValidationContextTrust {
+    
+    interface AcmMember {
+        acm: TlsValidationContextAcmTrust;
+        file?: never;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface FileMember {
+        acm?: never;
+        file: TlsValidationContextFileTrust;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface SdsMember {
+        acm?: never;
+        file?: never;
+        sds: TlsValidationContextSdsTrust;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        acm?: never;
+        file?: never;
+        sds?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        acm: (value: TlsValidationContextAcmTrust) => T;
+        file: (value: TlsValidationContextFileTrust) => T;
+        sds: (value: TlsValidationContextSdsTrust) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: TlsValidationContextTrust, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: TlsValidationContextTrust) => any;
+}
+
+export interface TlsValidationContext {
+    
+    trust: TlsValidationContextTrust | undefined;
+    
+    subjectAlternativeNames?: SubjectAlternativeNames;
+}
+export declare namespace TlsValidationContext {
+    
+    const filterSensitiveLog: (obj: TlsValidationContext) => any;
+}
+
+export interface ClientPolicyTls {
+    
+    enforce?: boolean;
+    
+    ports?: number[];
+    
+    certificate?: ClientTlsCertificate;
+    
+    validation: TlsValidationContext | undefined;
+}
+export declare namespace ClientPolicyTls {
+    
+    const filterSensitiveLog: (obj: ClientPolicyTls) => any;
+}
+
+export interface ClientPolicy {
+    
+    tls?: ClientPolicyTls;
+}
+export declare namespace ClientPolicy {
+    
+    const filterSensitiveLog: (obj: ClientPolicy) => any;
+}
+
+export interface BackendDefaults {
+    
+    clientPolicy?: ClientPolicy;
+}
+export declare namespace BackendDefaults {
+    
+    const filterSensitiveLog: (obj: BackendDefaults) => any;
+}
+
+export interface VirtualServiceBackend {
+    
+    virtualServiceName: string | undefined;
+    
+    clientPolicy?: ClientPolicy;
+}
+export declare namespace VirtualServiceBackend {
+    
+    const filterSensitiveLog: (obj: VirtualServiceBackend) => any;
+}
+
+export declare type Backend = Backend.VirtualServiceMember | Backend.$UnknownMember;
+export declare namespace Backend {
+    
+    interface VirtualServiceMember {
+        virtualService: VirtualServiceBackend;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        virtualService?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        virtualService: (value: VirtualServiceBackend) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: Backend, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: Backend) => any;
+}
+
+export interface VirtualNodeGrpcConnectionPool {
+    
+    maxRequests: number | undefined;
+}
+export declare namespace VirtualNodeGrpcConnectionPool {
+    
+    const filterSensitiveLog: (obj: VirtualNodeGrpcConnectionPool) => any;
+}
+
+export interface VirtualNodeHttpConnectionPool {
+    
+    maxConnections: number | undefined;
+    
+    maxPendingRequests?: number;
+}
+export declare namespace VirtualNodeHttpConnectionPool {
+    
+    const filterSensitiveLog: (obj: VirtualNodeHttpConnectionPool) => any;
+}
+
+export interface VirtualNodeHttp2ConnectionPool {
+    
+    maxRequests: number | undefined;
+}
+export declare namespace VirtualNodeHttp2ConnectionPool {
+    
+    const filterSensitiveLog: (obj: VirtualNodeHttp2ConnectionPool) => any;
+}
+
+export interface VirtualNodeTcpConnectionPool {
+    
+    maxConnections: number | undefined;
+}
+export declare namespace VirtualNodeTcpConnectionPool {
+    
+    const filterSensitiveLog: (obj: VirtualNodeTcpConnectionPool) => any;
+}
+
+export declare type VirtualNodeConnectionPool = VirtualNodeConnectionPool.GrpcMember | VirtualNodeConnectionPool.HttpMember | VirtualNodeConnectionPool.Http2Member | VirtualNodeConnectionPool.TcpMember | VirtualNodeConnectionPool.$UnknownMember;
+export declare namespace VirtualNodeConnectionPool {
+    
+    interface TcpMember {
+        tcp: VirtualNodeTcpConnectionPool;
+        http?: never;
+        http2?: never;
+        grpc?: never;
+        $unknown?: never;
+    }
+    
+    interface HttpMember {
+        tcp?: never;
+        http: VirtualNodeHttpConnectionPool;
+        http2?: never;
+        grpc?: never;
+        $unknown?: never;
+    }
+    
+    interface Http2Member {
+        tcp?: never;
+        http?: never;
+        http2: VirtualNodeHttp2ConnectionPool;
+        grpc?: never;
+        $unknown?: never;
+    }
+    
+    interface GrpcMember {
+        tcp?: never;
+        http?: never;
+        http2?: never;
+        grpc: VirtualNodeGrpcConnectionPool;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        tcp?: never;
+        http?: never;
+        http2?: never;
+        grpc?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        tcp: (value: VirtualNodeTcpConnectionPool) => T;
+        http: (value: VirtualNodeHttpConnectionPool) => T;
+        http2: (value: VirtualNodeHttp2ConnectionPool) => T;
+        grpc: (value: VirtualNodeGrpcConnectionPool) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: VirtualNodeConnectionPool, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: VirtualNodeConnectionPool) => any;
+}
+export declare enum PortProtocol {
+    GRPC = "grpc",
+    HTTP = "http",
+    HTTP2 = "http2",
+    TCP = "tcp"
+}
+
+export interface HealthCheckPolicy {
+    
+    timeoutMillis: number | undefined;
+    
+    intervalMillis: number | undefined;
+    
+    protocol: PortProtocol | string | undefined;
+    
+    port?: number;
+    
+    path?: string;
+    
+    healthyThreshold: number | undefined;
+    
+    unhealthyThreshold: number | undefined;
+}
+export declare namespace HealthCheckPolicy {
+    
+    const filterSensitiveLog: (obj: HealthCheckPolicy) => any;
+}
+export declare enum DurationUnit {
+    MS = "ms",
+    S = "s"
+}
+
+export interface Duration {
+    
+    value?: number;
+    
+    unit?: DurationUnit | string;
+}
+export declare namespace Duration {
+    
+    const filterSensitiveLog: (obj: Duration) => any;
+}
+
+export interface OutlierDetection {
+    
+    maxServerErrors: number | undefined;
+    
+    interval: Duration | undefined;
+    
+    baseEjectionDuration: Duration | undefined;
+    
+    maxEjectionPercent: number | undefined;
+}
+export declare namespace OutlierDetection {
+    
+    const filterSensitiveLog: (obj: OutlierDetection) => any;
+}
+
+export interface PortMapping {
+    
+    port: number | undefined;
+    
+    protocol: PortProtocol | string | undefined;
+}
+export declare namespace PortMapping {
+    
+    const filterSensitiveLog: (obj: PortMapping) => any;
+}
+
+export interface GrpcTimeout {
+    
+    perRequest?: Duration;
+    
+    idle?: Duration;
+}
+export declare namespace GrpcTimeout {
+    
+    const filterSensitiveLog: (obj: GrpcTimeout) => any;
+}
+
+export interface HttpTimeout {
+    
+    perRequest?: Duration;
+    
+    idle?: Duration;
+}
+export declare namespace HttpTimeout {
+    
+    const filterSensitiveLog: (obj: HttpTimeout) => any;
+}
+
+export interface TcpTimeout {
+    
+    idle?: Duration;
+}
+export declare namespace TcpTimeout {
+    
+    const filterSensitiveLog: (obj: TcpTimeout) => any;
+}
+
+export declare type ListenerTimeout = ListenerTimeout.GrpcMember | ListenerTimeout.HttpMember | ListenerTimeout.Http2Member | ListenerTimeout.TcpMember | ListenerTimeout.$UnknownMember;
+export declare namespace ListenerTimeout {
+    
+    interface TcpMember {
+        tcp: TcpTimeout;
+        http?: never;
+        http2?: never;
+        grpc?: never;
+        $unknown?: never;
+    }
+    
+    interface HttpMember {
+        tcp?: never;
+        http: HttpTimeout;
+        http2?: never;
+        grpc?: never;
+        $unknown?: never;
+    }
+    
+    interface Http2Member {
+        tcp?: never;
+        http?: never;
+        http2: HttpTimeout;
+        grpc?: never;
+        $unknown?: never;
+    }
+    
+    interface GrpcMember {
+        tcp?: never;
+        http?: never;
+        http2?: never;
+        grpc: GrpcTimeout;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        tcp?: never;
+        http?: never;
+        http2?: never;
+        grpc?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        tcp: (value: TcpTimeout) => T;
+        http: (value: HttpTimeout) => T;
+        http2: (value: HttpTimeout) => T;
+        grpc: (value: GrpcTimeout) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ListenerTimeout, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: ListenerTimeout) => any;
+}
+
+export interface ListenerTlsAcmCertificate {
+    
+    certificateArn: string | undefined;
+}
+export declare namespace ListenerTlsAcmCertificate {
+    
+    const filterSensitiveLog: (obj: ListenerTlsAcmCertificate) => any;
+}
+
+export declare type ListenerTlsCertificate = ListenerTlsCertificate.AcmMember | ListenerTlsCertificate.FileMember | ListenerTlsCertificate.SdsMember | ListenerTlsCertificate.$UnknownMember;
+export declare namespace ListenerTlsCertificate {
+    
+    interface AcmMember {
+        acm: ListenerTlsAcmCertificate;
+        file?: never;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface FileMember {
+        acm?: never;
+        file: ListenerTlsFileCertificate;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface SdsMember {
+        acm?: never;
+        file?: never;
+        sds: ListenerTlsSdsCertificate;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        acm?: never;
+        file?: never;
+        sds?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        acm: (value: ListenerTlsAcmCertificate) => T;
+        file: (value: ListenerTlsFileCertificate) => T;
+        sds: (value: ListenerTlsSdsCertificate) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ListenerTlsCertificate, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: ListenerTlsCertificate) => any;
+}
+export declare enum ListenerTlsMode {
+    DISABLED = "DISABLED",
+    PERMISSIVE = "PERMISSIVE",
+    STRICT = "STRICT"
+}
+
+export declare type ListenerTlsValidationContextTrust = ListenerTlsValidationContextTrust.FileMember | ListenerTlsValidationContextTrust.SdsMember | ListenerTlsValidationContextTrust.$UnknownMember;
+export declare namespace ListenerTlsValidationContextTrust {
+    
+    interface FileMember {
+        file: TlsValidationContextFileTrust;
+        sds?: never;
+        $unknown?: never;
+    }
+    
+    interface SdsMember {
+        file?: never;
+        sds: TlsValidationContextSdsTrust;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        file?: never;
+        sds?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        file: (value: TlsValidationContextFileTrust) => T;
+        sds: (value: TlsValidationContextSdsTrust) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ListenerTlsValidationContextTrust, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: ListenerTlsValidationContextTrust) => any;
+}
+
+export interface ListenerTlsValidationContext {
+    
+    trust: ListenerTlsValidationContextTrust | undefined;
+    
+    subjectAlternativeNames?: SubjectAlternativeNames;
+}
+export declare namespace ListenerTlsValidationContext {
+    
+    const filterSensitiveLog: (obj: ListenerTlsValidationContext) => any;
+}
+
+export interface ListenerTls {
+    
+    mode: ListenerTlsMode | string | undefined;
+    
+    certificate: ListenerTlsCertificate | undefined;
+    
+    validation?: ListenerTlsValidationContext;
+}
+export declare namespace ListenerTls {
+    
+    const filterSensitiveLog: (obj: ListenerTls) => any;
+}
+
+export interface Listener {
+    
+    portMapping: PortMapping | undefined;
+    
+    tls?: ListenerTls;
+    
+    healthCheck?: HealthCheckPolicy;
+    
+    timeout?: ListenerTimeout;
+    
+    outlierDetection?: OutlierDetection;
+    
+    connectionPool?: VirtualNodeConnectionPool;
+}
+export declare namespace Listener {
+    
+    const filterSensitiveLog: (obj: Listener) => any;
+}
+
+export interface Logging {
+    
+    accessLog?: AccessLog;
+}
+export declare namespace Logging {
+    
+    const filterSensitiveLog: (obj: Logging) => any;
+}
+
+export interface AwsCloudMapInstanceAttribute {
+    
+    key: string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace AwsCloudMapInstanceAttribute {
+    
+    const filterSensitiveLog: (obj: AwsCloudMapInstanceAttribute) => any;
+}
+
+export interface AwsCloudMapServiceDiscovery {
+    
+    namespaceName: string | undefined;
+    
+    serviceName: string | undefined;
+    
+    attributes?: AwsCloudMapInstanceAttribute[];
+}
+export declare namespace AwsCloudMapServiceDiscovery {
+    
+    const filterSensitiveLog: (obj: AwsCloudMapServiceDiscovery) => any;
+}
+export declare enum DnsResponseType {
+    ENDPOINTS = "ENDPOINTS",
+    LOADBALANCER = "LOADBALANCER"
+}
+
+export interface DnsServiceDiscovery {
+    
+    hostname: string | undefined;
+    
+    responseType?: DnsResponseType | string;
+}
+export declare namespace DnsServiceDiscovery {
+    
+    const filterSensitiveLog: (obj: DnsServiceDiscovery) => any;
+}
+
+export declare type ServiceDiscovery = ServiceDiscovery.AwsCloudMapMember | ServiceDiscovery.DnsMember | ServiceDiscovery.$UnknownMember;
+export declare namespace ServiceDiscovery {
+    
+    interface DnsMember {
+        dns: DnsServiceDiscovery;
+        awsCloudMap?: never;
+        $unknown?: never;
+    }
+    
+    interface AwsCloudMapMember {
+        dns?: never;
+        awsCloudMap: AwsCloudMapServiceDiscovery;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        dns?: never;
+        awsCloudMap?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        dns: (value: DnsServiceDiscovery) => T;
+        awsCloudMap: (value: AwsCloudMapServiceDiscovery) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ServiceDiscovery, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: ServiceDiscovery) => any;
+}
+
+export interface VirtualNodeSpec {
+    
+    serviceDiscovery?: ServiceDiscovery;
+    
+    listeners?: Listener[];
+    
+    backends?: Backend[];
+    
+    backendDefaults?: BackendDefaults;
+    
+    logging?: Logging;
+}
+export declare namespace VirtualNodeSpec {
+    
+    const filterSensitiveLog: (obj: VirtualNodeSpec) => any;
+}
+
+export interface CreateVirtualNodeInput {
+    
+    virtualNodeName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    spec: VirtualNodeSpec | undefined;
+    
+    tags?: TagRef[];
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace CreateVirtualNodeInput {
+    
+    const filterSensitiveLog: (obj: CreateVirtualNodeInput) => any;
+}
+export declare enum VirtualNodeStatusCode {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    INACTIVE = "INACTIVE"
+}
+
+export interface VirtualNodeStatus {
+    
+    status: VirtualNodeStatusCode | string | undefined;
+}
+export declare namespace VirtualNodeStatus {
+    
+    const filterSensitiveLog: (obj: VirtualNodeStatus) => any;
+}
+
+export interface VirtualNodeData {
+    
+    meshName: string | undefined;
+    
+    virtualNodeName: string | undefined;
+    
+    spec: VirtualNodeSpec | undefined;
+    
+    metadata: ResourceMetadata | undefined;
+    
+    status: VirtualNodeStatus | undefined;
+}
+export declare namespace VirtualNodeData {
+    
+    const filterSensitiveLog: (obj: VirtualNodeData) => any;
+}
+
+export interface CreateVirtualNodeOutput {
+    
+    virtualNode: VirtualNodeData | undefined;
+}
+export declare namespace CreateVirtualNodeOutput {
+    
+    const filterSensitiveLog: (obj: CreateVirtualNodeOutput) => any;
+}
+
+export interface DeleteVirtualNodeInput {
+    
+    virtualNodeName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DeleteVirtualNodeInput {
+    
+    const filterSensitiveLog: (obj: DeleteVirtualNodeInput) => any;
+}
+
+export interface DeleteVirtualNodeOutput {
+    
+    virtualNode: VirtualNodeData | undefined;
+}
+export declare namespace DeleteVirtualNodeOutput {
+    
+    const filterSensitiveLog: (obj: DeleteVirtualNodeOutput) => any;
+}
+
+export interface DescribeVirtualNodeInput {
+    
+    virtualNodeName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DescribeVirtualNodeInput {
+    
+    const filterSensitiveLog: (obj: DescribeVirtualNodeInput) => any;
+}
+
+export interface DescribeVirtualNodeOutput {
+    
+    virtualNode: VirtualNodeData | undefined;
+}
+export declare namespace DescribeVirtualNodeOutput {
+    
+    const filterSensitiveLog: (obj: DescribeVirtualNodeOutput) => any;
+}
+
+export interface ListVirtualNodesInput {
+    
+    meshName: string | undefined;
+    
+    nextToken?: string;
+    
+    limit?: number;
+    
+    meshOwner?: string;
+}
+export declare namespace ListVirtualNodesInput {
+    
+    const filterSensitiveLog: (obj: ListVirtualNodesInput) => any;
+}
+
+export interface VirtualNodeRef {
+    
+    meshName: string | undefined;
+    
+    virtualNodeName: string | undefined;
+    
+    meshOwner: string | undefined;
+    
+    resourceOwner: string | undefined;
+    
+    arn: string | undefined;
+    
+    version: number | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastUpdatedAt: Date | undefined;
+}
+export declare namespace VirtualNodeRef {
+    
+    const filterSensitiveLog: (obj: VirtualNodeRef) => any;
+}
+
+export interface ListVirtualNodesOutput {
+    
+    virtualNodes: VirtualNodeRef[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListVirtualNodesOutput {
+    
+    const filterSensitiveLog: (obj: ListVirtualNodesOutput) => any;
+}
+
+export interface UpdateVirtualNodeInput {
+    
+    virtualNodeName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    spec: VirtualNodeSpec | undefined;
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace UpdateVirtualNodeInput {
+    
+    const filterSensitiveLog: (obj: UpdateVirtualNodeInput) => any;
+}
+
+export interface UpdateVirtualNodeOutput {
+    
+    virtualNode: VirtualNodeData | undefined;
+}
+export declare namespace UpdateVirtualNodeOutput {
+    
+    const filterSensitiveLog: (obj: UpdateVirtualNodeOutput) => any;
+}
+
+export interface VirtualRouterListener {
+    
+    portMapping: PortMapping | undefined;
+}
+export declare namespace VirtualRouterListener {
+    
+    const filterSensitiveLog: (obj: VirtualRouterListener) => any;
+}
+
+export interface VirtualRouterSpec {
+    
+    listeners?: VirtualRouterListener[];
+}
+export declare namespace VirtualRouterSpec {
+    
+    const filterSensitiveLog: (obj: VirtualRouterSpec) => any;
+}
+
+export interface CreateVirtualRouterInput {
+    
+    virtualRouterName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    spec: VirtualRouterSpec | undefined;
+    
+    tags?: TagRef[];
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace CreateVirtualRouterInput {
+    
+    const filterSensitiveLog: (obj: CreateVirtualRouterInput) => any;
+}
+export declare enum VirtualRouterStatusCode {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    INACTIVE = "INACTIVE"
+}
+
+export interface VirtualRouterStatus {
+    
+    status: VirtualRouterStatusCode | string | undefined;
+}
+export declare namespace VirtualRouterStatus {
+    
+    const filterSensitiveLog: (obj: VirtualRouterStatus) => any;
+}
+
+export interface VirtualRouterData {
+    
+    meshName: string | undefined;
+    
+    virtualRouterName: string | undefined;
+    
+    spec: VirtualRouterSpec | undefined;
+    
+    metadata: ResourceMetadata | undefined;
+    
+    status: VirtualRouterStatus | undefined;
+}
+export declare namespace VirtualRouterData {
+    
+    const filterSensitiveLog: (obj: VirtualRouterData) => any;
+}
+
+export interface CreateVirtualRouterOutput {
+    
+    virtualRouter: VirtualRouterData | undefined;
+}
+export declare namespace CreateVirtualRouterOutput {
+    
+    const filterSensitiveLog: (obj: CreateVirtualRouterOutput) => any;
+}
+
+export interface DeleteVirtualRouterInput {
+    
+    virtualRouterName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DeleteVirtualRouterInput {
+    
+    const filterSensitiveLog: (obj: DeleteVirtualRouterInput) => any;
+}
+
+export interface DeleteVirtualRouterOutput {
+    
+    virtualRouter: VirtualRouterData | undefined;
+}
+export declare namespace DeleteVirtualRouterOutput {
+    
+    const filterSensitiveLog: (obj: DeleteVirtualRouterOutput) => any;
+}
+
+export interface DescribeVirtualRouterInput {
+    
+    virtualRouterName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DescribeVirtualRouterInput {
+    
+    const filterSensitiveLog: (obj: DescribeVirtualRouterInput) => any;
+}
+
+export interface DescribeVirtualRouterOutput {
+    
+    virtualRouter: VirtualRouterData | undefined;
+}
+export declare namespace DescribeVirtualRouterOutput {
+    
+    const filterSensitiveLog: (obj: DescribeVirtualRouterOutput) => any;
+}
+
+export interface ListVirtualRoutersInput {
+    
+    meshName: string | undefined;
+    
+    nextToken?: string;
+    
+    limit?: number;
+    
+    meshOwner?: string;
+}
+export declare namespace ListVirtualRoutersInput {
+    
+    const filterSensitiveLog: (obj: ListVirtualRoutersInput) => any;
+}
+
+export interface VirtualRouterRef {
+    
+    meshName: string | undefined;
+    
+    virtualRouterName: string | undefined;
+    
+    meshOwner: string | undefined;
+    
+    resourceOwner: string | undefined;
+    
+    arn: string | undefined;
+    
+    version: number | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastUpdatedAt: Date | undefined;
+}
+export declare namespace VirtualRouterRef {
+    
+    const filterSensitiveLog: (obj: VirtualRouterRef) => any;
+}
+
+export interface ListVirtualRoutersOutput {
+    
+    virtualRouters: VirtualRouterRef[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListVirtualRoutersOutput {
+    
+    const filterSensitiveLog: (obj: ListVirtualRoutersOutput) => any;
+}
+
+export interface WeightedTarget {
+    
+    virtualNode: string | undefined;
+    
+    weight: number | undefined;
+}
+export declare namespace WeightedTarget {
+    
+    const filterSensitiveLog: (obj: WeightedTarget) => any;
+}
+
+export interface GrpcRouteAction {
+    
+    weightedTargets: WeightedTarget[] | undefined;
+}
+export declare namespace GrpcRouteAction {
+    
+    const filterSensitiveLog: (obj: GrpcRouteAction) => any;
+}
+
+export declare type GrpcRouteMetadataMatchMethod = GrpcRouteMetadataMatchMethod.ExactMember | GrpcRouteMetadataMatchMethod.PrefixMember | GrpcRouteMetadataMatchMethod.RangeMember | GrpcRouteMetadataMatchMethod.RegexMember | GrpcRouteMetadataMatchMethod.SuffixMember | GrpcRouteMetadataMatchMethod.$UnknownMember;
+export declare namespace GrpcRouteMetadataMatchMethod {
+    
+    interface ExactMember {
+        exact: string;
+        regex?: never;
+        range?: never;
+        prefix?: never;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface RegexMember {
+        exact?: never;
+        regex: string;
+        range?: never;
+        prefix?: never;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface RangeMember {
+        exact?: never;
+        regex?: never;
+        range: MatchRange;
+        prefix?: never;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface PrefixMember {
+        exact?: never;
+        regex?: never;
+        range?: never;
+        prefix: string;
+        suffix?: never;
+        $unknown?: never;
+    }
+    
+    interface SuffixMember {
+        exact?: never;
+        regex?: never;
+        range?: never;
+        prefix?: never;
+        suffix: string;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        exact?: never;
+        regex?: never;
+        range?: never;
+        prefix?: never;
+        suffix?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        exact: (value: string) => T;
+        regex: (value: string) => T;
+        range: (value: MatchRange) => T;
+        prefix: (value: string) => T;
+        suffix: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: GrpcRouteMetadataMatchMethod, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: GrpcRouteMetadataMatchMethod) => any;
+}
+
+export interface GrpcRouteMetadata {
+    
+    name: string | undefined;
+    
+    invert?: boolean;
+    
+    match?: GrpcRouteMetadataMatchMethod;
+}
+export declare namespace GrpcRouteMetadata {
+    
+    const filterSensitiveLog: (obj: GrpcRouteMetadata) => any;
+}
+
+export interface GrpcRouteMatch {
+    
+    serviceName?: string;
+    
+    methodName?: string;
+    
+    metadata?: GrpcRouteMetadata[];
+}
+export declare namespace GrpcRouteMatch {
+    
+    const filterSensitiveLog: (obj: GrpcRouteMatch) => any;
+}
+export declare enum GrpcRetryPolicyEvent {
+    CANCELLED = "cancelled",
+    DEADLINE_EXCEEDED = "deadline-exceeded",
+    INTERNAL = "internal",
+    RESOURCE_EXHAUSTED = "resource-exhausted",
+    UNAVAILABLE = "unavailable"
+}
+export declare enum TcpRetryPolicyEvent {
+    CONNECTION_ERROR = "connection-error"
+}
+
+export interface GrpcRetryPolicy {
+    
+    perRetryTimeout: Duration | undefined;
+    
+    maxRetries: number | undefined;
+    
+    httpRetryEvents?: string[];
+    
+    tcpRetryEvents?: (TcpRetryPolicyEvent | string)[];
+    
+    grpcRetryEvents?: (GrpcRetryPolicyEvent | string)[];
+}
+export declare namespace GrpcRetryPolicy {
+    
+    const filterSensitiveLog: (obj: GrpcRetryPolicy) => any;
+}
+
+export interface GrpcRoute {
+    
+    action: GrpcRouteAction | undefined;
+    
+    match: GrpcRouteMatch | undefined;
+    
+    retryPolicy?: GrpcRetryPolicy;
+    
+    timeout?: GrpcTimeout;
+}
+export declare namespace GrpcRoute {
+    
+    const filterSensitiveLog: (obj: GrpcRoute) => any;
+}
+
+export interface HttpRouteAction {
+    
+    weightedTargets: WeightedTarget[] | undefined;
+}
+export declare namespace HttpRouteAction {
+    
+    const filterSensitiveLog: (obj: HttpRouteAction) => any;
+}
+
+export interface HttpRouteHeader {
+    
+    name: string | undefined;
+    
+    invert?: boolean;
+    
+    match?: HeaderMatchMethod;
+}
+export declare namespace HttpRouteHeader {
+    
+    const filterSensitiveLog: (obj: HttpRouteHeader) => any;
+}
+export declare enum HttpScheme {
+    HTTP = "http",
+    HTTPS = "https"
+}
+
+export interface HttpRouteMatch {
+    
+    prefix?: string;
+    
+    path?: HttpPathMatch;
+    
+    queryParameters?: HttpQueryParameter[];
+    
+    method?: HttpMethod | string;
+    
+    scheme?: HttpScheme | string;
+    
+    headers?: HttpRouteHeader[];
+}
+export declare namespace HttpRouteMatch {
+    
+    const filterSensitiveLog: (obj: HttpRouteMatch) => any;
+}
+
+export interface HttpRetryPolicy {
+    
+    perRetryTimeout: Duration | undefined;
+    
+    maxRetries: number | undefined;
+    
+    httpRetryEvents?: string[];
+    
+    tcpRetryEvents?: (TcpRetryPolicyEvent | string)[];
+}
+export declare namespace HttpRetryPolicy {
+    
+    const filterSensitiveLog: (obj: HttpRetryPolicy) => any;
+}
+
+export interface HttpRoute {
+    
+    match: HttpRouteMatch | undefined;
+    
+    action: HttpRouteAction | undefined;
+    
+    retryPolicy?: HttpRetryPolicy;
+    
+    timeout?: HttpTimeout;
+}
+export declare namespace HttpRoute {
+    
+    const filterSensitiveLog: (obj: HttpRoute) => any;
+}
+
+export interface TcpRouteAction {
+    
+    weightedTargets: WeightedTarget[] | undefined;
+}
+export declare namespace TcpRouteAction {
+    
+    const filterSensitiveLog: (obj: TcpRouteAction) => any;
+}
+
+export interface TcpRoute {
+    
+    action: TcpRouteAction | undefined;
+    
+    timeout?: TcpTimeout;
+}
+export declare namespace TcpRoute {
+    
+    const filterSensitiveLog: (obj: TcpRoute) => any;
+}
+
+export interface RouteSpec {
+    
+    priority?: number;
+    
+    httpRoute?: HttpRoute;
+    
+    tcpRoute?: TcpRoute;
+    
+    http2Route?: HttpRoute;
+    
+    grpcRoute?: GrpcRoute;
+}
+export declare namespace RouteSpec {
+    
+    const filterSensitiveLog: (obj: RouteSpec) => any;
+}
+
+export interface CreateRouteInput {
+    
+    routeName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    virtualRouterName: string | undefined;
+    
+    spec: RouteSpec | undefined;
+    
+    tags?: TagRef[];
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace CreateRouteInput {
+    
+    const filterSensitiveLog: (obj: CreateRouteInput) => any;
+}
+export declare enum RouteStatusCode {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    INACTIVE = "INACTIVE"
+}
+
+export interface RouteStatus {
+    
+    status: RouteStatusCode | string | undefined;
+}
+export declare namespace RouteStatus {
+    
+    const filterSensitiveLog: (obj: RouteStatus) => any;
+}
+
+export interface RouteData {
+    
+    meshName: string | undefined;
+    
+    virtualRouterName: string | undefined;
+    
+    routeName: string | undefined;
+    
+    spec: RouteSpec | undefined;
+    
+    metadata: ResourceMetadata | undefined;
+    
+    status: RouteStatus | undefined;
+}
+export declare namespace RouteData {
+    
+    const filterSensitiveLog: (obj: RouteData) => any;
+}
+
+export interface CreateRouteOutput {
+    
+    route: RouteData | undefined;
+}
+export declare namespace CreateRouteOutput {
+    
+    const filterSensitiveLog: (obj: CreateRouteOutput) => any;
+}
+
+export interface DeleteRouteInput {
+    
+    routeName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    virtualRouterName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DeleteRouteInput {
+    
+    const filterSensitiveLog: (obj: DeleteRouteInput) => any;
+}
+
+export interface DeleteRouteOutput {
+    
+    route: RouteData | undefined;
+}
+export declare namespace DeleteRouteOutput {
+    
+    const filterSensitiveLog: (obj: DeleteRouteOutput) => any;
+}
+
+export interface DescribeRouteInput {
+    
+    routeName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    meshOwner?: string;
+    
+    virtualRouterName: string | undefined;
+}
+export declare namespace DescribeRouteInput {
+    
+    const filterSensitiveLog: (obj: DescribeRouteInput) => any;
+}
+
+export interface DescribeRouteOutput {
+    
+    route: RouteData | undefined;
+}
+export declare namespace DescribeRouteOutput {
+    
+    const filterSensitiveLog: (obj: DescribeRouteOutput) => any;
+}
+
+export interface ListRoutesInput {
+    
+    meshName: string | undefined;
+    
+    virtualRouterName: string | undefined;
+    
+    nextToken?: string;
+    
+    limit?: number;
+    
+    meshOwner?: string;
+}
+export declare namespace ListRoutesInput {
+    
+    const filterSensitiveLog: (obj: ListRoutesInput) => any;
+}
+
+export interface RouteRef {
+    
+    meshName: string | undefined;
+    
+    virtualRouterName: string | undefined;
+    
+    routeName: string | undefined;
+    
+    meshOwner: string | undefined;
+    
+    resourceOwner: string | undefined;
+    
+    arn: string | undefined;
+    
+    version: number | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastUpdatedAt: Date | undefined;
+}
+export declare namespace RouteRef {
+    
+    const filterSensitiveLog: (obj: RouteRef) => any;
+}
+
+export interface ListRoutesOutput {
+    
+    routes: RouteRef[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListRoutesOutput {
+    
+    const filterSensitiveLog: (obj: ListRoutesOutput) => any;
+}
+
+export interface UpdateRouteInput {
+    
+    routeName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    virtualRouterName: string | undefined;
+    
+    spec: RouteSpec | undefined;
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace UpdateRouteInput {
+    
+    const filterSensitiveLog: (obj: UpdateRouteInput) => any;
+}
+
+export interface UpdateRouteOutput {
+    
+    route: RouteData | undefined;
+}
+export declare namespace UpdateRouteOutput {
+    
+    const filterSensitiveLog: (obj: UpdateRouteOutput) => any;
+}
+
+export interface UpdateVirtualRouterInput {
+    
+    virtualRouterName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    spec: VirtualRouterSpec | undefined;
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace UpdateVirtualRouterInput {
+    
+    const filterSensitiveLog: (obj: UpdateVirtualRouterInput) => any;
+}
+
+export interface UpdateVirtualRouterOutput {
+    
+    virtualRouter: VirtualRouterData | undefined;
+}
+export declare namespace UpdateVirtualRouterOutput {
+    
+    const filterSensitiveLog: (obj: UpdateVirtualRouterOutput) => any;
+}
+
+export interface VirtualNodeServiceProvider {
+    
+    virtualNodeName: string | undefined;
+}
+export declare namespace VirtualNodeServiceProvider {
+    
+    const filterSensitiveLog: (obj: VirtualNodeServiceProvider) => any;
+}
+
+export interface VirtualRouterServiceProvider {
+    
+    virtualRouterName: string | undefined;
+}
+export declare namespace VirtualRouterServiceProvider {
+    
+    const filterSensitiveLog: (obj: VirtualRouterServiceProvider) => any;
+}
+
+export declare type VirtualServiceProvider = VirtualServiceProvider.VirtualNodeMember | VirtualServiceProvider.VirtualRouterMember | VirtualServiceProvider.$UnknownMember;
+export declare namespace VirtualServiceProvider {
+    
+    interface VirtualNodeMember {
+        virtualNode: VirtualNodeServiceProvider;
+        virtualRouter?: never;
+        $unknown?: never;
+    }
+    
+    interface VirtualRouterMember {
+        virtualNode?: never;
+        virtualRouter: VirtualRouterServiceProvider;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        virtualNode?: never;
+        virtualRouter?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        virtualNode: (value: VirtualNodeServiceProvider) => T;
+        virtualRouter: (value: VirtualRouterServiceProvider) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: VirtualServiceProvider, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: VirtualServiceProvider) => any;
+}
+
+export interface VirtualServiceSpec {
+    
+    provider?: VirtualServiceProvider;
+}
+export declare namespace VirtualServiceSpec {
+    
+    const filterSensitiveLog: (obj: VirtualServiceSpec) => any;
+}
+
+export interface CreateVirtualServiceInput {
+    
+    virtualServiceName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    spec: VirtualServiceSpec | undefined;
+    
+    tags?: TagRef[];
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace CreateVirtualServiceInput {
+    
+    const filterSensitiveLog: (obj: CreateVirtualServiceInput) => any;
+}
+export declare enum VirtualServiceStatusCode {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    INACTIVE = "INACTIVE"
+}
+
+export interface VirtualServiceStatus {
+    
+    status: VirtualServiceStatusCode | string | undefined;
+}
+export declare namespace VirtualServiceStatus {
+    
+    const filterSensitiveLog: (obj: VirtualServiceStatus) => any;
+}
+
+export interface VirtualServiceData {
+    
+    meshName: string | undefined;
+    
+    virtualServiceName: string | undefined;
+    
+    spec: VirtualServiceSpec | undefined;
+    
+    metadata: ResourceMetadata | undefined;
+    
+    status: VirtualServiceStatus | undefined;
+}
+export declare namespace VirtualServiceData {
+    
+    const filterSensitiveLog: (obj: VirtualServiceData) => any;
+}
+
+export interface CreateVirtualServiceOutput {
+    
+    virtualService: VirtualServiceData | undefined;
+}
+export declare namespace CreateVirtualServiceOutput {
+    
+    const filterSensitiveLog: (obj: CreateVirtualServiceOutput) => any;
+}
+
+export interface DeleteVirtualServiceInput {
+    
+    virtualServiceName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DeleteVirtualServiceInput {
+    
+    const filterSensitiveLog: (obj: DeleteVirtualServiceInput) => any;
+}
+
+export interface DeleteVirtualServiceOutput {
+    
+    virtualService: VirtualServiceData | undefined;
+}
+export declare namespace DeleteVirtualServiceOutput {
+    
+    const filterSensitiveLog: (obj: DeleteVirtualServiceOutput) => any;
+}
+
+export interface DescribeVirtualServiceInput {
+    
+    virtualServiceName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    meshOwner?: string;
+}
+export declare namespace DescribeVirtualServiceInput {
+    
+    const filterSensitiveLog: (obj: DescribeVirtualServiceInput) => any;
+}
+
+export interface DescribeVirtualServiceOutput {
+    
+    virtualService: VirtualServiceData | undefined;
+}
+export declare namespace DescribeVirtualServiceOutput {
+    
+    const filterSensitiveLog: (obj: DescribeVirtualServiceOutput) => any;
+}
+
+export interface ListVirtualServicesInput {
+    
+    meshName: string | undefined;
+    
+    nextToken?: string;
+    
+    limit?: number;
+    
+    meshOwner?: string;
+}
+export declare namespace ListVirtualServicesInput {
+    
+    const filterSensitiveLog: (obj: ListVirtualServicesInput) => any;
+}
+
+export interface VirtualServiceRef {
+    
+    meshName: string | undefined;
+    
+    virtualServiceName: string | undefined;
+    
+    meshOwner: string | undefined;
+    
+    resourceOwner: string | undefined;
+    
+    arn: string | undefined;
+    
+    version: number | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastUpdatedAt: Date | undefined;
+}
+export declare namespace VirtualServiceRef {
+    
+    const filterSensitiveLog: (obj: VirtualServiceRef) => any;
+}
+
+export interface ListVirtualServicesOutput {
+    
+    virtualServices: VirtualServiceRef[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListVirtualServicesOutput {
+    
+    const filterSensitiveLog: (obj: ListVirtualServicesOutput) => any;
+}
+
+export interface UpdateVirtualServiceInput {
+    
+    virtualServiceName: string | undefined;
+    
+    meshName: string | undefined;
+    
+    spec: VirtualServiceSpec | undefined;
+    
+    clientToken?: string;
+    
+    meshOwner?: string;
+}
+export declare namespace UpdateVirtualServiceInput {
+    
+    const filterSensitiveLog: (obj: UpdateVirtualServiceInput) => any;
+}
+
+export interface UpdateVirtualServiceOutput {
+    
+    virtualService: VirtualServiceData | undefined;
+}
+export declare namespace UpdateVirtualServiceOutput {
+    
+    const filterSensitiveLog: (obj: UpdateVirtualServiceOutput) => any;
+}
+
+export interface TagResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    tags: TagRef[] | undefined;
+}
+export declare namespace TagResourceInput {
+    
+    const filterSensitiveLog: (obj: TagResourceInput) => any;
+}
+
+export interface TagResourceOutput {
+}
+export declare namespace TagResourceOutput {
+    
+    const filterSensitiveLog: (obj: TagResourceOutput) => any;
+}
+
+export declare class TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
+}
+
+export interface UntagResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceInput {
+    
+    const filterSensitiveLog: (obj: UntagResourceInput) => any;
+}
+
+export interface UntagResourceOutput {
+}
+export declare namespace UntagResourceOutput {
+    
+    const filterSensitiveLog: (obj: UntagResourceOutput) => any;
+}