'use strict';

var client$1 = require('@aws-sdk/core/client');
var core = require('@smithy/core');
var client = require('@smithy/core/client');
var config = require('@smithy/core/config');
var endpoints = require('@smithy/core/endpoints');
var protocols = require('@smithy/core/protocols');
var retry = require('@smithy/core/retry');
var schema = require('@smithy/core/schema');
var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
var runtimeConfig = require('./runtimeConfig');
var schemas_0 = require('./schemas/schemas_0');
var errors = require('./models/errors');
var AppSyncServiceException = require('./models/AppSyncServiceException');

const resolveClientEndpointParameters = (options) => {
    return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "appsync",
    });
};
const commonParams = {
    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
    Endpoint: { type: "builtInParams", name: "endpoint" },
    Region: { type: "builtInParams", name: "region" },
    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
};

const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
    let _credentials = runtimeConfig.credentials;
    return {
        setHttpAuthScheme(httpAuthScheme) {
            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
            if (index === -1) {
                _httpAuthSchemes.push(httpAuthScheme);
            }
            else {
                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
            }
        },
        httpAuthSchemes() {
            return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
            _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
            return _httpAuthSchemeProvider;
        },
        setCredentials(credentials) {
            _credentials = credentials;
        },
        credentials() {
            return _credentials;
        },
    };
};
const resolveHttpAuthRuntimeConfig = (config) => {
    return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials(),
    };
};

const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
    extensions.forEach((extension) => extension.configure(extensionConfiguration));
    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};

class AppSyncClient extends client.Client {
    config;
    constructor(...[configuration]) {
        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
        super(_config_0);
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters(_config_0);
        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
        const _config_3 = retry.resolveRetryConfig(_config_2);
        const _config_4 = config.resolveRegionConfig(_config_3);
        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
        this.config = _config_8;
        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
        this.middlewareStack.use(retry.getRetryPlugin(this.config));
        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultAppSyncHttpAuthSchemeParametersProvider,
            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

class AssociateApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "AssociateApi", {})
    .n("AppSyncClient", "AssociateApiCommand")
    .sc(schemas_0.AssociateApi$)
    .build() {
}

class AssociateMergedGraphqlApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "AssociateMergedGraphqlApi", {})
    .n("AppSyncClient", "AssociateMergedGraphqlApiCommand")
    .sc(schemas_0.AssociateMergedGraphqlApi$)
    .build() {
}

class AssociateSourceGraphqlApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "AssociateSourceGraphqlApi", {})
    .n("AppSyncClient", "AssociateSourceGraphqlApiCommand")
    .sc(schemas_0.AssociateSourceGraphqlApi$)
    .build() {
}

class CreateApiCacheCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "CreateApiCache", {})
    .n("AppSyncClient", "CreateApiCacheCommand")
    .sc(schemas_0.CreateApiCache$)
    .build() {
}

class CreateApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "CreateApi", {})
    .n("AppSyncClient", "CreateApiCommand")
    .sc(schemas_0.CreateApi$)
    .build() {
}

class CreateApiKeyCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "CreateApiKey", {})
    .n("AppSyncClient", "CreateApiKeyCommand")
    .sc(schemas_0.CreateApiKey$)
    .build() {
}

class CreateChannelNamespaceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "CreateChannelNamespace", {})
    .n("AppSyncClient", "CreateChannelNamespaceCommand")
    .sc(schemas_0.CreateChannelNamespace$)
    .build() {
}

class CreateDataSourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "CreateDataSource", {})
    .n("AppSyncClient", "CreateDataSourceCommand")
    .sc(schemas_0.CreateDataSource$)
    .build() {
}

class CreateDomainNameCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "CreateDomainName", {})
    .n("AppSyncClient", "CreateDomainNameCommand")
    .sc(schemas_0.CreateDomainName$)
    .build() {
}

class CreateFunctionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "CreateFunction", {})
    .n("AppSyncClient", "CreateFunctionCommand")
    .sc(schemas_0.CreateFunction$)
    .build() {
}

class CreateGraphqlApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "CreateGraphqlApi", {})
    .n("AppSyncClient", "CreateGraphqlApiCommand")
    .sc(schemas_0.CreateGraphqlApi$)
    .build() {
}

class CreateResolverCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "CreateResolver", {})
    .n("AppSyncClient", "CreateResolverCommand")
    .sc(schemas_0.CreateResolver$)
    .build() {
}

class CreateTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "CreateType", {})
    .n("AppSyncClient", "CreateTypeCommand")
    .sc(schemas_0.CreateType$)
    .build() {
}

class DeleteApiCacheCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DeleteApiCache", {})
    .n("AppSyncClient", "DeleteApiCacheCommand")
    .sc(schemas_0.DeleteApiCache$)
    .build() {
}

class DeleteApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DeleteApi", {})
    .n("AppSyncClient", "DeleteApiCommand")
    .sc(schemas_0.DeleteApi$)
    .build() {
}

class DeleteApiKeyCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DeleteApiKey", {})
    .n("AppSyncClient", "DeleteApiKeyCommand")
    .sc(schemas_0.DeleteApiKey$)
    .build() {
}

class DeleteChannelNamespaceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DeleteChannelNamespace", {})
    .n("AppSyncClient", "DeleteChannelNamespaceCommand")
    .sc(schemas_0.DeleteChannelNamespace$)
    .build() {
}

class DeleteDataSourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DeleteDataSource", {})
    .n("AppSyncClient", "DeleteDataSourceCommand")
    .sc(schemas_0.DeleteDataSource$)
    .build() {
}

class DeleteDomainNameCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DeleteDomainName", {})
    .n("AppSyncClient", "DeleteDomainNameCommand")
    .sc(schemas_0.DeleteDomainName$)
    .build() {
}

class DeleteFunctionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DeleteFunction", {})
    .n("AppSyncClient", "DeleteFunctionCommand")
    .sc(schemas_0.DeleteFunction$)
    .build() {
}

class DeleteGraphqlApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DeleteGraphqlApi", {})
    .n("AppSyncClient", "DeleteGraphqlApiCommand")
    .sc(schemas_0.DeleteGraphqlApi$)
    .build() {
}

class DeleteResolverCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DeleteResolver", {})
    .n("AppSyncClient", "DeleteResolverCommand")
    .sc(schemas_0.DeleteResolver$)
    .build() {
}

class DeleteTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DeleteType", {})
    .n("AppSyncClient", "DeleteTypeCommand")
    .sc(schemas_0.DeleteType$)
    .build() {
}

class DisassociateApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DisassociateApi", {})
    .n("AppSyncClient", "DisassociateApiCommand")
    .sc(schemas_0.DisassociateApi$)
    .build() {
}

class DisassociateMergedGraphqlApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DisassociateMergedGraphqlApi", {})
    .n("AppSyncClient", "DisassociateMergedGraphqlApiCommand")
    .sc(schemas_0.DisassociateMergedGraphqlApi$)
    .build() {
}

class DisassociateSourceGraphqlApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "DisassociateSourceGraphqlApi", {})
    .n("AppSyncClient", "DisassociateSourceGraphqlApiCommand")
    .sc(schemas_0.DisassociateSourceGraphqlApi$)
    .build() {
}

class EvaluateCodeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "EvaluateCode", {})
    .n("AppSyncClient", "EvaluateCodeCommand")
    .sc(schemas_0.EvaluateCode$)
    .build() {
}

class EvaluateMappingTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "EvaluateMappingTemplate", {})
    .n("AppSyncClient", "EvaluateMappingTemplateCommand")
    .sc(schemas_0.EvaluateMappingTemplate$)
    .build() {
}

class FlushApiCacheCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "FlushApiCache", {})
    .n("AppSyncClient", "FlushApiCacheCommand")
    .sc(schemas_0.FlushApiCache$)
    .build() {
}

class GetApiAssociationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetApiAssociation", {})
    .n("AppSyncClient", "GetApiAssociationCommand")
    .sc(schemas_0.GetApiAssociation$)
    .build() {
}

class GetApiCacheCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetApiCache", {})
    .n("AppSyncClient", "GetApiCacheCommand")
    .sc(schemas_0.GetApiCache$)
    .build() {
}

class GetApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetApi", {})
    .n("AppSyncClient", "GetApiCommand")
    .sc(schemas_0.GetApi$)
    .build() {
}

class GetChannelNamespaceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetChannelNamespace", {})
    .n("AppSyncClient", "GetChannelNamespaceCommand")
    .sc(schemas_0.GetChannelNamespace$)
    .build() {
}

class GetDataSourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetDataSource", {})
    .n("AppSyncClient", "GetDataSourceCommand")
    .sc(schemas_0.GetDataSource$)
    .build() {
}

class GetDataSourceIntrospectionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetDataSourceIntrospection", {})
    .n("AppSyncClient", "GetDataSourceIntrospectionCommand")
    .sc(schemas_0.GetDataSourceIntrospection$)
    .build() {
}

class GetDomainNameCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetDomainName", {})
    .n("AppSyncClient", "GetDomainNameCommand")
    .sc(schemas_0.GetDomainName$)
    .build() {
}

class GetFunctionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetFunction", {})
    .n("AppSyncClient", "GetFunctionCommand")
    .sc(schemas_0.GetFunction$)
    .build() {
}

class GetGraphqlApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetGraphqlApi", {})
    .n("AppSyncClient", "GetGraphqlApiCommand")
    .sc(schemas_0.GetGraphqlApi$)
    .build() {
}

class GetGraphqlApiEnvironmentVariablesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetGraphqlApiEnvironmentVariables", {})
    .n("AppSyncClient", "GetGraphqlApiEnvironmentVariablesCommand")
    .sc(schemas_0.GetGraphqlApiEnvironmentVariables$)
    .build() {
}

class GetIntrospectionSchemaCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetIntrospectionSchema", {})
    .n("AppSyncClient", "GetIntrospectionSchemaCommand")
    .sc(schemas_0.GetIntrospectionSchema$)
    .build() {
}

class GetResolverCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetResolver", {})
    .n("AppSyncClient", "GetResolverCommand")
    .sc(schemas_0.GetResolver$)
    .build() {
}

class GetSchemaCreationStatusCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetSchemaCreationStatus", {})
    .n("AppSyncClient", "GetSchemaCreationStatusCommand")
    .sc(schemas_0.GetSchemaCreationStatus$)
    .build() {
}

class GetSourceApiAssociationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetSourceApiAssociation", {})
    .n("AppSyncClient", "GetSourceApiAssociationCommand")
    .sc(schemas_0.GetSourceApiAssociation$)
    .build() {
}

class GetTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "GetType", {})
    .n("AppSyncClient", "GetTypeCommand")
    .sc(schemas_0.GetType$)
    .build() {
}

class ListApiKeysCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListApiKeys", {})
    .n("AppSyncClient", "ListApiKeysCommand")
    .sc(schemas_0.ListApiKeys$)
    .build() {
}

class ListApisCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListApis", {})
    .n("AppSyncClient", "ListApisCommand")
    .sc(schemas_0.ListApis$)
    .build() {
}

class ListChannelNamespacesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListChannelNamespaces", {})
    .n("AppSyncClient", "ListChannelNamespacesCommand")
    .sc(schemas_0.ListChannelNamespaces$)
    .build() {
}

class ListDataSourcesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListDataSources", {})
    .n("AppSyncClient", "ListDataSourcesCommand")
    .sc(schemas_0.ListDataSources$)
    .build() {
}

class ListDomainNamesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListDomainNames", {})
    .n("AppSyncClient", "ListDomainNamesCommand")
    .sc(schemas_0.ListDomainNames$)
    .build() {
}

class ListFunctionsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListFunctions", {})
    .n("AppSyncClient", "ListFunctionsCommand")
    .sc(schemas_0.ListFunctions$)
    .build() {
}

class ListGraphqlApisCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListGraphqlApis", {})
    .n("AppSyncClient", "ListGraphqlApisCommand")
    .sc(schemas_0.ListGraphqlApis$)
    .build() {
}

class ListResolversByFunctionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListResolversByFunction", {})
    .n("AppSyncClient", "ListResolversByFunctionCommand")
    .sc(schemas_0.ListResolversByFunction$)
    .build() {
}

class ListResolversCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListResolvers", {})
    .n("AppSyncClient", "ListResolversCommand")
    .sc(schemas_0.ListResolvers$)
    .build() {
}

class ListSourceApiAssociationsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListSourceApiAssociations", {})
    .n("AppSyncClient", "ListSourceApiAssociationsCommand")
    .sc(schemas_0.ListSourceApiAssociations$)
    .build() {
}

class ListTagsForResourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListTagsForResource", {})
    .n("AppSyncClient", "ListTagsForResourceCommand")
    .sc(schemas_0.ListTagsForResource$)
    .build() {
}

class ListTypesByAssociationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListTypesByAssociation", {})
    .n("AppSyncClient", "ListTypesByAssociationCommand")
    .sc(schemas_0.ListTypesByAssociation$)
    .build() {
}

class ListTypesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "ListTypes", {})
    .n("AppSyncClient", "ListTypesCommand")
    .sc(schemas_0.ListTypes$)
    .build() {
}

class PutGraphqlApiEnvironmentVariablesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "PutGraphqlApiEnvironmentVariables", {})
    .n("AppSyncClient", "PutGraphqlApiEnvironmentVariablesCommand")
    .sc(schemas_0.PutGraphqlApiEnvironmentVariables$)
    .build() {
}

class StartDataSourceIntrospectionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "StartDataSourceIntrospection", {})
    .n("AppSyncClient", "StartDataSourceIntrospectionCommand")
    .sc(schemas_0.StartDataSourceIntrospection$)
    .build() {
}

class StartSchemaCreationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "StartSchemaCreation", {})
    .n("AppSyncClient", "StartSchemaCreationCommand")
    .sc(schemas_0.StartSchemaCreation$)
    .build() {
}

class StartSchemaMergeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "StartSchemaMerge", {})
    .n("AppSyncClient", "StartSchemaMergeCommand")
    .sc(schemas_0.StartSchemaMerge$)
    .build() {
}

class TagResourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "TagResource", {})
    .n("AppSyncClient", "TagResourceCommand")
    .sc(schemas_0.TagResource$)
    .build() {
}

class UntagResourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UntagResource", {})
    .n("AppSyncClient", "UntagResourceCommand")
    .sc(schemas_0.UntagResource$)
    .build() {
}

class UpdateApiCacheCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateApiCache", {})
    .n("AppSyncClient", "UpdateApiCacheCommand")
    .sc(schemas_0.UpdateApiCache$)
    .build() {
}

class UpdateApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateApi", {})
    .n("AppSyncClient", "UpdateApiCommand")
    .sc(schemas_0.UpdateApi$)
    .build() {
}

class UpdateApiKeyCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateApiKey", {})
    .n("AppSyncClient", "UpdateApiKeyCommand")
    .sc(schemas_0.UpdateApiKey$)
    .build() {
}

class UpdateChannelNamespaceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateChannelNamespace", {})
    .n("AppSyncClient", "UpdateChannelNamespaceCommand")
    .sc(schemas_0.UpdateChannelNamespace$)
    .build() {
}

class UpdateDataSourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateDataSource", {})
    .n("AppSyncClient", "UpdateDataSourceCommand")
    .sc(schemas_0.UpdateDataSource$)
    .build() {
}

class UpdateDomainNameCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateDomainName", {})
    .n("AppSyncClient", "UpdateDomainNameCommand")
    .sc(schemas_0.UpdateDomainName$)
    .build() {
}

class UpdateFunctionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateFunction", {})
    .n("AppSyncClient", "UpdateFunctionCommand")
    .sc(schemas_0.UpdateFunction$)
    .build() {
}

class UpdateGraphqlApiCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateGraphqlApi", {})
    .n("AppSyncClient", "UpdateGraphqlApiCommand")
    .sc(schemas_0.UpdateGraphqlApi$)
    .build() {
}

class UpdateResolverCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateResolver", {})
    .n("AppSyncClient", "UpdateResolverCommand")
    .sc(schemas_0.UpdateResolver$)
    .build() {
}

class UpdateSourceApiAssociationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateSourceApiAssociation", {})
    .n("AppSyncClient", "UpdateSourceApiAssociationCommand")
    .sc(schemas_0.UpdateSourceApiAssociation$)
    .build() {
}

class UpdateTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSDeepdishControlPlaneService", "UpdateType", {})
    .n("AppSyncClient", "UpdateTypeCommand")
    .sc(schemas_0.UpdateType$)
    .build() {
}

const paginateListApiKeys = core.createPaginator(AppSyncClient, ListApiKeysCommand, "nextToken", "nextToken", "maxResults");

const paginateListApis = core.createPaginator(AppSyncClient, ListApisCommand, "nextToken", "nextToken", "maxResults");

const paginateListChannelNamespaces = core.createPaginator(AppSyncClient, ListChannelNamespacesCommand, "nextToken", "nextToken", "maxResults");

const paginateListDataSources = core.createPaginator(AppSyncClient, ListDataSourcesCommand, "nextToken", "nextToken", "maxResults");

const paginateListDomainNames = core.createPaginator(AppSyncClient, ListDomainNamesCommand, "nextToken", "nextToken", "maxResults");

const paginateListFunctions = core.createPaginator(AppSyncClient, ListFunctionsCommand, "nextToken", "nextToken", "maxResults");

const paginateListGraphqlApis = core.createPaginator(AppSyncClient, ListGraphqlApisCommand, "nextToken", "nextToken", "maxResults");

const paginateListResolversByFunction = core.createPaginator(AppSyncClient, ListResolversByFunctionCommand, "nextToken", "nextToken", "maxResults");

const paginateListResolvers = core.createPaginator(AppSyncClient, ListResolversCommand, "nextToken", "nextToken", "maxResults");

const paginateListSourceApiAssociations = core.createPaginator(AppSyncClient, ListSourceApiAssociationsCommand, "nextToken", "nextToken", "maxResults");

const paginateListTypesByAssociation = core.createPaginator(AppSyncClient, ListTypesByAssociationCommand, "nextToken", "nextToken", "maxResults");

const paginateListTypes = core.createPaginator(AppSyncClient, ListTypesCommand, "nextToken", "nextToken", "maxResults");

