@aws-sdk/client-api-gateway 3.34.0 → 3.37.0

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

@@ -0,0 +1,3016 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccessLogSettings {
+    
+    format?: string;
+    
+    destinationArn?: string;
+}
+export declare namespace AccessLogSettings {
+    
+    const filterSensitiveLog: (obj: AccessLogSettings) => any;
+}
+
+export interface ThrottleSettings {
+    
+    burstLimit?: number;
+    
+    rateLimit?: number;
+}
+export declare namespace ThrottleSettings {
+    
+    const filterSensitiveLog: (obj: ThrottleSettings) => any;
+}
+
+export interface Account {
+    
+    cloudwatchRoleArn?: string;
+    
+    throttleSettings?: ThrottleSettings;
+    
+    features?: string[];
+    
+    apiKeyVersion?: string;
+}
+export declare namespace Account {
+    
+    const filterSensitiveLog: (obj: Account) => any;
+}
+
+export interface ApiKey {
+    
+    id?: string;
+    
+    value?: string;
+    
+    name?: string;
+    
+    customerId?: string;
+    
+    description?: string;
+    
+    enabled?: boolean;
+    
+    createdDate?: Date;
+    
+    lastUpdatedDate?: Date;
+    
+    stageKeys?: string[];
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ApiKey {
+    
+    const filterSensitiveLog: (obj: ApiKey) => any;
+}
+
+export interface ApiKeyIds {
+    
+    ids?: string[];
+    
+    warnings?: string[];
+}
+export declare namespace ApiKeyIds {
+    
+    const filterSensitiveLog: (obj: ApiKeyIds) => any;
+}
+
+export interface ApiKeys {
+    
+    warnings?: string[];
+    
+    items?: ApiKey[];
+    
+    position?: string;
+}
+export declare namespace ApiKeys {
+    
+    const filterSensitiveLog: (obj: ApiKeys) => any;
+}
+export declare enum ApiKeysFormat {
+    csv = "csv"
+}
+export declare enum ApiKeySourceType {
+    AUTHORIZER = "AUTHORIZER",
+    HEADER = "HEADER"
+}
+
+export interface ApiStage {
+    
+    apiId?: string;
+    
+    stage?: string;
+    
+    throttle?: {
+        [key: string]: ThrottleSettings;
+    };
+}
+export declare namespace ApiStage {
+    
+    const filterSensitiveLog: (obj: ApiStage) => any;
+}
+export declare enum AuthorizerType {
+    COGNITO_USER_POOLS = "COGNITO_USER_POOLS",
+    REQUEST = "REQUEST",
+    TOKEN = "TOKEN"
+}
+
+export interface Authorizer {
+    
+    id?: string;
+    
+    name?: string;
+    
+    type?: AuthorizerType | string;
+    
+    providerARNs?: string[];
+    
+    authType?: string;
+    
+    authorizerUri?: string;
+    
+    authorizerCredentials?: string;
+    
+    identitySource?: string;
+    
+    identityValidationExpression?: string;
+    
+    authorizerResultTtlInSeconds?: number;
+}
+export declare namespace Authorizer {
+    
+    const filterSensitiveLog: (obj: Authorizer) => any;
+}
+
+export interface Authorizers {
+    
+    items?: Authorizer[];
+    
+    position?: string;
+}
+export declare namespace Authorizers {
+    
+    const filterSensitiveLog: (obj: Authorizers) => any;
+}
+
+export interface BadRequestException extends __SmithyException, $MetadataBearer {
+    name: "BadRequestException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace BadRequestException {
+    
+    const filterSensitiveLog: (obj: BadRequestException) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ConflictException {
+    
+    const filterSensitiveLog: (obj: ConflictException) => any;
+}
+
+export interface StageKey {
+    
+    restApiId?: string;
+    
+    stageName?: string;
+}
+export declare namespace StageKey {
+    
+    const filterSensitiveLog: (obj: StageKey) => any;
+}
+
+export interface CreateApiKeyRequest {
+    
+    name?: string;
+    
+    description?: string;
+    
+    enabled?: boolean;
+    
+    generateDistinctId?: boolean;
+    
+    value?: string;
+    
+    stageKeys?: StageKey[];
+    
+    customerId?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateApiKeyRequest {
+    
+    const filterSensitiveLog: (obj: CreateApiKeyRequest) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    retryAfterSeconds?: string;
+    message?: string;
+}
+export declare namespace LimitExceededException {
+    
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+
+export interface NotFoundException extends __SmithyException, $MetadataBearer {
+    name: "NotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace NotFoundException {
+    
+    const filterSensitiveLog: (obj: NotFoundException) => any;
+}
+
+export interface TooManyRequestsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyRequestsException";
+    $fault: "client";
+    retryAfterSeconds?: string;
+    message?: string;
+}
+export declare namespace TooManyRequestsException {
+    
+    const filterSensitiveLog: (obj: TooManyRequestsException) => any;
+}
+
+export interface UnauthorizedException extends __SmithyException, $MetadataBearer {
+    name: "UnauthorizedException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace UnauthorizedException {
+    
+    const filterSensitiveLog: (obj: UnauthorizedException) => any;
+}
+
+export interface CreateAuthorizerRequest {
+    
+    restApiId: string | undefined;
+    
+    name: string | undefined;
+    
+    type: AuthorizerType | string | undefined;
+    
+    providerARNs?: string[];
+    
+    authType?: string;
+    
+    authorizerUri?: string;
+    
+    authorizerCredentials?: string;
+    
+    identitySource?: string;
+    
+    identityValidationExpression?: string;
+    
+    authorizerResultTtlInSeconds?: number;
+}
+export declare namespace CreateAuthorizerRequest {
+    
+    const filterSensitiveLog: (obj: CreateAuthorizerRequest) => any;
+}
+
+export interface BasePathMapping {
+    
+    basePath?: string;
+    
+    restApiId?: string;
+    
+    stage?: string;
+}
+export declare namespace BasePathMapping {
+    
+    const filterSensitiveLog: (obj: BasePathMapping) => any;
+}
+
+export interface CreateBasePathMappingRequest {
+    
+    domainName: string | undefined;
+    
+    basePath?: string;
+    
+    restApiId: string | undefined;
+    
+    stage?: string;
+}
+export declare namespace CreateBasePathMappingRequest {
+    
+    const filterSensitiveLog: (obj: CreateBasePathMappingRequest) => any;
+}
+export declare enum CacheClusterSize {
+    SIZE_0_POINT_5_GB = "0.5",
+    SIZE_118_GB = "118",
+    SIZE_13_POINT_5_GB = "13.5",
+    SIZE_1_POINT_6_GB = "1.6",
+    SIZE_237_GB = "237",
+    SIZE_28_POINT_4_GB = "28.4",
+    SIZE_58_POINT_2_GB = "58.2",
+    SIZE_6_POINT_1_GB = "6.1"
+}
+
+export interface DeploymentCanarySettings {
+    
+    percentTraffic?: number;
+    
+    stageVariableOverrides?: {
+        [key: string]: string;
+    };
+    
+    useStageCache?: boolean;
+}
+export declare namespace DeploymentCanarySettings {
+    
+    const filterSensitiveLog: (obj: DeploymentCanarySettings) => any;
+}
+
+export interface CreateDeploymentRequest {
+    
+    restApiId: string | undefined;
+    
+    stageName?: string;
+    
+    stageDescription?: string;
+    
+    description?: string;
+    
+    cacheClusterEnabled?: boolean;
+    
+    cacheClusterSize?: CacheClusterSize | string;
+    
+    variables?: {
+        [key: string]: string;
+    };
+    
+    canarySettings?: DeploymentCanarySettings;
+    
+    tracingEnabled?: boolean;
+}
+export declare namespace CreateDeploymentRequest {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentRequest) => any;
+}
+
+export interface MethodSnapshot {
+    
+    authorizationType?: string;
+    
+    apiKeyRequired?: boolean;
+}
+export declare namespace MethodSnapshot {
+    
+    const filterSensitiveLog: (obj: MethodSnapshot) => any;
+}
+
+export interface Deployment {
+    
+    id?: string;
+    
+    description?: string;
+    
+    createdDate?: Date;
+    
+    apiSummary?: {
+        [key: string]: {
+            [key: string]: MethodSnapshot;
+        };
+    };
+}
+export declare namespace Deployment {
+    
+    const filterSensitiveLog: (obj: Deployment) => any;
+}
+
+export interface ServiceUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "ServiceUnavailableException";
+    $fault: "server";
+    retryAfterSeconds?: string;
+    message?: string;
+}
+export declare namespace ServiceUnavailableException {
+    
+    const filterSensitiveLog: (obj: ServiceUnavailableException) => any;
+}
+export declare enum DocumentationPartType {
+    API = "API",
+    AUTHORIZER = "AUTHORIZER",
+    METHOD = "METHOD",
+    MODEL = "MODEL",
+    PATH_PARAMETER = "PATH_PARAMETER",
+    QUERY_PARAMETER = "QUERY_PARAMETER",
+    REQUEST_BODY = "REQUEST_BODY",
+    REQUEST_HEADER = "REQUEST_HEADER",
+    RESOURCE = "RESOURCE",
+    RESPONSE = "RESPONSE",
+    RESPONSE_BODY = "RESPONSE_BODY",
+    RESPONSE_HEADER = "RESPONSE_HEADER"
+}
+
+export interface DocumentationPartLocation {
+    
+    type: DocumentationPartType | string | undefined;
+    
+    path?: string;
+    
+    method?: string;
+    
+    statusCode?: string;
+    
+    name?: string;
+}
+export declare namespace DocumentationPartLocation {
+    
+    const filterSensitiveLog: (obj: DocumentationPartLocation) => any;
+}
+
+export interface CreateDocumentationPartRequest {
+    
+    restApiId: string | undefined;
+    
+    location: DocumentationPartLocation | undefined;
+    
+    properties: string | undefined;
+}
+export declare namespace CreateDocumentationPartRequest {
+    
+    const filterSensitiveLog: (obj: CreateDocumentationPartRequest) => any;
+}
+
+export interface DocumentationPart {
+    
+    id?: string;
+    
+    location?: DocumentationPartLocation;
+    
+    properties?: string;
+}
+export declare namespace DocumentationPart {
+    
+    const filterSensitiveLog: (obj: DocumentationPart) => any;
+}
+
+export interface CreateDocumentationVersionRequest {
+    
+    restApiId: string | undefined;
+    
+    documentationVersion: string | undefined;
+    
+    stageName?: string;
+    
+    description?: string;
+}
+export declare namespace CreateDocumentationVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateDocumentationVersionRequest) => any;
+}
+
+export interface DocumentationVersion {
+    
+    version?: string;
+    
+    createdDate?: Date;
+    
+    description?: string;
+}
+export declare namespace DocumentationVersion {
+    
+    const filterSensitiveLog: (obj: DocumentationVersion) => any;
+}
+export declare type EndpointType = "EDGE" | "PRIVATE" | "REGIONAL";
+
+export interface EndpointConfiguration {
+    
+    types?: (EndpointType | string)[];
+    
+    vpcEndpointIds?: string[];
+}
+export declare namespace EndpointConfiguration {
+    
+    const filterSensitiveLog: (obj: EndpointConfiguration) => any;
+}
+
+export interface MutualTlsAuthenticationInput {
+    
+    truststoreUri?: string;
+    
+    truststoreVersion?: string;
+}
+export declare namespace MutualTlsAuthenticationInput {
+    
+    const filterSensitiveLog: (obj: MutualTlsAuthenticationInput) => any;
+}
+export declare type SecurityPolicy = "TLS_1_0" | "TLS_1_2";
+
+export interface CreateDomainNameRequest {
+    
+    domainName: string | undefined;
+    
+    certificateName?: string;
+    
+    certificateBody?: string;
+    
+    certificatePrivateKey?: string;
+    
+    certificateChain?: string;
+    
+    certificateArn?: string;
+    
+    regionalCertificateName?: string;
+    
+    regionalCertificateArn?: string;
+    
+    endpointConfiguration?: EndpointConfiguration;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    securityPolicy?: SecurityPolicy | string;
+    
+    mutualTlsAuthentication?: MutualTlsAuthenticationInput;
+    
+    ownershipVerificationCertificateArn?: string;
+}
+export declare namespace CreateDomainNameRequest {
+    
+    const filterSensitiveLog: (obj: CreateDomainNameRequest) => any;
+}
+export declare enum DomainNameStatus {
+    AVAILABLE = "AVAILABLE",
+    PENDING = "PENDING",
+    PENDING_CERTIFICATE_REIMPORT = "PENDING_CERTIFICATE_REIMPORT",
+    PENDING_OWNERSHIP_VERIFICATION = "PENDING_OWNERSHIP_VERIFICATION",
+    UPDATING = "UPDATING"
+}
+
+export interface MutualTlsAuthentication {
+    
+    truststoreUri?: string;
+    
+    truststoreVersion?: string;
+    
+    truststoreWarnings?: string[];
+}
+export declare namespace MutualTlsAuthentication {
+    
+    const filterSensitiveLog: (obj: MutualTlsAuthentication) => any;
+}
+
+export interface DomainName {
+    
+    domainName?: string;
+    
+    certificateName?: string;
+    
+    certificateArn?: string;
+    
+    certificateUploadDate?: Date;
+    
+    regionalDomainName?: string;
+    
+    regionalHostedZoneId?: string;
+    
+    regionalCertificateName?: string;
+    
+    regionalCertificateArn?: string;
+    
+    distributionDomainName?: string;
+    
+    distributionHostedZoneId?: string;
+    
+    endpointConfiguration?: EndpointConfiguration;
+    
+    domainNameStatus?: DomainNameStatus | string;
+    
+    domainNameStatusMessage?: string;
+    
+    securityPolicy?: SecurityPolicy | string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    mutualTlsAuthentication?: MutualTlsAuthentication;
+    
+    ownershipVerificationCertificateArn?: string;
+}
+export declare namespace DomainName {
+    
+    const filterSensitiveLog: (obj: DomainName) => any;
+}
+
+export interface CreateModelRequest {
+    
+    restApiId: string | undefined;
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    schema?: string;
+    
+    contentType: string | undefined;
+}
+export declare namespace CreateModelRequest {
+    
+    const filterSensitiveLog: (obj: CreateModelRequest) => any;
+}
+
+export interface Model {
+    
+    id?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    schema?: string;
+    
+    contentType?: string;
+}
+export declare namespace Model {
+    
+    const filterSensitiveLog: (obj: Model) => any;
+}
+
+export interface CreateRequestValidatorRequest {
+    
+    restApiId: string | undefined;
+    
+    name?: string;
+    
+    validateRequestBody?: boolean;
+    
+    validateRequestParameters?: boolean;
+}
+export declare namespace CreateRequestValidatorRequest {
+    
+    const filterSensitiveLog: (obj: CreateRequestValidatorRequest) => any;
+}
+
+export interface RequestValidator {
+    
+    id?: string;
+    
+    name?: string;
+    
+    validateRequestBody?: boolean;
+    
+    validateRequestParameters?: boolean;
+}
+export declare namespace RequestValidator {
+    
+    const filterSensitiveLog: (obj: RequestValidator) => any;
+}
+
+export interface CreateResourceRequest {
+    
+    restApiId: string | undefined;
+    
+    parentId: string | undefined;
+    
+    pathPart: string | undefined;
+}
+export declare namespace CreateResourceRequest {
+    
+    const filterSensitiveLog: (obj: CreateResourceRequest) => any;
+}
+export declare enum ConnectionType {
+    INTERNET = "INTERNET",
+    VPC_LINK = "VPC_LINK"
+}
+export declare enum ContentHandlingStrategy {
+    CONVERT_TO_BINARY = "CONVERT_TO_BINARY",
+    CONVERT_TO_TEXT = "CONVERT_TO_TEXT"
+}
+
+export interface IntegrationResponse {
+    
+    statusCode?: string;
+    
+    selectionPattern?: string;
+    
+    responseParameters?: {
+        [key: string]: string;
+    };
+    
+    responseTemplates?: {
+        [key: string]: string;
+    };
+    
+    contentHandling?: ContentHandlingStrategy | string;
+}
+export declare namespace IntegrationResponse {
+    
+    const filterSensitiveLog: (obj: IntegrationResponse) => any;
+}
+export interface TlsConfig {
+    
+    insecureSkipVerification?: boolean;
+}
+export declare namespace TlsConfig {
+    
+    const filterSensitiveLog: (obj: TlsConfig) => any;
+}
+export declare enum IntegrationType {
+    AWS = "AWS",
+    AWS_PROXY = "AWS_PROXY",
+    HTTP = "HTTP",
+    HTTP_PROXY = "HTTP_PROXY",
+    MOCK = "MOCK"
+}
+
+export interface Integration {
+    
+    type?: IntegrationType | string;
+    
+    httpMethod?: string;
+    
+    uri?: string;
+    
+    connectionType?: ConnectionType | string;
+    
+    connectionId?: string;
+    
+    credentials?: string;
+    
+    requestParameters?: {
+        [key: string]: string;
+    };
+    
+    requestTemplates?: {
+        [key: string]: string;
+    };
+    
+    passthroughBehavior?: string;
+    
+    contentHandling?: ContentHandlingStrategy | string;
+    
+    timeoutInMillis?: number;
+    
+    cacheNamespace?: string;
+    
+    cacheKeyParameters?: string[];
+    
+    integrationResponses?: {
+        [key: string]: IntegrationResponse;
+    };
+    
+    tlsConfig?: TlsConfig;
+}
+export declare namespace Integration {
+    
+    const filterSensitiveLog: (obj: Integration) => any;
+}
+
+export interface MethodResponse {
+    
+    statusCode?: string;
+    
+    responseParameters?: {
+        [key: string]: boolean;
+    };
+    
+    responseModels?: {
+        [key: string]: string;
+    };
+}
+export declare namespace MethodResponse {
+    
+    const filterSensitiveLog: (obj: MethodResponse) => any;
+}
+
+export interface Method {
+    
+    httpMethod?: string;
+    
+    authorizationType?: string;
+    
+    authorizerId?: string;
+    
+    apiKeyRequired?: boolean;
+    
+    requestValidatorId?: string;
+    
+    operationName?: string;
+    
+    requestParameters?: {
+        [key: string]: boolean;
+    };
+    
+    requestModels?: {
+        [key: string]: string;
+    };
+    
+    methodResponses?: {
+        [key: string]: MethodResponse;
+    };
+    
+    methodIntegration?: Integration;
+    
+    authorizationScopes?: string[];
+}
+export declare namespace Method {
+    
+    const filterSensitiveLog: (obj: Method) => any;
+}
+
+export interface Resource {
+    
+    id?: string;
+    
+    parentId?: string;
+    
+    pathPart?: string;
+    
+    path?: string;
+    
+    resourceMethods?: {
+        [key: string]: Method;
+    };
+}
+export declare namespace Resource {
+    
+    const filterSensitiveLog: (obj: Resource) => any;
+}
+
+export interface CreateRestApiRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    version?: string;
+    
+    cloneFrom?: string;
+    
+    binaryMediaTypes?: string[];
+    
+    minimumCompressionSize?: number;
+    
+    apiKeySource?: ApiKeySourceType | string;
+    
+    endpointConfiguration?: EndpointConfiguration;
+    
+    policy?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    disableExecuteApiEndpoint?: boolean;
+}
+export declare namespace CreateRestApiRequest {
+    
+    const filterSensitiveLog: (obj: CreateRestApiRequest) => any;
+}
+
+export interface RestApi {
+    
+    id?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    createdDate?: Date;
+    
+    version?: string;
+    
+    warnings?: string[];
+    
+    binaryMediaTypes?: string[];
+    
+    minimumCompressionSize?: number;
+    
+    apiKeySource?: ApiKeySourceType | string;
+    
+    endpointConfiguration?: EndpointConfiguration;
+    
+    policy?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    disableExecuteApiEndpoint?: boolean;
+}
+export declare namespace RestApi {
+    
+    const filterSensitiveLog: (obj: RestApi) => any;
+}
+
+export interface CanarySettings {
+    
+    percentTraffic?: number;
+    
+    deploymentId?: string;
+    
+    stageVariableOverrides?: {
+        [key: string]: string;
+    };
+    
+    useStageCache?: boolean;
+}
+export declare namespace CanarySettings {
+    
+    const filterSensitiveLog: (obj: CanarySettings) => any;
+}
+
+export interface CreateStageRequest {
+    
+    restApiId: string | undefined;
+    
+    stageName: string | undefined;
+    
+    deploymentId: string | undefined;
+    
+    description?: string;
+    
+    cacheClusterEnabled?: boolean;
+    
+    cacheClusterSize?: CacheClusterSize | string;
+    
+    variables?: {
+        [key: string]: string;
+    };
+    
+    documentationVersion?: string;
+    
+    canarySettings?: CanarySettings;
+    
+    tracingEnabled?: boolean;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateStageRequest {
+    
+    const filterSensitiveLog: (obj: CreateStageRequest) => any;
+}
+export declare enum CacheClusterStatus {
+    AVAILABLE = "AVAILABLE",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    FLUSH_IN_PROGRESS = "FLUSH_IN_PROGRESS",
+    NOT_AVAILABLE = "NOT_AVAILABLE"
+}
+export declare enum UnauthorizedCacheControlHeaderStrategy {
+    FAIL_WITH_403 = "FAIL_WITH_403",
+    SUCCEED_WITHOUT_RESPONSE_HEADER = "SUCCEED_WITHOUT_RESPONSE_HEADER",
+    SUCCEED_WITH_RESPONSE_HEADER = "SUCCEED_WITH_RESPONSE_HEADER"
+}
+
+export interface MethodSetting {
+    
+    metricsEnabled?: boolean;
+    
+    loggingLevel?: string;
+    
+    dataTraceEnabled?: boolean;
+    
+    throttlingBurstLimit?: number;
+    
+    throttlingRateLimit?: number;
+    
+    cachingEnabled?: boolean;
+    
+    cacheTtlInSeconds?: number;
+    
+    cacheDataEncrypted?: boolean;
+    
+    requireAuthorizationForCacheControl?: boolean;
+    
+    unauthorizedCacheControlHeaderStrategy?: UnauthorizedCacheControlHeaderStrategy | string;
+}
+export declare namespace MethodSetting {
+    
+    const filterSensitiveLog: (obj: MethodSetting) => any;
+}
+
+export interface Stage {
+    
+    deploymentId?: string;
+    
+    clientCertificateId?: string;
+    
+    stageName?: string;
+    
+    description?: string;
+    
+    cacheClusterEnabled?: boolean;
+    
+    cacheClusterSize?: CacheClusterSize | string;
+    
+    cacheClusterStatus?: CacheClusterStatus | string;
+    
+    methodSettings?: {
+        [key: string]: MethodSetting;
+    };
+    
+    variables?: {
+        [key: string]: string;
+    };
+    
+    documentationVersion?: string;
+    
+    accessLogSettings?: AccessLogSettings;
+    
+    canarySettings?: CanarySettings;
+    
+    tracingEnabled?: boolean;
+    
+    webAclArn?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    createdDate?: Date;
+    
+    lastUpdatedDate?: Date;
+}
+export declare namespace Stage {
+    
+    const filterSensitiveLog: (obj: Stage) => any;
+}
+export declare enum QuotaPeriodType {
+    DAY = "DAY",
+    MONTH = "MONTH",
+    WEEK = "WEEK"
+}
+
+export interface QuotaSettings {
+    
+    limit?: number;
+    
+    offset?: number;
+    
+    period?: QuotaPeriodType | string;
+}
+export declare namespace QuotaSettings {
+    
+    const filterSensitiveLog: (obj: QuotaSettings) => any;
+}
+
+export interface CreateUsagePlanRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    apiStages?: ApiStage[];
+    
+    throttle?: ThrottleSettings;
+    
+    quota?: QuotaSettings;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateUsagePlanRequest {
+    
+    const filterSensitiveLog: (obj: CreateUsagePlanRequest) => any;
+}
+
+export interface UsagePlan {
+    
+    id?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    apiStages?: ApiStage[];
+    
+    throttle?: ThrottleSettings;
+    
+    quota?: QuotaSettings;
+    
+    productCode?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UsagePlan {
+    
+    const filterSensitiveLog: (obj: UsagePlan) => any;
+}
+
+export interface CreateUsagePlanKeyRequest {
+    
+    usagePlanId: string | undefined;
+    
+    keyId: string | undefined;
+    
+    keyType: string | undefined;
+}
+export declare namespace CreateUsagePlanKeyRequest {
+    
+    const filterSensitiveLog: (obj: CreateUsagePlanKeyRequest) => any;
+}
+
+export interface UsagePlanKey {
+    
+    id?: string;
+    
+    type?: string;
+    
+    value?: string;
+    
+    name?: string;
+}
+export declare namespace UsagePlanKey {
+    
+    const filterSensitiveLog: (obj: UsagePlanKey) => any;
+}
+
+export interface CreateVpcLinkRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    targetArns: string[] | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateVpcLinkRequest {
+    
+    const filterSensitiveLog: (obj: CreateVpcLinkRequest) => any;
+}
+export declare enum VpcLinkStatus {
+    AVAILABLE = "AVAILABLE",
+    DELETING = "DELETING",
+    FAILED = "FAILED",
+    PENDING = "PENDING"
+}
+
+export interface VpcLink {
+    
+    id?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    targetArns?: string[];
+    
+    status?: VpcLinkStatus | string;
+    
+    statusMessage?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace VpcLink {
+    
+    const filterSensitiveLog: (obj: VpcLink) => any;
+}
+
+export interface DeleteApiKeyRequest {
+    
+    apiKey: string | undefined;
+}
+export declare namespace DeleteApiKeyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApiKeyRequest) => any;
+}
+
+export interface DeleteAuthorizerRequest {
+    
+    restApiId: string | undefined;
+    
+    authorizerId: string | undefined;
+}
+export declare namespace DeleteAuthorizerRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAuthorizerRequest) => any;
+}
+
+export interface DeleteBasePathMappingRequest {
+    
+    domainName: string | undefined;
+    
+    basePath: string | undefined;
+}
+export declare namespace DeleteBasePathMappingRequest {
+    
+    const filterSensitiveLog: (obj: DeleteBasePathMappingRequest) => any;
+}
+
+export interface DeleteClientCertificateRequest {
+    
+    clientCertificateId: string | undefined;
+}
+export declare namespace DeleteClientCertificateRequest {
+    
+    const filterSensitiveLog: (obj: DeleteClientCertificateRequest) => any;
+}
+
+export interface DeleteDeploymentRequest {
+    
+    restApiId: string | undefined;
+    
+    deploymentId: string | undefined;
+}
+export declare namespace DeleteDeploymentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDeploymentRequest) => any;
+}
+
+export interface DeleteDocumentationPartRequest {
+    
+    restApiId: string | undefined;
+    
+    documentationPartId: string | undefined;
+}
+export declare namespace DeleteDocumentationPartRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDocumentationPartRequest) => any;
+}
+
+export interface DeleteDocumentationVersionRequest {
+    
+    restApiId: string | undefined;
+    
+    documentationVersion: string | undefined;
+}
+export declare namespace DeleteDocumentationVersionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDocumentationVersionRequest) => any;
+}
+
+export interface DeleteDomainNameRequest {
+    
+    domainName: string | undefined;
+}
+export declare namespace DeleteDomainNameRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDomainNameRequest) => any;
+}
+export declare enum GatewayResponseType {
+    ACCESS_DENIED = "ACCESS_DENIED",
+    API_CONFIGURATION_ERROR = "API_CONFIGURATION_ERROR",
+    AUTHORIZER_CONFIGURATION_ERROR = "AUTHORIZER_CONFIGURATION_ERROR",
+    AUTHORIZER_FAILURE = "AUTHORIZER_FAILURE",
+    BAD_REQUEST_BODY = "BAD_REQUEST_BODY",
+    BAD_REQUEST_PARAMETERS = "BAD_REQUEST_PARAMETERS",
+    DEFAULT_4XX = "DEFAULT_4XX",
+    DEFAULT_5XX = "DEFAULT_5XX",
+    EXPIRED_TOKEN = "EXPIRED_TOKEN",
+    INTEGRATION_FAILURE = "INTEGRATION_FAILURE",
+    INTEGRATION_TIMEOUT = "INTEGRATION_TIMEOUT",
+    INVALID_API_KEY = "INVALID_API_KEY",
+    INVALID_SIGNATURE = "INVALID_SIGNATURE",
+    MISSING_AUTHENTICATION_TOKEN = "MISSING_AUTHENTICATION_TOKEN",
+    QUOTA_EXCEEDED = "QUOTA_EXCEEDED",
+    REQUEST_TOO_LARGE = "REQUEST_TOO_LARGE",
+    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND",
+    THROTTLED = "THROTTLED",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    UNSUPPORTED_MEDIA_TYPE = "UNSUPPORTED_MEDIA_TYPE",
+    WAF_FILTERED = "WAF_FILTERED"
+}
+
+export interface DeleteGatewayResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    responseType: GatewayResponseType | string | undefined;
+}
+export declare namespace DeleteGatewayResponseRequest {
+    
+    const filterSensitiveLog: (obj: DeleteGatewayResponseRequest) => any;
+}
+
+export interface DeleteIntegrationRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+}
+export declare namespace DeleteIntegrationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteIntegrationRequest) => any;
+}
+
+export interface DeleteIntegrationResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    statusCode: string | undefined;
+}
+export declare namespace DeleteIntegrationResponseRequest {
+    
+    const filterSensitiveLog: (obj: DeleteIntegrationResponseRequest) => any;
+}
+
+export interface DeleteMethodRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+}
+export declare namespace DeleteMethodRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMethodRequest) => any;
+}
+
+export interface DeleteMethodResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    statusCode: string | undefined;
+}
+export declare namespace DeleteMethodResponseRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMethodResponseRequest) => any;
+}
+
+export interface DeleteModelRequest {
+    
+    restApiId: string | undefined;
+    
+    modelName: string | undefined;
+}
+export declare namespace DeleteModelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteModelRequest) => any;
+}
+
+export interface DeleteRequestValidatorRequest {
+    
+    restApiId: string | undefined;
+    
+    requestValidatorId: string | undefined;
+}
+export declare namespace DeleteRequestValidatorRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRequestValidatorRequest) => any;
+}
+
+export interface DeleteResourceRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+}
+export declare namespace DeleteResourceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteResourceRequest) => any;
+}
+
+export interface DeleteRestApiRequest {
+    
+    restApiId: string | undefined;
+}
+export declare namespace DeleteRestApiRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRestApiRequest) => any;
+}
+
+export interface DeleteStageRequest {
+    
+    restApiId: string | undefined;
+    
+    stageName: string | undefined;
+}
+export declare namespace DeleteStageRequest {
+    
+    const filterSensitiveLog: (obj: DeleteStageRequest) => any;
+}
+
+export interface DeleteUsagePlanRequest {
+    
+    usagePlanId: string | undefined;
+}
+export declare namespace DeleteUsagePlanRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUsagePlanRequest) => any;
+}
+
+export interface DeleteUsagePlanKeyRequest {
+    
+    usagePlanId: string | undefined;
+    
+    keyId: string | undefined;
+}
+export declare namespace DeleteUsagePlanKeyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUsagePlanKeyRequest) => any;
+}
+
+export interface DeleteVpcLinkRequest {
+    
+    vpcLinkId: string | undefined;
+}
+export declare namespace DeleteVpcLinkRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVpcLinkRequest) => any;
+}
+
+export interface FlushStageAuthorizersCacheRequest {
+    
+    restApiId: string | undefined;
+    
+    stageName: string | undefined;
+}
+export declare namespace FlushStageAuthorizersCacheRequest {
+    
+    const filterSensitiveLog: (obj: FlushStageAuthorizersCacheRequest) => any;
+}
+
+export interface FlushStageCacheRequest {
+    
+    restApiId: string | undefined;
+    
+    stageName: string | undefined;
+}
+export declare namespace FlushStageCacheRequest {
+    
+    const filterSensitiveLog: (obj: FlushStageCacheRequest) => any;
+}
+
+export interface ClientCertificate {
+    
+    clientCertificateId?: string;
+    
+    description?: string;
+    
+    pemEncodedCertificate?: string;
+    
+    createdDate?: Date;
+    
+    expirationDate?: Date;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ClientCertificate {
+    
+    const filterSensitiveLog: (obj: ClientCertificate) => any;
+}
+
+export interface GenerateClientCertificateRequest {
+    
+    description?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GenerateClientCertificateRequest {
+    
+    const filterSensitiveLog: (obj: GenerateClientCertificateRequest) => any;
+}
+
+export interface GetAccountRequest {
+}
+export declare namespace GetAccountRequest {
+    
+    const filterSensitiveLog: (obj: GetAccountRequest) => any;
+}
+
+export interface GetApiKeyRequest {
+    
+    apiKey: string | undefined;
+    
+    includeValue?: boolean;
+}
+export declare namespace GetApiKeyRequest {
+    
+    const filterSensitiveLog: (obj: GetApiKeyRequest) => any;
+}
+
+export interface GetApiKeysRequest {
+    
+    position?: string;
+    
+    limit?: number;
+    
+    nameQuery?: string;
+    
+    customerId?: string;
+    
+    includeValues?: boolean;
+}
+export declare namespace GetApiKeysRequest {
+    
+    const filterSensitiveLog: (obj: GetApiKeysRequest) => any;
+}
+
+export interface GetAuthorizerRequest {
+    
+    restApiId: string | undefined;
+    
+    authorizerId: string | undefined;
+}
+export declare namespace GetAuthorizerRequest {
+    
+    const filterSensitiveLog: (obj: GetAuthorizerRequest) => any;
+}
+
+export interface GetAuthorizersRequest {
+    
+    restApiId: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetAuthorizersRequest {
+    
+    const filterSensitiveLog: (obj: GetAuthorizersRequest) => any;
+}
+
+export interface GetBasePathMappingRequest {
+    
+    domainName: string | undefined;
+    
+    basePath: string | undefined;
+}
+export declare namespace GetBasePathMappingRequest {
+    
+    const filterSensitiveLog: (obj: GetBasePathMappingRequest) => any;
+}
+
+export interface BasePathMappings {
+    
+    items?: BasePathMapping[];
+    
+    position?: string;
+}
+export declare namespace BasePathMappings {
+    
+    const filterSensitiveLog: (obj: BasePathMappings) => any;
+}
+
+export interface GetBasePathMappingsRequest {
+    
+    domainName: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetBasePathMappingsRequest {
+    
+    const filterSensitiveLog: (obj: GetBasePathMappingsRequest) => any;
+}
+
+export interface GetClientCertificateRequest {
+    
+    clientCertificateId: string | undefined;
+}
+export declare namespace GetClientCertificateRequest {
+    
+    const filterSensitiveLog: (obj: GetClientCertificateRequest) => any;
+}
+
+export interface ClientCertificates {
+    
+    items?: ClientCertificate[];
+    
+    position?: string;
+}
+export declare namespace ClientCertificates {
+    
+    const filterSensitiveLog: (obj: ClientCertificates) => any;
+}
+
+export interface GetClientCertificatesRequest {
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetClientCertificatesRequest {
+    
+    const filterSensitiveLog: (obj: GetClientCertificatesRequest) => any;
+}
+
+export interface GetDeploymentRequest {
+    
+    restApiId: string | undefined;
+    
+    deploymentId: string | undefined;
+    
+    embed?: string[];
+}
+export declare namespace GetDeploymentRequest {
+    
+    const filterSensitiveLog: (obj: GetDeploymentRequest) => any;
+}
+
+export interface Deployments {
+    
+    items?: Deployment[];
+    
+    position?: string;
+}
+export declare namespace Deployments {
+    
+    const filterSensitiveLog: (obj: Deployments) => any;
+}
+
+export interface GetDeploymentsRequest {
+    
+    restApiId: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetDeploymentsRequest {
+    
+    const filterSensitiveLog: (obj: GetDeploymentsRequest) => any;
+}
+
+export interface GetDocumentationPartRequest {
+    
+    restApiId: string | undefined;
+    
+    documentationPartId: string | undefined;
+}
+export declare namespace GetDocumentationPartRequest {
+    
+    const filterSensitiveLog: (obj: GetDocumentationPartRequest) => any;
+}
+
+export interface DocumentationParts {
+    
+    items?: DocumentationPart[];
+    
+    position?: string;
+}
+export declare namespace DocumentationParts {
+    
+    const filterSensitiveLog: (obj: DocumentationParts) => any;
+}
+export declare enum LocationStatusType {
+    DOCUMENTED = "DOCUMENTED",
+    UNDOCUMENTED = "UNDOCUMENTED"
+}
+
+export interface GetDocumentationPartsRequest {
+    
+    restApiId: string | undefined;
+    
+    type?: DocumentationPartType | string;
+    
+    nameQuery?: string;
+    
+    path?: string;
+    
+    position?: string;
+    
+    limit?: number;
+    
+    locationStatus?: LocationStatusType | string;
+}
+export declare namespace GetDocumentationPartsRequest {
+    
+    const filterSensitiveLog: (obj: GetDocumentationPartsRequest) => any;
+}
+
+export interface GetDocumentationVersionRequest {
+    
+    restApiId: string | undefined;
+    
+    documentationVersion: string | undefined;
+}
+export declare namespace GetDocumentationVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetDocumentationVersionRequest) => any;
+}
+
+export interface DocumentationVersions {
+    
+    items?: DocumentationVersion[];
+    
+    position?: string;
+}
+export declare namespace DocumentationVersions {
+    
+    const filterSensitiveLog: (obj: DocumentationVersions) => any;
+}
+
+export interface GetDocumentationVersionsRequest {
+    
+    restApiId: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetDocumentationVersionsRequest {
+    
+    const filterSensitiveLog: (obj: GetDocumentationVersionsRequest) => any;
+}
+
+export interface GetDomainNameRequest {
+    
+    domainName: string | undefined;
+}
+export declare namespace GetDomainNameRequest {
+    
+    const filterSensitiveLog: (obj: GetDomainNameRequest) => any;
+}
+
+export interface DomainNames {
+    
+    items?: DomainName[];
+    
+    position?: string;
+}
+export declare namespace DomainNames {
+    
+    const filterSensitiveLog: (obj: DomainNames) => any;
+}
+
+export interface GetDomainNamesRequest {
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetDomainNamesRequest {
+    
+    const filterSensitiveLog: (obj: GetDomainNamesRequest) => any;
+}
+
+export interface ExportResponse {
+    
+    contentType?: string;
+    
+    contentDisposition?: string;
+    
+    body?: Uint8Array;
+}
+export declare namespace ExportResponse {
+    
+    const filterSensitiveLog: (obj: ExportResponse) => any;
+}
+
+export interface GetExportRequest {
+    
+    restApiId: string | undefined;
+    
+    stageName: string | undefined;
+    
+    exportType: string | undefined;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    accepts?: string;
+}
+export declare namespace GetExportRequest {
+    
+    const filterSensitiveLog: (obj: GetExportRequest) => any;
+}
+
+export interface GatewayResponse {
+    
+    responseType?: GatewayResponseType | string;
+    
+    statusCode?: string;
+    
+    responseParameters?: {
+        [key: string]: string;
+    };
+    
+    responseTemplates?: {
+        [key: string]: string;
+    };
+    
+    defaultResponse?: boolean;
+}
+export declare namespace GatewayResponse {
+    
+    const filterSensitiveLog: (obj: GatewayResponse) => any;
+}
+
+export interface GetGatewayResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    responseType: GatewayResponseType | string | undefined;
+}
+export declare namespace GetGatewayResponseRequest {
+    
+    const filterSensitiveLog: (obj: GetGatewayResponseRequest) => any;
+}
+
+export interface GatewayResponses {
+    
+    items?: GatewayResponse[];
+    
+    position?: string;
+}
+export declare namespace GatewayResponses {
+    
+    const filterSensitiveLog: (obj: GatewayResponses) => any;
+}
+
+export interface GetGatewayResponsesRequest {
+    
+    restApiId: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetGatewayResponsesRequest {
+    
+    const filterSensitiveLog: (obj: GetGatewayResponsesRequest) => any;
+}
+
+export interface GetIntegrationRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+}
+export declare namespace GetIntegrationRequest {
+    
+    const filterSensitiveLog: (obj: GetIntegrationRequest) => any;
+}
+
+export interface GetIntegrationResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    statusCode: string | undefined;
+}
+export declare namespace GetIntegrationResponseRequest {
+    
+    const filterSensitiveLog: (obj: GetIntegrationResponseRequest) => any;
+}
+
+export interface GetMethodRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+}
+export declare namespace GetMethodRequest {
+    
+    const filterSensitiveLog: (obj: GetMethodRequest) => any;
+}
+
+export interface GetMethodResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    statusCode: string | undefined;
+}
+export declare namespace GetMethodResponseRequest {
+    
+    const filterSensitiveLog: (obj: GetMethodResponseRequest) => any;
+}
+
+export interface GetModelRequest {
+    
+    restApiId: string | undefined;
+    
+    modelName: string | undefined;
+    
+    flatten?: boolean;
+}
+export declare namespace GetModelRequest {
+    
+    const filterSensitiveLog: (obj: GetModelRequest) => any;
+}
+
+export interface GetModelsRequest {
+    
+    restApiId: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetModelsRequest {
+    
+    const filterSensitiveLog: (obj: GetModelsRequest) => any;
+}
+
+export interface Models {
+    
+    items?: Model[];
+    
+    position?: string;
+}
+export declare namespace Models {
+    
+    const filterSensitiveLog: (obj: Models) => any;
+}
+
+export interface GetModelTemplateRequest {
+    
+    restApiId: string | undefined;
+    
+    modelName: string | undefined;
+}
+export declare namespace GetModelTemplateRequest {
+    
+    const filterSensitiveLog: (obj: GetModelTemplateRequest) => any;
+}
+
+export interface Template {
+    
+    value?: string;
+}
+export declare namespace Template {
+    
+    const filterSensitiveLog: (obj: Template) => any;
+}
+
+export interface GetRequestValidatorRequest {
+    
+    restApiId: string | undefined;
+    
+    requestValidatorId: string | undefined;
+}
+export declare namespace GetRequestValidatorRequest {
+    
+    const filterSensitiveLog: (obj: GetRequestValidatorRequest) => any;
+}
+
+export interface GetRequestValidatorsRequest {
+    
+    restApiId: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetRequestValidatorsRequest {
+    
+    const filterSensitiveLog: (obj: GetRequestValidatorsRequest) => any;
+}
+
+export interface RequestValidators {
+    
+    items?: RequestValidator[];
+    
+    position?: string;
+}
+export declare namespace RequestValidators {
+    
+    const filterSensitiveLog: (obj: RequestValidators) => any;
+}
+
+export interface GetResourceRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    embed?: string[];
+}
+export declare namespace GetResourceRequest {
+    
+    const filterSensitiveLog: (obj: GetResourceRequest) => any;
+}
+
+export interface GetResourcesRequest {
+    
+    restApiId: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+    
+    embed?: string[];
+}
+export declare namespace GetResourcesRequest {
+    
+    const filterSensitiveLog: (obj: GetResourcesRequest) => any;
+}
+
+export interface Resources {
+    
+    items?: Resource[];
+    
+    position?: string;
+}
+export declare namespace Resources {
+    
+    const filterSensitiveLog: (obj: Resources) => any;
+}
+
+export interface GetRestApiRequest {
+    
+    restApiId: string | undefined;
+}
+export declare namespace GetRestApiRequest {
+    
+    const filterSensitiveLog: (obj: GetRestApiRequest) => any;
+}
+
+export interface GetRestApisRequest {
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetRestApisRequest {
+    
+    const filterSensitiveLog: (obj: GetRestApisRequest) => any;
+}
+
+export interface RestApis {
+    
+    items?: RestApi[];
+    
+    position?: string;
+}
+export declare namespace RestApis {
+    
+    const filterSensitiveLog: (obj: RestApis) => any;
+}
+
+export interface GetSdkRequest {
+    
+    restApiId: string | undefined;
+    
+    stageName: string | undefined;
+    
+    sdkType: string | undefined;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetSdkRequest {
+    
+    const filterSensitiveLog: (obj: GetSdkRequest) => any;
+}
+
+export interface SdkResponse {
+    
+    contentType?: string;
+    
+    contentDisposition?: string;
+    
+    body?: Uint8Array;
+}
+export declare namespace SdkResponse {
+    
+    const filterSensitiveLog: (obj: SdkResponse) => any;
+}
+
+export interface GetSdkTypeRequest {
+    
+    id: string | undefined;
+}
+export declare namespace GetSdkTypeRequest {
+    
+    const filterSensitiveLog: (obj: GetSdkTypeRequest) => any;
+}
+
+export interface SdkConfigurationProperty {
+    
+    name?: string;
+    
+    friendlyName?: string;
+    
+    description?: string;
+    
+    required?: boolean;
+    
+    defaultValue?: string;
+}
+export declare namespace SdkConfigurationProperty {
+    
+    const filterSensitiveLog: (obj: SdkConfigurationProperty) => any;
+}
+
+export interface SdkType {
+    
+    id?: string;
+    
+    friendlyName?: string;
+    
+    description?: string;
+    
+    configurationProperties?: SdkConfigurationProperty[];
+}
+export declare namespace SdkType {
+    
+    const filterSensitiveLog: (obj: SdkType) => any;
+}
+
+export interface GetSdkTypesRequest {
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetSdkTypesRequest {
+    
+    const filterSensitiveLog: (obj: GetSdkTypesRequest) => any;
+}
+
+export interface SdkTypes {
+    
+    items?: SdkType[];
+}
+export declare namespace SdkTypes {
+    
+    const filterSensitiveLog: (obj: SdkTypes) => any;
+}
+
+export interface GetStageRequest {
+    
+    restApiId: string | undefined;
+    
+    stageName: string | undefined;
+}
+export declare namespace GetStageRequest {
+    
+    const filterSensitiveLog: (obj: GetStageRequest) => any;
+}
+
+export interface GetStagesRequest {
+    
+    restApiId: string | undefined;
+    
+    deploymentId?: string;
+}
+export declare namespace GetStagesRequest {
+    
+    const filterSensitiveLog: (obj: GetStagesRequest) => any;
+}
+
+export interface Stages {
+    
+    item?: Stage[];
+}
+export declare namespace Stages {
+    
+    const filterSensitiveLog: (obj: Stages) => any;
+}
+
+export interface GetTagsRequest {
+    
+    resourceArn: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetTagsRequest {
+    
+    const filterSensitiveLog: (obj: GetTagsRequest) => any;
+}
+
+export interface Tags {
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Tags {
+    
+    const filterSensitiveLog: (obj: Tags) => any;
+}
+
+export interface GetUsageRequest {
+    
+    usagePlanId: string | undefined;
+    
+    keyId?: string;
+    
+    startDate: string | undefined;
+    
+    endDate: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetUsageRequest {
+    
+    const filterSensitiveLog: (obj: GetUsageRequest) => any;
+}
+
+export interface Usage {
+    
+    usagePlanId?: string;
+    
+    startDate?: string;
+    
+    endDate?: string;
+    
+    items?: {
+        [key: string]: number[][];
+    };
+    
+    position?: string;
+}
+export declare namespace Usage {
+    
+    const filterSensitiveLog: (obj: Usage) => any;
+}
+
+export interface GetUsagePlanRequest {
+    
+    usagePlanId: string | undefined;
+}
+export declare namespace GetUsagePlanRequest {
+    
+    const filterSensitiveLog: (obj: GetUsagePlanRequest) => any;
+}
+
+export interface GetUsagePlanKeyRequest {
+    
+    usagePlanId: string | undefined;
+    
+    keyId: string | undefined;
+}
+export declare namespace GetUsagePlanKeyRequest {
+    
+    const filterSensitiveLog: (obj: GetUsagePlanKeyRequest) => any;
+}
+
+export interface GetUsagePlanKeysRequest {
+    
+    usagePlanId: string | undefined;
+    
+    position?: string;
+    
+    limit?: number;
+    
+    nameQuery?: string;
+}
+export declare namespace GetUsagePlanKeysRequest {
+    
+    const filterSensitiveLog: (obj: GetUsagePlanKeysRequest) => any;
+}
+
+export interface UsagePlanKeys {
+    
+    items?: UsagePlanKey[];
+    
+    position?: string;
+}
+export declare namespace UsagePlanKeys {
+    
+    const filterSensitiveLog: (obj: UsagePlanKeys) => any;
+}
+
+export interface GetUsagePlansRequest {
+    
+    position?: string;
+    
+    keyId?: string;
+    
+    limit?: number;
+}
+export declare namespace GetUsagePlansRequest {
+    
+    const filterSensitiveLog: (obj: GetUsagePlansRequest) => any;
+}
+
+export interface UsagePlans {
+    
+    items?: UsagePlan[];
+    
+    position?: string;
+}
+export declare namespace UsagePlans {
+    
+    const filterSensitiveLog: (obj: UsagePlans) => any;
+}
+
+export interface GetVpcLinkRequest {
+    
+    vpcLinkId: string | undefined;
+}
+export declare namespace GetVpcLinkRequest {
+    
+    const filterSensitiveLog: (obj: GetVpcLinkRequest) => any;
+}
+
+export interface GetVpcLinksRequest {
+    
+    position?: string;
+    
+    limit?: number;
+}
+export declare namespace GetVpcLinksRequest {
+    
+    const filterSensitiveLog: (obj: GetVpcLinksRequest) => any;
+}
+
+export interface VpcLinks {
+    
+    items?: VpcLink[];
+    
+    position?: string;
+}
+export declare namespace VpcLinks {
+    
+    const filterSensitiveLog: (obj: VpcLinks) => any;
+}
+
+export interface ImportApiKeysRequest {
+    
+    body: Uint8Array | undefined;
+    
+    format: ApiKeysFormat | string | undefined;
+    
+    failOnWarnings?: boolean;
+}
+export declare namespace ImportApiKeysRequest {
+    
+    const filterSensitiveLog: (obj: ImportApiKeysRequest) => any;
+}
+
+export interface DocumentationPartIds {
+    
+    ids?: string[];
+    
+    warnings?: string[];
+}
+export declare namespace DocumentationPartIds {
+    
+    const filterSensitiveLog: (obj: DocumentationPartIds) => any;
+}
+export declare enum PutMode {
+    Merge = "merge",
+    Overwrite = "overwrite"
+}
+
+export interface ImportDocumentationPartsRequest {
+    
+    restApiId: string | undefined;
+    
+    mode?: PutMode | string;
+    
+    failOnWarnings?: boolean;
+    
+    body: Uint8Array | undefined;
+}
+export declare namespace ImportDocumentationPartsRequest {
+    
+    const filterSensitiveLog: (obj: ImportDocumentationPartsRequest) => any;
+}
+
+export interface ImportRestApiRequest {
+    
+    failOnWarnings?: boolean;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    body: Uint8Array | undefined;
+}
+export declare namespace ImportRestApiRequest {
+    
+    const filterSensitiveLog: (obj: ImportRestApiRequest) => any;
+}
+
+export interface PutGatewayResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    responseType: GatewayResponseType | string | undefined;
+    
+    statusCode?: string;
+    
+    responseParameters?: {
+        [key: string]: string;
+    };
+    
+    responseTemplates?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PutGatewayResponseRequest {
+    
+    const filterSensitiveLog: (obj: PutGatewayResponseRequest) => any;
+}
+
+export interface PutIntegrationRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    type: IntegrationType | string | undefined;
+    
+    integrationHttpMethod?: string;
+    
+    uri?: string;
+    
+    connectionType?: ConnectionType | string;
+    
+    connectionId?: string;
+    
+    credentials?: string;
+    
+    requestParameters?: {
+        [key: string]: string;
+    };
+    
+    requestTemplates?: {
+        [key: string]: string;
+    };
+    
+    passthroughBehavior?: string;
+    
+    cacheNamespace?: string;
+    
+    cacheKeyParameters?: string[];
+    
+    contentHandling?: ContentHandlingStrategy | string;
+    
+    timeoutInMillis?: number;
+    tlsConfig?: TlsConfig;
+}
+export declare namespace PutIntegrationRequest {
+    
+    const filterSensitiveLog: (obj: PutIntegrationRequest) => any;
+}
+
+export interface PutIntegrationResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    statusCode: string | undefined;
+    
+    selectionPattern?: string;
+    
+    responseParameters?: {
+        [key: string]: string;
+    };
+    
+    responseTemplates?: {
+        [key: string]: string;
+    };
+    
+    contentHandling?: ContentHandlingStrategy | string;
+}
+export declare namespace PutIntegrationResponseRequest {
+    
+    const filterSensitiveLog: (obj: PutIntegrationResponseRequest) => any;
+}
+
+export interface PutMethodRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    authorizationType: string | undefined;
+    
+    authorizerId?: string;
+    
+    apiKeyRequired?: boolean;
+    
+    operationName?: string;
+    
+    requestParameters?: {
+        [key: string]: boolean;
+    };
+    
+    requestModels?: {
+        [key: string]: string;
+    };
+    
+    requestValidatorId?: string;
+    
+    authorizationScopes?: string[];
+}
+export declare namespace PutMethodRequest {
+    
+    const filterSensitiveLog: (obj: PutMethodRequest) => any;
+}
+
+export interface PutMethodResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    statusCode: string | undefined;
+    
+    responseParameters?: {
+        [key: string]: boolean;
+    };
+    
+    responseModels?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PutMethodResponseRequest {
+    
+    const filterSensitiveLog: (obj: PutMethodResponseRequest) => any;
+}
+
+export interface PutRestApiRequest {
+    
+    restApiId: string | undefined;
+    
+    mode?: PutMode | string;
+    
+    failOnWarnings?: boolean;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    body: Uint8Array | undefined;
+}
+export declare namespace PutRestApiRequest {
+    
+    const filterSensitiveLog: (obj: PutRestApiRequest) => any;
+}
+
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+
+export interface TestInvokeAuthorizerRequest {
+    
+    restApiId: string | undefined;
+    
+    authorizerId: string | undefined;
+    
+    headers?: {
+        [key: string]: string;
+    };
+    
+    multiValueHeaders?: {
+        [key: string]: string[];
+    };
+    
+    pathWithQueryString?: string;
+    
+    body?: string;
+    
+    stageVariables?: {
+        [key: string]: string;
+    };
+    
+    additionalContext?: {
+        [key: string]: string;
+    };
+}
+export declare namespace TestInvokeAuthorizerRequest {
+    
+    const filterSensitiveLog: (obj: TestInvokeAuthorizerRequest) => any;
+}
+
+export interface TestInvokeAuthorizerResponse {
+    
+    clientStatus?: number;
+    
+    log?: string;
+    
+    latency?: number;
+    
+    principalId?: string;
+    
+    policy?: string;
+    authorization?: {
+        [key: string]: string[];
+    };
+    
+    claims?: {
+        [key: string]: string;
+    };
+}
+export declare namespace TestInvokeAuthorizerResponse {
+    
+    const filterSensitiveLog: (obj: TestInvokeAuthorizerResponse) => any;
+}
+
+export interface TestInvokeMethodRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    pathWithQueryString?: string;
+    
+    body?: string;
+    
+    headers?: {
+        [key: string]: string;
+    };
+    
+    multiValueHeaders?: {
+        [key: string]: string[];
+    };
+    
+    clientCertificateId?: string;
+    
+    stageVariables?: {
+        [key: string]: string;
+    };
+}
+export declare namespace TestInvokeMethodRequest {
+    
+    const filterSensitiveLog: (obj: TestInvokeMethodRequest) => any;
+}
+
+export interface TestInvokeMethodResponse {
+    
+    status?: number;
+    
+    body?: string;
+    
+    headers?: {
+        [key: string]: string;
+    };
+    
+    multiValueHeaders?: {
+        [key: string]: string[];
+    };
+    
+    log?: string;
+    
+    latency?: number;
+}
+export declare namespace TestInvokeMethodResponse {
+    
+    const filterSensitiveLog: (obj: TestInvokeMethodResponse) => any;
+}
+
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export declare type Op = "add" | "copy" | "move" | "remove" | "replace" | "test";
+
+export interface PatchOperation {
+    
+    op?: Op | string;
+    
+    path?: string;
+    
+    value?: string;
+    
+    from?: string;
+}
+export declare namespace PatchOperation {
+    
+    const filterSensitiveLog: (obj: PatchOperation) => any;
+}
+
+export interface UpdateAccountRequest {
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateAccountRequest {
+    
+    const filterSensitiveLog: (obj: UpdateAccountRequest) => any;
+}
+
+export interface UpdateApiKeyRequest {
+    
+    apiKey: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateApiKeyRequest {
+    
+    const filterSensitiveLog: (obj: UpdateApiKeyRequest) => any;
+}
+
+export interface UpdateAuthorizerRequest {
+    
+    restApiId: string | undefined;
+    
+    authorizerId: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateAuthorizerRequest {
+    
+    const filterSensitiveLog: (obj: UpdateAuthorizerRequest) => any;
+}
+
+export interface UpdateBasePathMappingRequest {
+    
+    domainName: string | undefined;
+    
+    basePath: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateBasePathMappingRequest {
+    
+    const filterSensitiveLog: (obj: UpdateBasePathMappingRequest) => any;
+}
+
+export interface UpdateClientCertificateRequest {
+    
+    clientCertificateId: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateClientCertificateRequest {
+    
+    const filterSensitiveLog: (obj: UpdateClientCertificateRequest) => any;
+}
+
+export interface UpdateDeploymentRequest {
+    
+    restApiId: string | undefined;
+    
+    deploymentId: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateDeploymentRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDeploymentRequest) => any;
+}
+
+export interface UpdateDocumentationPartRequest {
+    
+    restApiId: string | undefined;
+    
+    documentationPartId: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateDocumentationPartRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDocumentationPartRequest) => any;
+}
+
+export interface UpdateDocumentationVersionRequest {
+    
+    restApiId: string | undefined;
+    
+    documentationVersion: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateDocumentationVersionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDocumentationVersionRequest) => any;
+}
+
+export interface UpdateDomainNameRequest {
+    
+    domainName: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateDomainNameRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDomainNameRequest) => any;
+}
+
+export interface UpdateGatewayResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    responseType: GatewayResponseType | string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateGatewayResponseRequest {
+    
+    const filterSensitiveLog: (obj: UpdateGatewayResponseRequest) => any;
+}
+
+export interface UpdateIntegrationRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateIntegrationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateIntegrationRequest) => any;
+}
+
+export interface UpdateIntegrationResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    statusCode: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateIntegrationResponseRequest {
+    
+    const filterSensitiveLog: (obj: UpdateIntegrationResponseRequest) => any;
+}
+
+export interface UpdateMethodRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateMethodRequest {
+    
+    const filterSensitiveLog: (obj: UpdateMethodRequest) => any;
+}
+
+export interface UpdateMethodResponseRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    httpMethod: string | undefined;
+    
+    statusCode: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateMethodResponseRequest {
+    
+    const filterSensitiveLog: (obj: UpdateMethodResponseRequest) => any;
+}
+
+export interface UpdateModelRequest {
+    
+    restApiId: string | undefined;
+    
+    modelName: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateModelRequest {
+    
+    const filterSensitiveLog: (obj: UpdateModelRequest) => any;
+}
+
+export interface UpdateRequestValidatorRequest {
+    
+    restApiId: string | undefined;
+    
+    requestValidatorId: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateRequestValidatorRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRequestValidatorRequest) => any;
+}
+
+export interface UpdateResourceRequest {
+    
+    restApiId: string | undefined;
+    
+    resourceId: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateResourceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateResourceRequest) => any;
+}
+
+export interface UpdateRestApiRequest {
+    
+    restApiId: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateRestApiRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRestApiRequest) => any;
+}
+
+export interface UpdateStageRequest {
+    
+    restApiId: string | undefined;
+    
+    stageName: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateStageRequest {
+    
+    const filterSensitiveLog: (obj: UpdateStageRequest) => any;
+}
+
+export interface UpdateUsageRequest {
+    
+    usagePlanId: string | undefined;
+    
+    keyId: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateUsageRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUsageRequest) => any;
+}
+
+export interface UpdateUsagePlanRequest {
+    
+    usagePlanId: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateUsagePlanRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUsagePlanRequest) => any;
+}
+
+export interface UpdateVpcLinkRequest {
+    
+    vpcLinkId: string | undefined;
+    
+    patchOperations?: PatchOperation[];
+}
+export declare namespace UpdateVpcLinkRequest {
+    
+    const filterSensitiveLog: (obj: UpdateVpcLinkRequest) => any;
+}