lambda-live-debugger/node_modules/@aws-sdk/client-iot/dist-cjs/index.js

Debug Lambda functions locally like it is running in the cloud

'use strict';

var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
var middlewareLogger = require('@aws-sdk/middleware-logger');
var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
var configResolver = require('@smithy/config-resolver');
var core = require('@smithy/core');
var schema = require('@smithy/core/schema');
var middlewareContentLength = require('@smithy/middleware-content-length');
var middlewareEndpoint = require('@smithy/middleware-endpoint');
var middlewareRetry = require('@smithy/middleware-retry');
var smithyClient = require('@smithy/smithy-client');
var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
var runtimeConfig = require('./runtimeConfig');
var regionConfigResolver = require('@aws-sdk/region-config-resolver');
var protocolHttp = require('@smithy/protocol-http');
var schemas_0 = require('./schemas/schemas_0');
var errors = require('./models/errors');
var IoTServiceException = require('./models/IoTServiceException');

const resolveClientEndpointParameters = (options) => {
    return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "iot",
    });
};
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(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
    extensions.forEach((extension) => extension.configure(extensionConfiguration));
    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};

class IoTClient extends smithyClient.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 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
        const _config_4 = configResolver.resolveRegionConfig(_config_3);
        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
        const _config_6 = middlewareEndpoint.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(middlewareUserAgent.getUserAgentPlugin(this.config));
        this.middlewareStack.use(middlewareRetry.getOmitRetryHeadersPlugin(this.config));
        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultIoTHttpAuthSchemeParametersProvider,
            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

class AcceptCertificateTransferCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "AcceptCertificateTransfer", {})
    .n("IoTClient", "AcceptCertificateTransferCommand")
    .sc(schemas_0.AcceptCertificateTransfer$)
    .build() {
}

class AddThingToBillingGroupCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "AddThingToBillingGroup", {})
    .n("IoTClient", "AddThingToBillingGroupCommand")
    .sc(schemas_0.AddThingToBillingGroup$)
    .build() {
}

class AddThingToThingGroupCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "AddThingToThingGroup", {})
    .n("IoTClient", "AddThingToThingGroupCommand")
    .sc(schemas_0.AddThingToThingGroup$)
    .build() {
}

class AssociateSbomWithPackageVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "AssociateSbomWithPackageVersion", {})
    .n("IoTClient", "AssociateSbomWithPackageVersionCommand")
    .sc(schemas_0.AssociateSbomWithPackageVersion$)
    .build() {
}

class AssociateTargetsWithJobCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "AssociateTargetsWithJob", {})
    .n("IoTClient", "AssociateTargetsWithJobCommand")
    .sc(schemas_0.AssociateTargetsWithJob$)
    .build() {
}

class AttachPolicyCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "AttachPolicy", {})
    .n("IoTClient", "AttachPolicyCommand")
    .sc(schemas_0.AttachPolicy$)
    .build() {
}

class AttachPrincipalPolicyCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "AttachPrincipalPolicy", {})
    .n("IoTClient", "AttachPrincipalPolicyCommand")
    .sc(schemas_0.AttachPrincipalPolicy$)
    .build() {
}

class AttachSecurityProfileCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "AttachSecurityProfile", {})
    .n("IoTClient", "AttachSecurityProfileCommand")
    .sc(schemas_0.AttachSecurityProfile$)
    .build() {
}

class AttachThingPrincipalCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "AttachThingPrincipal", {})
    .n("IoTClient", "AttachThingPrincipalCommand")
    .sc(schemas_0.AttachThingPrincipal$)
    .build() {
}

class CancelAuditMitigationActionsTaskCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CancelAuditMitigationActionsTask", {})
    .n("IoTClient", "CancelAuditMitigationActionsTaskCommand")
    .sc(schemas_0.CancelAuditMitigationActionsTask$)
    .build() {
}

class CancelAuditTaskCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CancelAuditTask", {})
    .n("IoTClient", "CancelAuditTaskCommand")
    .sc(schemas_0.CancelAuditTask$)
    .build() {
}

class CancelCertificateTransferCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CancelCertificateTransfer", {})
    .n("IoTClient", "CancelCertificateTransferCommand")
    .sc(schemas_0.CancelCertificateTransfer$)
    .build() {
}

class CancelDetectMitigationActionsTaskCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CancelDetectMitigationActionsTask", {})
    .n("IoTClient", "CancelDetectMitigationActionsTaskCommand")
    .sc(schemas_0.CancelDetectMitigationActionsTask$)
    .build() {
}

class CancelJobCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CancelJob", {})
    .n("IoTClient", "CancelJobCommand")
    .sc(schemas_0.CancelJob$)
    .build() {
}

class CancelJobExecutionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CancelJobExecution", {})
    .n("IoTClient", "CancelJobExecutionCommand")
    .sc(schemas_0.CancelJobExecution$)
    .build() {
}

class ClearDefaultAuthorizerCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "ClearDefaultAuthorizer", {})
    .n("IoTClient", "ClearDefaultAuthorizerCommand")
    .sc(schemas_0.ClearDefaultAuthorizer$)
    .build() {
}

class ConfirmTopicRuleDestinationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "ConfirmTopicRuleDestination", {})
    .n("IoTClient", "ConfirmTopicRuleDestinationCommand")
    .sc(schemas_0.ConfirmTopicRuleDestination$)
    .build() {
}

class CreateAuditSuppressionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateAuditSuppression", {})
    .n("IoTClient", "CreateAuditSuppressionCommand")
    .sc(schemas_0.CreateAuditSuppression$)
    .build() {
}

class CreateAuthorizerCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateAuthorizer", {})
    .n("IoTClient", "CreateAuthorizerCommand")
    .sc(schemas_0.CreateAuthorizer$)
    .build() {
}

class CreateBillingGroupCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateBillingGroup", {})
    .n("IoTClient", "CreateBillingGroupCommand")
    .sc(schemas_0.CreateBillingGroup$)
    .build() {
}

class CreateCertificateFromCsrCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateCertificateFromCsr", {})
    .n("IoTClient", "CreateCertificateFromCsrCommand")
    .sc(schemas_0.CreateCertificateFromCsr$)
    .build() {
}

class CreateCertificateProviderCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateCertificateProvider", {})
    .n("IoTClient", "CreateCertificateProviderCommand")
    .sc(schemas_0.CreateCertificateProvider$)
    .build() {
}

class CreateCommandCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateCommand", {})
    .n("IoTClient", "CreateCommandCommand")
    .sc(schemas_0.CreateCommand$)
    .build() {
}

class CreateCustomMetricCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateCustomMetric", {})
    .n("IoTClient", "CreateCustomMetricCommand")
    .sc(schemas_0.CreateCustomMetric$)
    .build() {
}

class CreateDimensionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateDimension", {})
    .n("IoTClient", "CreateDimensionCommand")
    .sc(schemas_0.CreateDimension$)
    .build() {
}

class CreateDomainConfigurationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateDomainConfiguration", {})
    .n("IoTClient", "CreateDomainConfigurationCommand")
    .sc(schemas_0.CreateDomainConfiguration$)
    .build() {
}

class CreateDynamicThingGroupCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateDynamicThingGroup", {})
    .n("IoTClient", "CreateDynamicThingGroupCommand")
    .sc(schemas_0.CreateDynamicThingGroup$)
    .build() {
}

class CreateFleetMetricCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateFleetMetric", {})
    .n("IoTClient", "CreateFleetMetricCommand")
    .sc(schemas_0.CreateFleetMetric$)
    .build() {
}

class CreateJobCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateJob", {})
    .n("IoTClient", "CreateJobCommand")
    .sc(schemas_0.CreateJob$)
    .build() {
}

class CreateJobTemplateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateJobTemplate", {})
    .n("IoTClient", "CreateJobTemplateCommand")
    .sc(schemas_0.CreateJobTemplate$)
    .build() {
}

class CreateKeysAndCertificateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateKeysAndCertificate", {})
    .n("IoTClient", "CreateKeysAndCertificateCommand")
    .sc(schemas_0.CreateKeysAndCertificate$)
    .build() {
}

class CreateMitigationActionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateMitigationAction", {})
    .n("IoTClient", "CreateMitigationActionCommand")
    .sc(schemas_0.CreateMitigationAction$)
    .build() {
}

class CreateOTAUpdateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateOTAUpdate", {})
    .n("IoTClient", "CreateOTAUpdateCommand")
    .sc(schemas_0.CreateOTAUpdate$)
    .build() {
}

class CreatePackageCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreatePackage", {})
    .n("IoTClient", "CreatePackageCommand")
    .sc(schemas_0.CreatePackage$)
    .build() {
}

class CreatePackageVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreatePackageVersion", {})
    .n("IoTClient", "CreatePackageVersionCommand")
    .sc(schemas_0.CreatePackageVersion$)
    .build() {
}

class CreatePolicyCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreatePolicy", {})
    .n("IoTClient", "CreatePolicyCommand")
    .sc(schemas_0.CreatePolicy$)
    .build() {
}

class CreatePolicyVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreatePolicyVersion", {})
    .n("IoTClient", "CreatePolicyVersionCommand")
    .sc(schemas_0.CreatePolicyVersion$)
    .build() {
}

class CreateProvisioningClaimCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateProvisioningClaim", {})
    .n("IoTClient", "CreateProvisioningClaimCommand")
    .sc(schemas_0.CreateProvisioningClaim$)
    .build() {
}

class CreateProvisioningTemplateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateProvisioningTemplate", {})
    .n("IoTClient", "CreateProvisioningTemplateCommand")
    .sc(schemas_0.CreateProvisioningTemplate$)
    .build() {
}

class CreateProvisioningTemplateVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateProvisioningTemplateVersion", {})
    .n("IoTClient", "CreateProvisioningTemplateVersionCommand")
    .sc(schemas_0.CreateProvisioningTemplateVersion$)
    .build() {
}

class CreateRoleAliasCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateRoleAlias", {})
    .n("IoTClient", "CreateRoleAliasCommand")
    .sc(schemas_0.CreateRoleAlias$)
    .build() {
}

class CreateScheduledAuditCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateScheduledAudit", {})
    .n("IoTClient", "CreateScheduledAuditCommand")
    .sc(schemas_0.CreateScheduledAudit$)
    .build() {
}

class CreateSecurityProfileCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateSecurityProfile", {})
    .n("IoTClient", "CreateSecurityProfileCommand")
    .sc(schemas_0.CreateSecurityProfile$)
    .build() {
}

class CreateStreamCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateStream", {})
    .n("IoTClient", "CreateStreamCommand")
    .sc(schemas_0.CreateStream$)
    .build() {
}

class CreateThingCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateThing", {})
    .n("IoTClient", "CreateThingCommand")
    .sc(schemas_0.CreateThing$)
    .build() {
}

class CreateThingGroupCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateThingGroup", {})
    .n("IoTClient", "CreateThingGroupCommand")
    .sc(schemas_0.CreateThingGroup$)
    .build() {
}

class CreateThingTypeCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateThingType", {})
    .n("IoTClient", "CreateThingTypeCommand")
    .sc(schemas_0.CreateThingType$)
    .build() {
}

class CreateTopicRuleCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateTopicRule", {})
    .n("IoTClient", "CreateTopicRuleCommand")
    .sc(schemas_0.CreateTopicRule$)
    .build() {
}

class CreateTopicRuleDestinationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "CreateTopicRuleDestination", {})
    .n("IoTClient", "CreateTopicRuleDestinationCommand")
    .sc(schemas_0.CreateTopicRuleDestination$)
    .build() {
}

class DeleteAccountAuditConfigurationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteAccountAuditConfiguration", {})
    .n("IoTClient", "DeleteAccountAuditConfigurationCommand")
    .sc(schemas_0.DeleteAccountAuditConfiguration$)
    .build() {
}

class DeleteAuditSuppressionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteAuditSuppression", {})
    .n("IoTClient", "DeleteAuditSuppressionCommand")
    .sc(schemas_0.DeleteAuditSuppression$)
    .build() {
}

class DeleteAuthorizerCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteAuthorizer", {})
    .n("IoTClient", "DeleteAuthorizerCommand")
    .sc(schemas_0.DeleteAuthorizer$)
    .build() {
}

class DeleteBillingGroupCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteBillingGroup", {})
    .n("IoTClient", "DeleteBillingGroupCommand")
    .sc(schemas_0.DeleteBillingGroup$)
    .build() {
}

class DeleteCACertificateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteCACertificate", {})
    .n("IoTClient", "DeleteCACertificateCommand")
    .sc(schemas_0.DeleteCACertificate$)
    .build() {
}

class DeleteCertificateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteCertificate", {})
    .n("IoTClient", "DeleteCertificateCommand")
    .sc(schemas_0.DeleteCertificate$)
    .build() {
}

class DeleteCertificateProviderCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteCertificateProvider", {})
    .n("IoTClient", "DeleteCertificateProviderCommand")
    .sc(schemas_0.DeleteCertificateProvider$)
    .build() {
}

class DeleteCommandCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteCommand", {})
    .n("IoTClient", "DeleteCommandCommand")
    .sc(schemas_0.DeleteCommand$)
    .build() {
}

class DeleteCommandExecutionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteCommandExecution", {})
    .n("IoTClient", "DeleteCommandExecutionCommand")
    .sc(schemas_0.DeleteCommandExecution$)
    .build() {
}

class DeleteCustomMetricCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteCustomMetric", {})
    .n("IoTClient", "DeleteCustomMetricCommand")
    .sc(schemas_0.DeleteCustomMetric$)
    .build() {
}

class DeleteDimensionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteDimension", {})
    .n("IoTClient", "DeleteDimensionCommand")
    .sc(schemas_0.DeleteDimension$)
    .build() {
}

class DeleteDomainConfigurationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteDomainConfiguration", {})
    .n("IoTClient", "DeleteDomainConfigurationCommand")
    .sc(schemas_0.DeleteDomainConfiguration$)
    .build() {
}

class DeleteDynamicThingGroupCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteDynamicThingGroup", {})
    .n("IoTClient", "DeleteDynamicThingGroupCommand")
    .sc(schemas_0.DeleteDynamicThingGroup$)
    .build() {
}

class DeleteFleetMetricCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteFleetMetric", {})
    .n("IoTClient", "DeleteFleetMetricCommand")
    .sc(schemas_0.DeleteFleetMetric$)
    .build() {
}

class DeleteJobCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteJob", {})
    .n("IoTClient", "DeleteJobCommand")
    .sc(schemas_0.DeleteJob$)
    .build() {
}

class DeleteJobExecutionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteJobExecution", {})
    .n("IoTClient", "DeleteJobExecutionCommand")
    .sc(schemas_0.DeleteJobExecution$)
    .build() {
}

class DeleteJobTemplateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteJobTemplate", {})
    .n("IoTClient", "DeleteJobTemplateCommand")
    .sc(schemas_0.DeleteJobTemplate$)
    .build() {
}

class DeleteMitigationActionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteMitigationAction", {})
    .n("IoTClient", "DeleteMitigationActionCommand")
    .sc(schemas_0.DeleteMitigationAction$)
    .build() {
}

class DeleteOTAUpdateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteOTAUpdate", {})
    .n("IoTClient", "DeleteOTAUpdateCommand")
    .sc(schemas_0.DeleteOTAUpdate$)
    .build() {
}

class DeletePackageCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeletePackage", {})
    .n("IoTClient", "DeletePackageCommand")
    .sc(schemas_0.DeletePackage$)
    .build() {
}

class DeletePackageVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeletePackageVersion", {})
    .n("IoTClient", "DeletePackageVersionCommand")
    .sc(schemas_0.DeletePackageVersion$)
    .build() {
}

class DeletePolicyCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeletePolicy", {})
    .n("IoTClient", "DeletePolicyCommand")
    .sc(schemas_0.DeletePolicy$)
    .build() {
}

class DeletePolicyVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeletePolicyVersion", {})
    .n("IoTClient", "DeletePolicyVersionCommand")
    .sc(schemas_0.DeletePolicyVersion$)
    .build() {
}

class DeleteProvisioningTemplateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteProvisioningTemplate", {})
    .n("IoTClient", "DeleteProvisioningTemplateCommand")
    .sc(schemas_0.DeleteProvisioningTemplate$)
    .build() {
}

class DeleteProvisioningTemplateVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteProvisioningTemplateVersion", {})
    .n("IoTClient", "DeleteProvisioningTemplateVersionCommand")
    .sc(schemas_0.DeleteProvisioningTemplateVersion$)
    .build() {
}

class DeleteRegistrationCodeCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteRegistrationCode", {})
    .n("IoTClient", "DeleteRegistrationCodeCommand")
    .sc(schemas_0.DeleteRegistrationCode$)
    .build() {
}

class DeleteRoleAliasCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteRoleAlias", {})
    .n("IoTClient", "DeleteRoleAliasCommand")
    .sc(schemas_0.DeleteRoleAlias$)
    .build() {
}

class DeleteScheduledAuditCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteScheduledAudit", {})
    .n("IoTClient", "DeleteScheduledAuditCommand")
    .sc(schemas_0.DeleteScheduledAudit$)
    .build() {
}

class DeleteSecurityProfileCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteSecurityProfile", {})
    .n("IoTClient", "DeleteSecurityProfileCommand")
    .sc(schemas_0.DeleteSecurityProfile$)
    .build() {
}

class DeleteStreamCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteStream", {})
    .n("IoTClient", "DeleteStreamCommand")
    .sc(schemas_0.DeleteStream$)
    .build() {
}

class DeleteThingCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteThing", {})
    .n("IoTClient", "DeleteThingCommand")
    .sc(schemas_0.DeleteThing$)
    .build() {
}

class DeleteThingGroupCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteThingGroup", {})
    .n("IoTClient", "DeleteThingGroupCommand")
    .sc(schemas_0.DeleteThingGroup$)
    .build() {
}

class DeleteThingTypeCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteThingType", {})
    .n("IoTClient", "DeleteThingTypeCommand")
    .sc(schemas_0.DeleteThingType$)
    .build() {
}

class DeleteTopicRuleCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteTopicRule", {})
    .n("IoTClient", "DeleteTopicRuleCommand")
    .sc(schemas_0.DeleteTopicRule$)
    .build() {
}

class DeleteTopicRuleDestinationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteTopicRuleDestination", {})
    .n("IoTClient", "DeleteTopicRuleDestinationCommand")
    .sc(schemas_0.DeleteTopicRuleDestination$)
    .build() {
}

class DeleteV2LoggingLevelCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeleteV2LoggingLevel", {})
    .n("IoTClient", "DeleteV2LoggingLevelCommand")
    .sc(schemas_0.DeleteV2LoggingLevel$)
    .build() {
}

class DeprecateThingTypeCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DeprecateThingType", {})
    .n("IoTClient", "DeprecateThingTypeCommand")
    .sc(schemas_0.DeprecateThingType$)
    .build() {
}

class DescribeAccountAuditConfigurationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeAccountAuditConfiguration", {})
    .n("IoTClient", "DescribeAccountAuditConfigurationCommand")
    .sc(schemas_0.DescribeAccountAuditConfiguration$)
    .build() {
}

class DescribeAuditFindingCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeAuditFinding", {})
    .n("IoTClient", "DescribeAuditFindingCommand")
    .sc(schemas_0.DescribeAuditFinding$)
    .build() {
}

class DescribeAuditMitigationActionsTaskCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeAuditMitigationActionsTask", {})
    .n("IoTClient", "DescribeAuditMitigationActionsTaskCommand")
    .sc(schemas_0.DescribeAuditMitigationActionsTask$)
    .build() {
}

class DescribeAuditSuppressionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeAuditSuppression", {})
    .n("IoTClient", "DescribeAuditSuppressionCommand")
    .sc(schemas_0.DescribeAuditSuppression$)
    .build() {
}

class DescribeAuditTaskCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeAuditTask", {})
    .n("IoTClient", "DescribeAuditTaskCommand")
    .sc(schemas_0.DescribeAuditTask$)
    .build() {
}

class DescribeAuthorizerCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeAuthorizer", {})
    .n("IoTClient", "DescribeAuthorizerCommand")
    .sc(schemas_0.DescribeAuthorizer$)
    .build() {
}

class DescribeBillingGroupCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeBillingGroup", {})
    .n("IoTClient", "DescribeBillingGroupCommand")
    .sc(schemas_0.DescribeBillingGroup$)
    .build() {
}

class DescribeCACertificateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeCACertificate", {})
    .n("IoTClient", "DescribeCACertificateCommand")
    .sc(schemas_0.DescribeCACertificate$)
    .build() {
}

class DescribeCertificateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeCertificate", {})
    .n("IoTClient", "DescribeCertificateCommand")
    .sc(schemas_0.DescribeCertificate$)
    .build() {
}

class DescribeCertificateProviderCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeCertificateProvider", {})
    .n("IoTClient", "DescribeCertificateProviderCommand")
    .sc(schemas_0.DescribeCertificateProvider$)
    .build() {
}

class DescribeCustomMetricCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeCustomMetric", {})
    .n("IoTClient", "DescribeCustomMetricCommand")
    .sc(schemas_0.DescribeCustomMetric$)
    .build() {
}

class DescribeDefaultAuthorizerCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeDefaultAuthorizer", {})
    .n("IoTClient", "DescribeDefaultAuthorizerCommand")
    .sc(schemas_0.DescribeDefaultAuthorizer$)
    .build() {
}

class DescribeDetectMitigationActionsTaskCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeDetectMitigationActionsTask", {})
    .n("IoTClient", "DescribeDetectMitigationActionsTaskCommand")
    .sc(schemas_0.DescribeDetectMitigationActionsTask$)
    .build() {
}

class DescribeDimensionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeDimension", {})
    .n("IoTClient", "DescribeDimensionCommand")
    .sc(schemas_0.DescribeDimension$)
    .build() {
}

class DescribeDomainConfigurationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeDomainConfiguration", {})
    .n("IoTClient", "DescribeDomainConfigurationCommand")
    .sc(schemas_0.DescribeDomainConfiguration$)
    .build() {
}

class DescribeEncryptionConfigurationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeEncryptionConfiguration", {})
    .n("IoTClient", "DescribeEncryptionConfigurationCommand")
    .sc(schemas_0.DescribeEncryptionConfiguration$)
    .build() {
}

class DescribeEndpointCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeEndpoint", {})
    .n("IoTClient", "DescribeEndpointCommand")
    .sc(schemas_0.DescribeEndpoint$)
    .build() {
}

class DescribeEventConfigurationsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeEventConfigurations", {})
    .n("IoTClient", "DescribeEventConfigurationsCommand")
    .sc(schemas_0.DescribeEventConfigurations$)
    .build() {
}

class DescribeFleetMetricCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeFleetMetric", {})
    .n("IoTClient", "DescribeFleetMetricCommand")
    .sc(schemas_0.DescribeFleetMetric$)
    .build() {
}

class DescribeIndexCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSIotService", "DescribeIndex", {})
    .n("IoTClient", "DescribeIndexCommand")
    .sc(schemas_0.Desc