const commands = {
    AssociateApiCommand,
    AssociateMergedGraphqlApiCommand,
    AssociateSourceGraphqlApiCommand,
    CreateApiCommand,
    CreateApiCacheCommand,
    CreateApiKeyCommand,
    CreateChannelNamespaceCommand,
    CreateDataSourceCommand,
    CreateDomainNameCommand,
    CreateFunctionCommand,
    CreateGraphqlApiCommand,
    CreateResolverCommand,
    CreateTypeCommand,
    DeleteApiCommand,
    DeleteApiCacheCommand,
    DeleteApiKeyCommand,
    DeleteChannelNamespaceCommand,
    DeleteDataSourceCommand,
    DeleteDomainNameCommand,
    DeleteFunctionCommand,
    DeleteGraphqlApiCommand,
    DeleteResolverCommand,
    DeleteTypeCommand,
    DisassociateApiCommand,
    DisassociateMergedGraphqlApiCommand,
    DisassociateSourceGraphqlApiCommand,
    EvaluateCodeCommand,
    EvaluateMappingTemplateCommand,
    FlushApiCacheCommand,
    GetApiCommand,
    GetApiAssociationCommand,
    GetApiCacheCommand,
    GetChannelNamespaceCommand,
    GetDataSourceCommand,
    GetDataSourceIntrospectionCommand,
    GetDomainNameCommand,
    GetFunctionCommand,
    GetGraphqlApiCommand,
    GetGraphqlApiEnvironmentVariablesCommand,
    GetIntrospectionSchemaCommand,
    GetResolverCommand,
    GetSchemaCreationStatusCommand,
    GetSourceApiAssociationCommand,
    GetTypeCommand,
    ListApiKeysCommand,
    ListApisCommand,
    ListChannelNamespacesCommand,
    ListDataSourcesCommand,
    ListDomainNamesCommand,
    ListFunctionsCommand,
    ListGraphqlApisCommand,
    ListResolversCommand,
    ListResolversByFunctionCommand,
    ListSourceApiAssociationsCommand,
    ListTagsForResourceCommand,
    ListTypesCommand,
    ListTypesByAssociationCommand,
    PutGraphqlApiEnvironmentVariablesCommand,
    StartDataSourceIntrospectionCommand,
    StartSchemaCreationCommand,
    StartSchemaMergeCommand,
    TagResourceCommand,
    UntagResourceCommand,
    UpdateApiCommand,
    UpdateApiCacheCommand,
    UpdateApiKeyCommand,
    UpdateChannelNamespaceCommand,
    UpdateDataSourceCommand,
    UpdateDomainNameCommand,
    UpdateFunctionCommand,
    UpdateGraphqlApiCommand,
    UpdateResolverCommand,
    UpdateSourceApiAssociationCommand,
    UpdateTypeCommand,
};
const paginators = {
    paginateListApiKeys,
    paginateListApis,
    paginateListChannelNamespaces,
    paginateListDataSources,
    paginateListDomainNames,
    paginateListFunctions,
    paginateListGraphqlApis,
    paginateListResolvers,
    paginateListResolversByFunction,
    paginateListSourceApiAssociations,
    paginateListTypes,
    paginateListTypesByAssociation,
};
class AppSync extends AppSyncClient {
}
client.createAggregatedClient(commands, AppSync, { paginators });

