personal_site/frontend/node_modules/@aws-sdk/client-kms/dist-cjs/index.js

'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 KMSServiceException = require('./models/KMSServiceException');

const resolveClientEndpointParameters = (options) => {
    return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "kms",
    });
};
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 KMSClient 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.defaultKMSHttpAuthSchemeParametersProvider,
            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class TagResourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("TrentService", "TagResource", {})
    .n("KMSClient", "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("TrentService", "UntagResource", {})
    .n("KMSClient", "UntagResourceCommand")
    .sc(schemas_0.UntagResource$)
    .build() {
}

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

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

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

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

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

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

const paginateDescribeCustomKeyStores = core.createPaginator(KMSClient, DescribeCustomKeyStoresCommand, "Marker", "NextMarker", "Limit");

const paginateListAliases = core.createPaginator(KMSClient, ListAliasesCommand, "Marker", "NextMarker", "Limit");

const paginateListGrants = core.createPaginator(KMSClient, ListGrantsCommand, "Marker", "NextMarker", "Limit");

const paginateListKeyPolicies = core.createPaginator(KMSClient, ListKeyPoliciesCommand, "Marker", "NextMarker", "Limit");

const paginateListKeyRotations = core.createPaginator(KMSClient, ListKeyRotationsCommand, "Marker", "NextMarker", "Limit");

const paginateListKeys = core.createPaginator(KMSClient, ListKeysCommand, "Marker", "NextMarker", "Limit");

const paginateListResourceTags = core.createPaginator(KMSClient, ListResourceTagsCommand, "Marker", "NextMarker", "Limit");

const paginateListRetirableGrants = core.createPaginator(KMSClient, ListRetirableGrantsCommand, "Marker", "NextMarker", "Limit");

const commands = {
    CancelKeyDeletionCommand,
    ConnectCustomKeyStoreCommand,
    CreateAliasCommand,
    CreateCustomKeyStoreCommand,
    CreateGrantCommand,
    CreateKeyCommand,
    DecryptCommand,
    DeleteAliasCommand,
    DeleteCustomKeyStoreCommand,
    DeleteImportedKeyMaterialCommand,
    DeriveSharedSecretCommand,
    DescribeCustomKeyStoresCommand,
    DescribeKeyCommand,
    DisableKeyCommand,
    DisableKeyRotationCommand,
    DisconnectCustomKeyStoreCommand,
    EnableKeyCommand,
    EnableKeyRotationCommand,
    EncryptCommand,
    GenerateDataKeyCommand,
    GenerateDataKeyPairCommand,
    GenerateDataKeyPairWithoutPlaintextCommand,
    GenerateDataKeyWithoutPlaintextCommand,
    GenerateMacCommand,
    GenerateRandomCommand,
    GetKeyLastUsageCommand,
    GetKeyPolicyCommand,
    GetKeyRotationStatusCommand,
    GetParametersForImportCommand,
    GetPublicKeyCommand,
    ImportKeyMaterialCommand,
    ListAliasesCommand,
    ListGrantsCommand,
    ListKeyPoliciesCommand,
    ListKeyRotationsCommand,
    ListKeysCommand,
    ListResourceTagsCommand,
    ListRetirableGrantsCommand,
    PutKeyPolicyCommand,
    ReEncryptCommand,
    ReplicateKeyCommand,
    RetireGrantCommand,
    RevokeGrantCommand,
    RotateKeyOnDemandCommand,
    ScheduleKeyDeletionCommand,
    SignCommand,
    TagResourceCommand,
    UntagResourceCommand,
    UpdateAliasCommand,
    UpdateCustomKeyStoreCommand,
    UpdateKeyDescriptionCommand,
    UpdatePrimaryRegionCommand,
    VerifyCommand,
    VerifyMacCommand,
};
const paginators = {
    paginateDescribeCustomKeyStores,
    paginateListAliases,
    paginateListGrants,
    paginateListKeyPolicies,
    paginateListKeyRotations,
    paginateListKeys,
    paginateListResourceTags,
    paginateListRetirableGrants,
};
class KMS extends KMSClient {
}
client.createAggregatedClient(commands, KMS, { paginators });

const AlgorithmSpec = {
    RSAES_OAEP_SHA_1: "RSAES_OAEP_SHA_1",
    RSAES_OAEP_SHA_256: "RSAES_OAEP_SHA_256",
    RSAES_PKCS1_V1_5: "RSAES_PKCS1_V1_5",
    RSA_AES_KEY_WRAP_SHA_1: "RSA_AES_KEY_WRAP_SHA_1",
    RSA_AES_KEY_WRAP_SHA_256: "RSA_AES_KEY_WRAP_SHA_256",
    SM2PKE: "SM2PKE",
};
const ConnectionErrorCodeType = {
    CLUSTER_NOT_FOUND: "CLUSTER_NOT_FOUND",
    INSUFFICIENT_CLOUDHSM_HSMS: "INSUFFICIENT_CLOUDHSM_HSMS",
    INSUFFICIENT_FREE_ADDRESSES_IN_SUBNET: "INSUFFICIENT_FREE_ADDRESSES_IN_SUBNET",
    INTERNAL_ERROR: "INTERNAL_ERROR",
    INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
    NETWORK_ERRORS: "NETWORK_ERRORS",
    SUBNET_NOT_FOUND: "SUBNET_NOT_FOUND",
    USER_LOCKED_OUT: "USER_LOCKED_OUT",
    USER_LOGGED_IN: "USER_LOGGED_IN",
    USER_NOT_FOUND: "USER_NOT_FOUND",
    XKS_PROXY_ACCESS_DENIED: "XKS_PROXY_ACCESS_DENIED",
    XKS_PROXY_INVALID_CONFIGURATION: "XKS_PROXY_INVALID_CONFIGURATION",
    XKS_PROXY_INVALID_RESPONSE: "XKS_PROXY_INVALID_RESPONSE",
    XKS_PROXY_INVALID_TLS_CONFIGURATION: "XKS_PROXY_INVALID_TLS_CONFIGURATION",
    XKS_PROXY_NOT_REACHABLE: "XKS_PROXY_NOT_REACHABLE",
    XKS_PROXY_TIMED_OUT: "XKS_PROXY_TIMED_OUT",
    XKS_VPC_ENDPOINT_SERVICE_INVALID_CONFIGURATION: "XKS_VPC_ENDPOINT_SERVICE_INVALID_CONFIGURATION",
    XKS_VPC_ENDPOINT_SERVICE_NOT_FOUND: "XKS_VPC_ENDPOINT_SERVICE_NOT_FOUND",
};
const ConnectionStateType = {
    CONNECTED: "CONNECTED",
    CONNECTING: "CONNECTING",
    DISCONNECTED: "DISCONNECTED",
    DISCONNECTING: "DISCONNECTING",
    FAILED: "FAILED",
};
const CustomKeyStoreType = {
    AWS_CLOUDHSM: "AWS_CLOUDHSM",
    EXTERNAL_KEY_STORE: "EXTERNAL_KEY_STORE",
};
const XksProxyConnectivityType = {
    PUBLIC_ENDPOINT: "PUBLIC_ENDPOINT",
    VPC_ENDPOINT_SERVICE: "VPC_ENDPOINT_SERVICE",
};
const GrantOperation = {
    CreateGrant: "CreateGrant",
    Decrypt: "Decrypt",
    DeriveSharedSecret: "DeriveSharedSecret",
    DescribeKey: "DescribeKey",
    Encrypt: "Encrypt",
    GenerateDataKey: "GenerateDataKey",
    GenerateDataKeyPair: "GenerateDataKeyPair",
    GenerateDataKeyPairWithoutPlaintext: "GenerateDataKeyPairWithoutPlaintext",
    GenerateDataKeyWithoutPlaintext: "GenerateDataKeyWithoutPlaintext",
    GenerateMac: "GenerateMac",
    GetPublicKey: "GetPublicKey",
    ReEncryptFrom: "ReEncryptFrom",
    ReEncryptTo: "ReEncryptTo",
    RetireGrant: "RetireGrant",
    Sign: "Sign",
    Verify: "Verify",
    VerifyMac: "VerifyMac",
};
const CustomerMasterKeySpec = {
    ECC_NIST_P256: "ECC_NIST_P256",
    ECC_NIST_P384: "ECC_NIST_P384",
    ECC_NIST_P521: "ECC_NIST_P521",
    ECC_SECG_P256K1: "ECC_SECG_P256K1",
    HMAC_224: "HMAC_224",
    HMAC_256: "HMAC_256",
    HMAC_384: "HMAC_384",
    HMAC_512: "HMAC_512",
    RSA_2048: "RSA_2048",
    RSA_3072: "RSA_3072",
    RSA_4096: "RSA_4096",
    SM2: "SM2",
    SYMMETRIC_DEFAULT: "SYMMETRIC_DEFAULT",
};
const KeySpec = {
    ECC_NIST_EDWARDS25519: "ECC_NIST_EDWARDS25519",
    ECC_NIST_P256: "ECC_NIST_P256",
    ECC_NIST_P384: "ECC_NIST_P384",
    ECC_NIST_P521: "ECC_NIST_P521",
    ECC_SECG_P256K1: "ECC_SECG_P256K1",
    HMAC_224: "HMAC_224",
    HMAC_256: "HMAC_256",
    HMAC_384: "HMAC_384",
    HMAC_512: "HMAC_512",
    ML_DSA_44: "ML_DSA_44",
    ML_DSA_65: "ML_DSA_65",
    ML_DSA_87: "ML_DSA_87",
    RSA_2048: "RSA_2048",
    RSA_3072: "RSA_3072",
    RSA_4096: "RSA_4096",
    SM2: "SM2",
    SYMMETRIC_DEFAULT: "SYMMETRIC_DEFAULT",
};
const KeyUsageType = {
    ENCRYPT_DECRYPT: "ENCRYPT_DECRYPT",
    GENERATE_VERIFY_MAC: "GENERATE_VERIFY_MAC",
    KEY_AGREEMENT: "KEY_AGREEMENT",
    SIGN_VERIFY: "SIGN_VERIFY",
};
const OriginType = {
    AWS_CLOUDHSM: "AWS_CLOUDHSM",
    AWS_KMS: "AWS_KMS",
    EXTERNAL: "EXTERNAL",
    EXTERNAL_KEY_STORE: "EXTERNAL_KEY_STORE",
};
const EncryptionAlgorithmSpec = {
    RSAES_OAEP_SHA_1: "RSAES_OAEP_SHA_1",
    RSAES_OAEP_SHA_256: "RSAES_OAEP_SHA_256",
    SM2PKE: "SM2PKE",
    SYMMETRIC_DEFAULT: "SYMMETRIC_DEFAULT",
};
const ExpirationModelType = {
    KEY_MATERIAL_DOES_NOT_EXPIRE: "KEY_MATERIAL_DOES_NOT_EXPIRE",
    KEY_MATERIAL_EXPIRES: "KEY_MATERIAL_EXPIRES",
};
const KeyAgreementAlgorithmSpec = {
    ECDH: "ECDH",
};
const KeyManagerType = {
    AWS: "AWS",
    CUSTOMER: "CUSTOMER",
};
const KeyState = {
    Creating: "Creating",
    Disabled: "Disabled",
    Enabled: "Enabled",
    PendingDeletion: "PendingDeletion",
    PendingImport: "PendingImport",
    PendingReplicaDeletion: "PendingReplicaDeletion",
    Unavailable: "Unavailable",
    Updating: "Updating",
};
const MacAlgorithmSpec = {
    HMAC_SHA_224: "HMAC_SHA_224",
    HMAC_SHA_256: "HMAC_SHA_256",
    HMAC_SHA_384: "HMAC_SHA_384",
    HMAC_SHA_512: "HMAC_SHA_512",
};
const MultiRegionKeyType = {
    PRIMARY: "PRIMARY",
    REPLICA: "REPLICA",
};
const SigningAlgorithmSpec = {
    ECDSA_SHA_256: "ECDSA_SHA_256",
    ECDSA_SHA_384: "ECDSA_SHA_384",
    ECDSA_SHA_512: "ECDSA_SHA_512",
    ED25519_PH_SHA_512: "ED25519_PH_SHA_512",
    ED25519_SHA_512: "ED25519_SHA_512",
    ML_DSA_SHAKE_256: "ML_DSA_SHAKE_256",
    RSASSA_PKCS1_V1_5_SHA_256: "RSASSA_PKCS1_V1_5_SHA_256",
    RSASSA_PKCS1_V1_5_SHA_384: "RSASSA_PKCS1_V1_5_SHA_384",
    RSASSA_PKCS1_V1_5_SHA_512: "RSASSA_PKCS1_V1_5_SHA_512",
    RSASSA_PSS_SHA_256: "RSASSA_PSS_SHA_256",
    RSASSA_PSS_SHA_384: "RSASSA_PSS_SHA_384",
    RSASSA_PSS_SHA_512: "RSASSA_PSS_SHA_512",
    SM2DSA: "SM2DSA",
};
const DataKeyPairSpec = {
    ECC_NIST_EDWARDS25519: "ECC_NIST_EDWARDS25519",
    ECC_NIST_P256: "ECC_NIST_P256",
    ECC_NIST_P384: "ECC_NIST_P384",
    ECC_NIST_P521: "ECC_NIST_P521",
    ECC_SECG_P256K1: "ECC_SECG_P256K1",
    RSA_2048: "RSA_2048",
    RSA_3072: "RSA_3072",
    RSA_4096: "RSA_4096",
    SM2: "SM2",
};
const DataKeySpec = {
    AES_128: "AES_128",
    AES_256: "AES_256",
};
const DryRunModifierType = {
    IGNORE_CIPHERTEXT: "IGNORE_CIPHERTEXT",
};
const KeyEncryptionMechanism = {
    RSAES_OAEP_SHA_256: "RSAES_OAEP_SHA_256",
};
const KeyLastUsageTrackingOperation = {
    Decrypt: "Decrypt",
    DeriveSharedSecret: "DeriveSharedSecret",
    Encrypt: "Encrypt",
    GenerateDataKey: "GenerateDataKey",
    GenerateDataKeyPair: "GenerateDataKeyPair",
    GenerateDataKeyPairWithoutPlaintext: "GenerateDataKeyPairWithoutPlaintext",
    GenerateDataKeyWithoutPlaintext: "GenerateDataKeyWithoutPlaintext",
    GenerateMac: "GenerateMac",
    ReEncrypt: "ReEncrypt",
    Sign: "Sign",
    Verify: "Verify",
    VerifyMac: "VerifyMac",
};
const WrappingKeySpec = {
    RSA_2048: "RSA_2048",
    RSA_3072: "RSA_3072",
    RSA_4096: "RSA_4096",
    SM2: "SM2",
};
const ImportType = {
    EXISTING_KEY_MATERIAL: "EXISTING_KEY_MATERIAL",
    NEW_KEY_MATERIAL: "NEW_KEY_MATERIAL",
};
const ImportState = {
    IMPORTED: "IMPORTED",
    PENDING_IMPORT: "PENDING_IMPORT",
};
const IncludeKeyMaterial = {
    ALL_KEY_MATERIAL: "ALL_KEY_MATERIAL",
    ROTATIONS_ONLY: "ROTATIONS_ONLY",
};
const KeyMaterialState = {
    CURRENT: "CURRENT",
    NON_CURRENT: "NON_CURRENT",
    PENDING_MULTI_REGION_IMPORT_AND_ROTATION: "PENDING_MULTI_REGION_IMPORT_AND_ROTATION",
    PENDING_ROTATION: "PENDING_ROTATION",
};
const RotationType = {
    AUTOMATIC: "AUTOMATIC",
    ON_DEMAND: "ON_DEMAND",
};
const MessageType = {
    DIGEST: "DIGEST",
    EXTERNAL_MU: "EXTERNAL_MU",
    RAW: "RAW",
};

exports.$Command = client.Command;
exports.__Client = client.Client;
exports.KMSServiceException = KMSServiceException.KMSServiceException;
exports.AlgorithmSpec = AlgorithmSpec;
exports.CancelKeyDeletionCommand = CancelKeyDeletionCommand;
exports.ConnectCustomKeyStoreCommand = ConnectCustomKeyStoreCommand;
exports.ConnectionErrorCodeType = ConnectionErrorCodeType;
exports.ConnectionStateType = ConnectionStateType;
exports.CreateAliasCommand = CreateAliasCommand;
exports.CreateCustomKeyStoreCommand = CreateCustomKeyStoreCommand;
exports.CreateGrantCommand = CreateGrantCommand;
exports.CreateKeyCommand = CreateKeyCommand;
exports.CustomKeyStoreType = CustomKeyStoreType;
exports.CustomerMasterKeySpec = CustomerMasterKeySpec;
exports.DataKeyPairSpec = DataKeyPairSpec;
exports.DataKeySpec = DataKeySpec;
exports.DecryptCommand = DecryptCommand;
exports.DeleteAliasCommand = DeleteAliasCommand;
exports.DeleteCustomKeyStoreCommand = DeleteCustomKeyStoreCommand;
exports.DeleteImportedKeyMaterialCommand = DeleteImportedKeyMaterialCommand;
exports.DeriveSharedSecretCommand = DeriveSharedSecretCommand;
exports.DescribeCustomKeyStoresCommand = DescribeCustomKeyStoresCommand;
exports.DescribeKeyCommand = DescribeKeyCommand;
exports.DisableKeyCommand = DisableKeyCommand;
exports.DisableKeyRotationCommand = DisableKeyRotationCommand;
exports.DisconnectCustomKeyStoreCommand = DisconnectCustomKeyStoreCommand;
exports.DryRunModifierType = DryRunModifierType;
exports.EnableKeyCommand = EnableKeyCommand;
exports.EnableKeyRotationCommand = EnableKeyRotationCommand;
exports.EncryptCommand = EncryptCommand;
exports.EncryptionAlgorithmSpec = EncryptionAlgorithmSpec;
exports.ExpirationModelType = ExpirationModelType;
exports.GenerateDataKeyCommand = GenerateDataKeyCommand;
exports.GenerateDataKeyPairCommand = GenerateDataKeyPairCommand;
exports.GenerateDataKeyPairWithoutPlaintextCommand = GenerateDataKeyPairWithoutPlaintextCommand;
exports.GenerateDataKeyWithoutPlaintextCommand = GenerateDataKeyWithoutPlaintextCommand;
exports.GenerateMacCommand = GenerateMacCommand;
exports.GenerateRandomCommand = GenerateRandomCommand;
exports.GetKeyLastUsageCommand = GetKeyLastUsageCommand;
exports.GetKeyPolicyCommand = GetKeyPolicyCommand;
exports.GetKeyRotationStatusCommand = GetKeyRotationStatusCommand;
exports.GetParametersForImportCommand = GetParametersForImportCommand;
exports.GetPublicKeyCommand = GetPublicKeyCommand;
exports.GrantOperation = GrantOperation;
exports.ImportKeyMaterialCommand = ImportKeyMaterialCommand;
exports.ImportState = ImportState;
exports.ImportType = ImportType;
exports.IncludeKeyMaterial = IncludeKeyMaterial;
exports.KMS = KMS;
exports.KMSClient = KMSClient;
exports.KeyAgreementAlgorithmSpec = KeyAgreementAlgorithmSpec;
exports.KeyEncryptionMechanism = KeyEncryptionMechanism;
exports.KeyLastUsageTrackingOperation = KeyLastUsageTrackingOperation;
exports.KeyManagerType = KeyManagerType;
exports.KeyMaterialState = KeyMaterialState;
exports.KeySpec = KeySpec;
exports.KeyState = KeyState;
exports.KeyUsageType = KeyUsageType;
exports.ListAliasesCommand = ListAliasesCommand;
exports.ListGrantsCommand = ListGrantsCommand;
exports.ListKeyPoliciesCommand = ListKeyPoliciesCommand;
exports.ListKeyRotationsCommand = ListKeyRotationsCommand;
exports.ListKeysCommand = ListKeysCommand;
exports.ListResourceTagsCommand = ListResourceTagsCommand;
exports.ListRetirableGrantsCommand = ListRetirableGrantsCommand;
exports.MacAlgorithmSpec = MacAlgorithmSpec;
exports.MessageType = MessageType;
exports.MultiRegionKeyType = MultiRegionKeyType;
exports.OriginType = OriginType;
exports.PutKeyPolicyCommand = PutKeyPolicyCommand;
exports.ReEncryptCommand = ReEncryptCommand;
exports.ReplicateKeyCommand = ReplicateKeyCommand;
exports.RetireGrantCommand = RetireGrantCommand;
exports.RevokeGrantCommand = RevokeGrantCommand;
exports.RotateKeyOnDemandCommand = RotateKeyOnDemandCommand;
exports.RotationType = RotationType;
exports.ScheduleKeyDeletionCommand = ScheduleKeyDeletionCommand;
exports.SignCommand = SignCommand;
exports.SigningAlgorithmSpec = SigningAlgorithmSpec;
exports.TagResourceCommand = TagResourceCommand;
exports.UntagResourceCommand = UntagResourceCommand;
exports.UpdateAliasCommand = UpdateAliasCommand;
exports.UpdateCustomKeyStoreCommand = UpdateCustomKeyStoreCommand;
exports.UpdateKeyDescriptionCommand = UpdateKeyDescriptionCommand;
exports.UpdatePrimaryRegionCommand = UpdatePrimaryRegionCommand;
exports.VerifyCommand = VerifyCommand;
exports.VerifyMacCommand = VerifyMacCommand;
exports.WrappingKeySpec = WrappingKeySpec;
exports.XksProxyConnectivityType = XksProxyConnectivityType;
exports.paginateDescribeCustomKeyStores = paginateDescribeCustomKeyStores;
exports.paginateListAliases = paginateListAliases;
exports.paginateListGrants = paginateListGrants;
exports.paginateListKeyPolicies = paginateListKeyPolicies;
exports.paginateListKeyRotations = paginateListKeyRotations;
exports.paginateListKeys = paginateListKeys;
exports.paginateListResourceTags = paginateListResourceTags;
exports.paginateListRetirableGrants = paginateListRetirableGrants;
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];
});