const AuthenticationType = {
    AMAZON_COGNITO_USER_POOLS: "AMAZON_COGNITO_USER_POOLS",
    API_KEY: "API_KEY",
    AWS_IAM: "AWS_IAM",
    AWS_LAMBDA: "AWS_LAMBDA",
    OPENID_CONNECT: "OPENID_CONNECT",
};
const EventLogLevel = {
    ALL: "ALL",
    DEBUG: "DEBUG",
    ERROR: "ERROR",
    INFO: "INFO",
    NONE: "NONE",
};
const AssociationStatus = {
    Failed: "FAILED",
    Processing: "PROCESSING",
    Success: "SUCCESS",
};
const ApiCachingBehavior = {
    FULL_REQUEST_CACHING: "FULL_REQUEST_CACHING",
    OPERATION_LEVEL_CACHING: "OPERATION_LEVEL_CACHING",
    PER_RESOLVER_CACHING: "PER_RESOLVER_CACHING",
};
const CacheHealthMetricsConfig = {
    DISABLED: "DISABLED",
    ENABLED: "ENABLED",
};
const ApiCacheStatus = {
    AVAILABLE: "AVAILABLE",
    CREATING: "CREATING",
    DELETING: "DELETING",
    FAILED: "FAILED",
    MODIFYING: "MODIFYING",
};
const ApiCacheType = {
    LARGE: "LARGE",
    LARGE_12X: "LARGE_12X",
    LARGE_2X: "LARGE_2X",
    LARGE_4X: "LARGE_4X",
    LARGE_8X: "LARGE_8X",
    MEDIUM: "MEDIUM",
    R4_2XLARGE: "R4_2XLARGE",
    R4_4XLARGE: "R4_4XLARGE",
    R4_8XLARGE: "R4_8XLARGE",
    R4_LARGE: "R4_LARGE",
    R4_XLARGE: "R4_XLARGE",
    SMALL: "SMALL",
    T2_MEDIUM: "T2_MEDIUM",
    T2_SMALL: "T2_SMALL",
    XLARGE: "XLARGE",
};
const RuntimeName = {
    APPSYNC_JS: "APPSYNC_JS",
};
const BadRequestReason = {
    CODE_ERROR: "CODE_ERROR",
};
const MergeType = {
    AUTO_MERGE: "AUTO_MERGE",
    MANUAL_MERGE: "MANUAL_MERGE",
};
const SourceApiAssociationStatus = {
    AUTO_MERGE_SCHEDULE_FAILED: "AUTO_MERGE_SCHEDULE_FAILED",
    DELETION_FAILED: "DELETION_FAILED",
    DELETION_IN_PROGRESS: "DELETION_IN_PROGRESS",
    DELETION_SCHEDULED: "DELETION_SCHEDULED",
    MERGE_FAILED: "MERGE_FAILED",
    MERGE_IN_PROGRESS: "MERGE_IN_PROGRESS",
    MERGE_SCHEDULED: "MERGE_SCHEDULED",
    MERGE_SUCCESS: "MERGE_SUCCESS",
};
const AuthorizationType = {
    AWS_IAM: "AWS_IAM",
};
const HandlerBehavior = {
    CODE: "CODE",
    DIRECT: "DIRECT",
};
const InvokeType = {
    EVENT: "EVENT",
    REQUEST_RESPONSE: "REQUEST_RESPONSE",
};
const DataSourceLevelMetricsConfig = {
    DISABLED: "DISABLED",
    ENABLED: "ENABLED",
};
const RelationalDatabaseSourceType = {
    RDS_HTTP_ENDPOINT: "RDS_HTTP_ENDPOINT",
};
const DataSourceType = {
    AMAZON_BEDROCK_RUNTIME: "AMAZON_BEDROCK_RUNTIME",
    AMAZON_DYNAMODB: "AMAZON_DYNAMODB",
    AMAZON_ELASTICSEARCH: "AMAZON_ELASTICSEARCH",
    AMAZON_EVENTBRIDGE: "AMAZON_EVENTBRIDGE",
    AMAZON_OPENSEARCH_SERVICE: "AMAZON_OPENSEARCH_SERVICE",
    AWS_LAMBDA: "AWS_LAMBDA",
    HTTP: "HTTP",
    NONE: "NONE",
    RELATIONAL_DATABASE: "RELATIONAL_DATABASE",
};
const ConflictDetectionType = {
    NONE: "NONE",
    VERSION: "VERSION",
};
const ConflictHandlerType = {
    AUTOMERGE: "AUTOMERGE",
    LAMBDA: "LAMBDA",
    NONE: "NONE",
    OPTIMISTIC_CONCURRENCY: "OPTIMISTIC_CONCURRENCY",
};
const GraphQLApiType = {
    GRAPHQL: "GRAPHQL",
    MERGED: "MERGED",
};
const DataSourceLevelMetricsBehavior = {
    FULL_REQUEST_DATA_SOURCE_METRICS: "FULL_REQUEST_DATA_SOURCE_METRICS",
    PER_DATA_SOURCE_METRICS: "PER_DATA_SOURCE_METRICS",
};
const OperationLevelMetricsConfig = {
    DISABLED: "DISABLED",
    ENABLED: "ENABLED",
};
const ResolverLevelMetricsBehavior = {
    FULL_REQUEST_RESOLVER_METRICS: "FULL_REQUEST_RESOLVER_METRICS",
    PER_RESOLVER_METRICS: "PER_RESOLVER_METRICS",
};
const GraphQLApiIntrospectionConfig = {
    DISABLED: "DISABLED",
    ENABLED: "ENABLED",
};
const FieldLogLevel = {
    ALL: "ALL",
    DEBUG: "DEBUG",
    ERROR: "ERROR",
    INFO: "INFO",
    NONE: "NONE",
};
const DefaultAction = {
    ALLOW: "ALLOW",
    DENY: "DENY",
};
const GraphQLApiVisibility = {
    GLOBAL: "GLOBAL",
    PRIVATE: "PRIVATE",
};
const ResolverKind = {
    PIPELINE: "PIPELINE",
    UNIT: "UNIT",
};
const ResolverLevelMetricsConfig = {
    DISABLED: "DISABLED",
    ENABLED: "ENABLED",
};
const TypeDefinitionFormat = {
    JSON: "JSON",
    SDL: "SDL",
};
const DataSourceIntrospectionStatus = {
    FAILED: "FAILED",
    PROCESSING: "PROCESSING",
    SUCCESS: "SUCCESS",
};
const OutputType = {
    JSON: "JSON",
    SDL: "SDL",
};
const SchemaStatus = {
    Active: "ACTIVE",
    Deleting: "DELETING",
    Failed: "FAILED",
    NotApplicable: "NOT_APPLICABLE",
    Processing: "PROCESSING",
    Success: "SUCCESS",
};
const Ownership = {
    CURRENT_ACCOUNT: "CURRENT_ACCOUNT",
    OTHER_ACCOUNTS: "OTHER_ACCOUNTS",
};

exports.$Command = client.Command;
exports.__Client = client.Client;
exports.AppSyncServiceException = AppSyncServiceException.AppSyncServiceException;
exports.ApiCacheStatus = ApiCacheStatus;
exports.ApiCacheType = ApiCacheType;
exports.ApiCachingBehavior = ApiCachingBehavior;
exports.AppSync = AppSync;
exports.AppSyncClient = AppSyncClient;
exports.AssociateApiCommand = AssociateApiCommand;
exports.AssociateMergedGraphqlApiCommand = AssociateMergedGraphqlApiCommand;
exports.AssociateSourceGraphqlApiCommand = AssociateSourceGraphqlApiCommand;
exports.AssociationStatus = AssociationStatus;
exports.AuthenticationType = AuthenticationType;
exports.AuthorizationType = AuthorizationType;
exports.BadRequestReason = BadRequestReason;
exports.CacheHealthMetricsConfig = CacheHealthMetricsConfig;
exports.ConflictDetectionType = ConflictDetectionType;
exports.ConflictHandlerType = ConflictHandlerType;
exports.CreateApiCacheCommand = CreateApiCacheCommand;
exports.CreateApiCommand = CreateApiCommand;
exports.CreateApiKeyCommand = CreateApiKeyCommand;
exports.CreateChannelNamespaceCommand = CreateChannelNamespaceCommand;
exports.CreateDataSourceCommand = CreateDataSourceCommand;
exports.CreateDomainNameCommand = CreateDomainNameCommand;
exports.CreateFunctionCommand = CreateFunctionCommand;
exports.CreateGraphqlApiCommand = CreateGraphqlApiCommand;
exports.CreateResolverCommand = CreateResolverCommand;
exports.CreateTypeCommand = CreateTypeCommand;
exports.DataSourceIntrospectionStatus = DataSourceIntrospectionStatus;
exports.DataSourceLevelMetricsBehavior = DataSourceLevelMetricsBehavior;
exports.DataSourceLevelMetricsConfig = DataSourceLevelMetricsConfig;
exports.DataSourceType = DataSourceType;
exports.DefaultAction = DefaultAction;
exports.DeleteApiCacheCommand = DeleteApiCacheCommand;
exports.DeleteApiCommand = DeleteApiCommand;
exports.DeleteApiKeyCommand = DeleteApiKeyCommand;
exports.DeleteChannelNamespaceCommand = DeleteChannelNamespaceCommand;
exports.DeleteDataSourceCommand = DeleteDataSourceCommand;
exports.DeleteDomainNameCommand = DeleteDomainNameCommand;
exports.DeleteFunctionCommand = DeleteFunctionCommand;
exports.DeleteGraphqlApiCommand = DeleteGraphqlApiCommand;
exports.DeleteResolverCommand = DeleteResolverCommand;
exports.DeleteTypeCommand = DeleteTypeCommand;
exports.DisassociateApiCommand = DisassociateApiCommand;
exports.DisassociateMergedGraphqlApiCommand = DisassociateMergedGraphqlApiCommand;
exports.DisassociateSourceGraphqlApiCommand = DisassociateSourceGraphqlApiCommand;
exports.EvaluateCodeCommand = EvaluateCodeCommand;
exports.EvaluateMappingTemplateCommand = EvaluateMappingTemplateCommand;
exports.EventLogLevel = EventLogLevel;
exports.FieldLogLevel = FieldLogLevel;
exports.FlushApiCacheCommand = FlushApiCacheCommand;
exports.GetApiAssociationCommand = GetApiAssociationCommand;
exports.GetApiCacheCommand = GetApiCacheCommand;
exports.GetApiCommand = GetApiCommand;
exports.GetChannelNamespaceCommand = GetChannelNamespaceCommand;
exports.GetDataSourceCommand = GetDataSourceCommand;
exports.GetDataSourceIntrospectionCommand = GetDataSourceIntrospectionCommand;
exports.GetDomainNameCommand = GetDomainNameCommand;
exports.GetFunctionCommand = GetFunctionCommand;
exports.GetGraphqlApiCommand = GetGraphqlApiCommand;
exports.GetGraphqlApiEnvironmentVariablesCommand = GetGraphqlApiEnvironmentVariablesCommand;
exports.GetIntrospectionSchemaCommand = GetIntrospectionSchemaCommand;
exports.GetResolverCommand = GetResolverCommand;
exports.GetSchemaCreationStatusCommand = GetSchemaCreationStatusCommand;
exports.GetSourceApiAssociationCommand = GetSourceApiAssociationCommand;
exports.GetTypeCommand = GetTypeCommand;
exports.GraphQLApiIntrospectionConfig = GraphQLApiIntrospectionConfig;
exports.GraphQLApiType = GraphQLApiType;
exports.GraphQLApiVisibility = GraphQLApiVisibility;
exports.HandlerBehavior = HandlerBehavior;
exports.InvokeType = InvokeType;
exports.ListApiKeysCommand = ListApiKeysCommand;
exports.ListApisCommand = ListApisCommand;
exports.ListChannelNamespacesCommand = ListChannelNamespacesCommand;
exports.ListDataSourcesCommand = ListDataSourcesCommand;
exports.ListDomainNamesCommand = ListDomainNamesCommand;
exports.ListFunctionsCommand = ListFunctionsCommand;
exports.ListGraphqlApisCommand = ListGraphqlApisCommand;
exports.ListResolversByFunctionCommand = ListResolversByFunctionCommand;
exports.ListResolversCommand = ListResolversCommand;
exports.ListSourceApiAssociationsCommand = ListSourceApiAssociationsCommand;
exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
exports.ListTypesByAssociationCommand = ListTypesByAssociationCommand;
exports.ListTypesCommand = ListTypesCommand;
exports.MergeType = MergeType;
exports.OperationLevelMetricsConfig = OperationLevelMetricsConfig;
exports.OutputType = OutputType;
exports.Ownership = Ownership;
exports.PutGraphqlApiEnvironmentVariablesCommand = PutGraphqlApiEnvironmentVariablesCommand;
exports.RelationalDatabaseSourceType = RelationalDatabaseSourceType;
exports.ResolverKind = ResolverKind;
exports.ResolverLevelMetricsBehavior = ResolverLevelMetricsBehavior;
exports.ResolverLevelMetricsConfig = ResolverLevelMetricsConfig;
exports.RuntimeName = RuntimeName;
exports.SchemaStatus = SchemaStatus;
exports.SourceApiAssociationStatus = SourceApiAssociationStatus;
exports.StartDataSourceIntrospectionCommand = StartDataSourceIntrospectionCommand;
exports.StartSchemaCreationCommand = StartSchemaCreationCommand;
exports.StartSchemaMergeCommand = StartSchemaMergeCommand;
exports.TagResourceCommand = TagResourceCommand;
exports.TypeDefinitionFormat = TypeDefinitionFormat;
exports.UntagResourceCommand = UntagResourceCommand;
exports.UpdateApiCacheCommand = UpdateApiCacheCommand;
exports.UpdateApiCommand = UpdateApiCommand;
exports.UpdateApiKeyCommand = UpdateApiKeyCommand;
exports.UpdateChannelNamespaceCommand = UpdateChannelNamespaceCommand;
exports.UpdateDataSourceCommand = UpdateDataSourceCommand;
exports.UpdateDomainNameCommand = UpdateDomainNameCommand;
exports.UpdateFunctionCommand = UpdateFunctionCommand;
exports.UpdateGraphqlApiCommand = UpdateGraphqlApiCommand;
exports.UpdateResolverCommand = UpdateResolverCommand;
exports.UpdateSourceApiAssociationCommand = UpdateSourceApiAssociationCommand;
exports.UpdateTypeCommand = UpdateTypeCommand;
exports.paginateListApiKeys = paginateListApiKeys;
exports.paginateListApis = paginateListApis;
exports.paginateListChannelNamespaces = paginateListChannelNamespaces;
exports.paginateListDataSources = paginateListDataSources;
exports.paginateListDomainNames = paginateListDomainNames;
exports.paginateListFunctions = paginateListFunctions;
exports.paginateListGraphqlApis = paginateListGraphqlApis;
exports.paginateListResolvers = paginateListResolvers;
exports.paginateListResolversByFunction = paginateListResolversByFunction;
exports.paginateListSourceApiAssociations = paginateListSourceApiAssociations;
exports.paginateListTypes = paginateListTypes;
exports.paginateListTypesByAssociation = paginateListTypesByAssociation;
Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
    Object.defineProperty(exports, '__proto__', {
        enumerable: true,
        value: schemas_0['__proto__']
    });

Object.keys(schemas_0).forEach(function (k) {
    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
});
Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
    Object.defineProperty(exports, '__proto__', {
        enumerable: true,
        value: errors['__proto__']
    });

Object.keys(errors).forEach(function (k) {
    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
});