3023 lines
109 KiB
JavaScript
3023 lines
109 KiB
JavaScript
'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 CloudFormationServiceException = require('./models/CloudFormationServiceException');
|
|
|
|
const resolveClientEndpointParameters = (options) => {
|
|
return Object.assign(options, {
|
|
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
|
|
useFipsEndpoint: options.useFipsEndpoint ?? false,
|
|
defaultSigningName: "cloudformation",
|
|
});
|
|
};
|
|
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 CloudFormationClient 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.defaultCloudFormationHttpAuthSchemeParametersProvider,
|
|
identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
|
|
"aws.auth#sigv4": config.credentials,
|
|
}),
|
|
}));
|
|
this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
|
|
}
|
|
destroy() {
|
|
super.destroy();
|
|
}
|
|
}
|
|
|
|
class ActivateOrganizationsAccessCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ActivateOrganizationsAccess", {})
|
|
.n("CloudFormationClient", "ActivateOrganizationsAccessCommand")
|
|
.sc(schemas_0.ActivateOrganizationsAccess$)
|
|
.build() {
|
|
}
|
|
|
|
class ActivateTypeCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ActivateType", {})
|
|
.n("CloudFormationClient", "ActivateTypeCommand")
|
|
.sc(schemas_0.ActivateType$)
|
|
.build() {
|
|
}
|
|
|
|
class BatchDescribeTypeConfigurationsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "BatchDescribeTypeConfigurations", {})
|
|
.n("CloudFormationClient", "BatchDescribeTypeConfigurationsCommand")
|
|
.sc(schemas_0.BatchDescribeTypeConfigurations$)
|
|
.build() {
|
|
}
|
|
|
|
class CancelUpdateStackCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "CancelUpdateStack", {})
|
|
.n("CloudFormationClient", "CancelUpdateStackCommand")
|
|
.sc(schemas_0.CancelUpdateStack$)
|
|
.build() {
|
|
}
|
|
|
|
class ContinueUpdateRollbackCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ContinueUpdateRollback", {})
|
|
.n("CloudFormationClient", "ContinueUpdateRollbackCommand")
|
|
.sc(schemas_0.ContinueUpdateRollback$)
|
|
.build() {
|
|
}
|
|
|
|
class CreateChangeSetCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "CreateChangeSet", {})
|
|
.n("CloudFormationClient", "CreateChangeSetCommand")
|
|
.sc(schemas_0.CreateChangeSet$)
|
|
.build() {
|
|
}
|
|
|
|
class CreateGeneratedTemplateCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "CreateGeneratedTemplate", {})
|
|
.n("CloudFormationClient", "CreateGeneratedTemplateCommand")
|
|
.sc(schemas_0.CreateGeneratedTemplate$)
|
|
.build() {
|
|
}
|
|
|
|
class CreateStackCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "CreateStack", {})
|
|
.n("CloudFormationClient", "CreateStackCommand")
|
|
.sc(schemas_0.CreateStack$)
|
|
.build() {
|
|
}
|
|
|
|
class CreateStackInstancesCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "CreateStackInstances", {})
|
|
.n("CloudFormationClient", "CreateStackInstancesCommand")
|
|
.sc(schemas_0.CreateStackInstances$)
|
|
.build() {
|
|
}
|
|
|
|
class CreateStackRefactorCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "CreateStackRefactor", {})
|
|
.n("CloudFormationClient", "CreateStackRefactorCommand")
|
|
.sc(schemas_0.CreateStackRefactor$)
|
|
.build() {
|
|
}
|
|
|
|
class CreateStackSetCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "CreateStackSet", {})
|
|
.n("CloudFormationClient", "CreateStackSetCommand")
|
|
.sc(schemas_0.CreateStackSet$)
|
|
.build() {
|
|
}
|
|
|
|
class DeactivateOrganizationsAccessCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DeactivateOrganizationsAccess", {})
|
|
.n("CloudFormationClient", "DeactivateOrganizationsAccessCommand")
|
|
.sc(schemas_0.DeactivateOrganizationsAccess$)
|
|
.build() {
|
|
}
|
|
|
|
class DeactivateTypeCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DeactivateType", {})
|
|
.n("CloudFormationClient", "DeactivateTypeCommand")
|
|
.sc(schemas_0.DeactivateType$)
|
|
.build() {
|
|
}
|
|
|
|
class DeleteChangeSetCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DeleteChangeSet", {})
|
|
.n("CloudFormationClient", "DeleteChangeSetCommand")
|
|
.sc(schemas_0.DeleteChangeSet$)
|
|
.build() {
|
|
}
|
|
|
|
class DeleteGeneratedTemplateCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DeleteGeneratedTemplate", {})
|
|
.n("CloudFormationClient", "DeleteGeneratedTemplateCommand")
|
|
.sc(schemas_0.DeleteGeneratedTemplate$)
|
|
.build() {
|
|
}
|
|
|
|
class DeleteStackCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DeleteStack", {})
|
|
.n("CloudFormationClient", "DeleteStackCommand")
|
|
.sc(schemas_0.DeleteStack$)
|
|
.build() {
|
|
}
|
|
|
|
class DeleteStackInstancesCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DeleteStackInstances", {})
|
|
.n("CloudFormationClient", "DeleteStackInstancesCommand")
|
|
.sc(schemas_0.DeleteStackInstances$)
|
|
.build() {
|
|
}
|
|
|
|
class DeleteStackSetCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DeleteStackSet", {})
|
|
.n("CloudFormationClient", "DeleteStackSetCommand")
|
|
.sc(schemas_0.DeleteStackSet$)
|
|
.build() {
|
|
}
|
|
|
|
class DeregisterTypeCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DeregisterType", {})
|
|
.n("CloudFormationClient", "DeregisterTypeCommand")
|
|
.sc(schemas_0.DeregisterType$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeAccountLimitsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeAccountLimits", {})
|
|
.n("CloudFormationClient", "DescribeAccountLimitsCommand")
|
|
.sc(schemas_0.DescribeAccountLimits$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeChangeSetCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeChangeSet", {})
|
|
.n("CloudFormationClient", "DescribeChangeSetCommand")
|
|
.sc(schemas_0.DescribeChangeSet$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeChangeSetHooksCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeChangeSetHooks", {})
|
|
.n("CloudFormationClient", "DescribeChangeSetHooksCommand")
|
|
.sc(schemas_0.DescribeChangeSetHooks$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeEventsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeEvents", {})
|
|
.n("CloudFormationClient", "DescribeEventsCommand")
|
|
.sc(schemas_0.DescribeEvents$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeGeneratedTemplateCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeGeneratedTemplate", {})
|
|
.n("CloudFormationClient", "DescribeGeneratedTemplateCommand")
|
|
.sc(schemas_0.DescribeGeneratedTemplate$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeOrganizationsAccessCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeOrganizationsAccess", {})
|
|
.n("CloudFormationClient", "DescribeOrganizationsAccessCommand")
|
|
.sc(schemas_0.DescribeOrganizationsAccess$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribePublisherCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribePublisher", {})
|
|
.n("CloudFormationClient", "DescribePublisherCommand")
|
|
.sc(schemas_0.DescribePublisher$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeResourceScanCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeResourceScan", {})
|
|
.n("CloudFormationClient", "DescribeResourceScanCommand")
|
|
.sc(schemas_0.DescribeResourceScan$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeStackDriftDetectionStatusCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeStackDriftDetectionStatus", {})
|
|
.n("CloudFormationClient", "DescribeStackDriftDetectionStatusCommand")
|
|
.sc(schemas_0.DescribeStackDriftDetectionStatus$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeStackEventsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeStackEvents", {})
|
|
.n("CloudFormationClient", "DescribeStackEventsCommand")
|
|
.sc(schemas_0.DescribeStackEvents$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeStackInstanceCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeStackInstance", {})
|
|
.n("CloudFormationClient", "DescribeStackInstanceCommand")
|
|
.sc(schemas_0.DescribeStackInstance$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeStackRefactorCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeStackRefactor", {})
|
|
.n("CloudFormationClient", "DescribeStackRefactorCommand")
|
|
.sc(schemas_0.DescribeStackRefactor$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeStackResourceCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeStackResource", {})
|
|
.n("CloudFormationClient", "DescribeStackResourceCommand")
|
|
.sc(schemas_0.DescribeStackResource$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeStackResourceDriftsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeStackResourceDrifts", {})
|
|
.n("CloudFormationClient", "DescribeStackResourceDriftsCommand")
|
|
.sc(schemas_0.DescribeStackResourceDrifts$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeStackResourcesCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeStackResources", {})
|
|
.n("CloudFormationClient", "DescribeStackResourcesCommand")
|
|
.sc(schemas_0.DescribeStackResources$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeStacksCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeStacks", {})
|
|
.n("CloudFormationClient", "DescribeStacksCommand")
|
|
.sc(schemas_0.DescribeStacks$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeStackSetCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeStackSet", {})
|
|
.n("CloudFormationClient", "DescribeStackSetCommand")
|
|
.sc(schemas_0.DescribeStackSet$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeStackSetOperationCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeStackSetOperation", {})
|
|
.n("CloudFormationClient", "DescribeStackSetOperationCommand")
|
|
.sc(schemas_0.DescribeStackSetOperation$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeTypeCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeType", {})
|
|
.n("CloudFormationClient", "DescribeTypeCommand")
|
|
.sc(schemas_0.DescribeType$)
|
|
.build() {
|
|
}
|
|
|
|
class DescribeTypeRegistrationCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DescribeTypeRegistration", {})
|
|
.n("CloudFormationClient", "DescribeTypeRegistrationCommand")
|
|
.sc(schemas_0.DescribeTypeRegistration$)
|
|
.build() {
|
|
}
|
|
|
|
class DetectStackDriftCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DetectStackDrift", {})
|
|
.n("CloudFormationClient", "DetectStackDriftCommand")
|
|
.sc(schemas_0.DetectStackDrift$)
|
|
.build() {
|
|
}
|
|
|
|
class DetectStackResourceDriftCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DetectStackResourceDrift", {})
|
|
.n("CloudFormationClient", "DetectStackResourceDriftCommand")
|
|
.sc(schemas_0.DetectStackResourceDrift$)
|
|
.build() {
|
|
}
|
|
|
|
class DetectStackSetDriftCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "DetectStackSetDrift", {})
|
|
.n("CloudFormationClient", "DetectStackSetDriftCommand")
|
|
.sc(schemas_0.DetectStackSetDrift$)
|
|
.build() {
|
|
}
|
|
|
|
class EstimateTemplateCostCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "EstimateTemplateCost", {})
|
|
.n("CloudFormationClient", "EstimateTemplateCostCommand")
|
|
.sc(schemas_0.EstimateTemplateCost$)
|
|
.build() {
|
|
}
|
|
|
|
class ExecuteChangeSetCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ExecuteChangeSet", {})
|
|
.n("CloudFormationClient", "ExecuteChangeSetCommand")
|
|
.sc(schemas_0.ExecuteChangeSet$)
|
|
.build() {
|
|
}
|
|
|
|
class ExecuteStackRefactorCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ExecuteStackRefactor", {})
|
|
.n("CloudFormationClient", "ExecuteStackRefactorCommand")
|
|
.sc(schemas_0.ExecuteStackRefactor$)
|
|
.build() {
|
|
}
|
|
|
|
class GetGeneratedTemplateCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "GetGeneratedTemplate", {})
|
|
.n("CloudFormationClient", "GetGeneratedTemplateCommand")
|
|
.sc(schemas_0.GetGeneratedTemplate$)
|
|
.build() {
|
|
}
|
|
|
|
class GetHookResultCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "GetHookResult", {})
|
|
.n("CloudFormationClient", "GetHookResultCommand")
|
|
.sc(schemas_0.GetHookResult$)
|
|
.build() {
|
|
}
|
|
|
|
class GetStackPolicyCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "GetStackPolicy", {})
|
|
.n("CloudFormationClient", "GetStackPolicyCommand")
|
|
.sc(schemas_0.GetStackPolicy$)
|
|
.build() {
|
|
}
|
|
|
|
class GetTemplateCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "GetTemplate", {})
|
|
.n("CloudFormationClient", "GetTemplateCommand")
|
|
.sc(schemas_0.GetTemplate$)
|
|
.build() {
|
|
}
|
|
|
|
class GetTemplateSummaryCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "GetTemplateSummary", {})
|
|
.n("CloudFormationClient", "GetTemplateSummaryCommand")
|
|
.sc(schemas_0.GetTemplateSummary$)
|
|
.build() {
|
|
}
|
|
|
|
class ImportStacksToStackSetCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ImportStacksToStackSet", {})
|
|
.n("CloudFormationClient", "ImportStacksToStackSetCommand")
|
|
.sc(schemas_0.ImportStacksToStackSet$)
|
|
.build() {
|
|
}
|
|
|
|
class ListChangeSetsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListChangeSets", {})
|
|
.n("CloudFormationClient", "ListChangeSetsCommand")
|
|
.sc(schemas_0.ListChangeSets$)
|
|
.build() {
|
|
}
|
|
|
|
class ListExportsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListExports", {})
|
|
.n("CloudFormationClient", "ListExportsCommand")
|
|
.sc(schemas_0.ListExports$)
|
|
.build() {
|
|
}
|
|
|
|
class ListGeneratedTemplatesCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListGeneratedTemplates", {})
|
|
.n("CloudFormationClient", "ListGeneratedTemplatesCommand")
|
|
.sc(schemas_0.ListGeneratedTemplates$)
|
|
.build() {
|
|
}
|
|
|
|
class ListHookResultsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListHookResults", {})
|
|
.n("CloudFormationClient", "ListHookResultsCommand")
|
|
.sc(schemas_0.ListHookResults$)
|
|
.build() {
|
|
}
|
|
|
|
class ListImportsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListImports", {})
|
|
.n("CloudFormationClient", "ListImportsCommand")
|
|
.sc(schemas_0.ListImports$)
|
|
.build() {
|
|
}
|
|
|
|
class ListResourceScanRelatedResourcesCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListResourceScanRelatedResources", {})
|
|
.n("CloudFormationClient", "ListResourceScanRelatedResourcesCommand")
|
|
.sc(schemas_0.ListResourceScanRelatedResources$)
|
|
.build() {
|
|
}
|
|
|
|
class ListResourceScanResourcesCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListResourceScanResources", {})
|
|
.n("CloudFormationClient", "ListResourceScanResourcesCommand")
|
|
.sc(schemas_0.ListResourceScanResources$)
|
|
.build() {
|
|
}
|
|
|
|
class ListResourceScansCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListResourceScans", {})
|
|
.n("CloudFormationClient", "ListResourceScansCommand")
|
|
.sc(schemas_0.ListResourceScans$)
|
|
.build() {
|
|
}
|
|
|
|
class ListStackInstanceResourceDriftsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListStackInstanceResourceDrifts", {})
|
|
.n("CloudFormationClient", "ListStackInstanceResourceDriftsCommand")
|
|
.sc(schemas_0.ListStackInstanceResourceDrifts$)
|
|
.build() {
|
|
}
|
|
|
|
class ListStackInstancesCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListStackInstances", {})
|
|
.n("CloudFormationClient", "ListStackInstancesCommand")
|
|
.sc(schemas_0.ListStackInstances$)
|
|
.build() {
|
|
}
|
|
|
|
class ListStackRefactorActionsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListStackRefactorActions", {})
|
|
.n("CloudFormationClient", "ListStackRefactorActionsCommand")
|
|
.sc(schemas_0.ListStackRefactorActions$)
|
|
.build() {
|
|
}
|
|
|
|
class ListStackRefactorsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListStackRefactors", {})
|
|
.n("CloudFormationClient", "ListStackRefactorsCommand")
|
|
.sc(schemas_0.ListStackRefactors$)
|
|
.build() {
|
|
}
|
|
|
|
class ListStackResourcesCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListStackResources", {})
|
|
.n("CloudFormationClient", "ListStackResourcesCommand")
|
|
.sc(schemas_0.ListStackResources$)
|
|
.build() {
|
|
}
|
|
|
|
class ListStacksCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListStacks", {})
|
|
.n("CloudFormationClient", "ListStacksCommand")
|
|
.sc(schemas_0.ListStacks$)
|
|
.build() {
|
|
}
|
|
|
|
class ListStackSetAutoDeploymentTargetsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListStackSetAutoDeploymentTargets", {})
|
|
.n("CloudFormationClient", "ListStackSetAutoDeploymentTargetsCommand")
|
|
.sc(schemas_0.ListStackSetAutoDeploymentTargets$)
|
|
.build() {
|
|
}
|
|
|
|
class ListStackSetOperationResultsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListStackSetOperationResults", {})
|
|
.n("CloudFormationClient", "ListStackSetOperationResultsCommand")
|
|
.sc(schemas_0.ListStackSetOperationResults$)
|
|
.build() {
|
|
}
|
|
|
|
class ListStackSetOperationsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListStackSetOperations", {})
|
|
.n("CloudFormationClient", "ListStackSetOperationsCommand")
|
|
.sc(schemas_0.ListStackSetOperations$)
|
|
.build() {
|
|
}
|
|
|
|
class ListStackSetsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListStackSets", {})
|
|
.n("CloudFormationClient", "ListStackSetsCommand")
|
|
.sc(schemas_0.ListStackSets$)
|
|
.build() {
|
|
}
|
|
|
|
class ListTypeRegistrationsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListTypeRegistrations", {})
|
|
.n("CloudFormationClient", "ListTypeRegistrationsCommand")
|
|
.sc(schemas_0.ListTypeRegistrations$)
|
|
.build() {
|
|
}
|
|
|
|
class ListTypesCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListTypes", {})
|
|
.n("CloudFormationClient", "ListTypesCommand")
|
|
.sc(schemas_0.ListTypes$)
|
|
.build() {
|
|
}
|
|
|
|
class ListTypeVersionsCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ListTypeVersions", {})
|
|
.n("CloudFormationClient", "ListTypeVersionsCommand")
|
|
.sc(schemas_0.ListTypeVersions$)
|
|
.build() {
|
|
}
|
|
|
|
class PublishTypeCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "PublishType", {})
|
|
.n("CloudFormationClient", "PublishTypeCommand")
|
|
.sc(schemas_0.PublishType$)
|
|
.build() {
|
|
}
|
|
|
|
class RecordHandlerProgressCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "RecordHandlerProgress", {})
|
|
.n("CloudFormationClient", "RecordHandlerProgressCommand")
|
|
.sc(schemas_0.RecordHandlerProgress$)
|
|
.build() {
|
|
}
|
|
|
|
class RegisterPublisherCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "RegisterPublisher", {})
|
|
.n("CloudFormationClient", "RegisterPublisherCommand")
|
|
.sc(schemas_0.RegisterPublisher$)
|
|
.build() {
|
|
}
|
|
|
|
class RegisterTypeCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "RegisterType", {})
|
|
.n("CloudFormationClient", "RegisterTypeCommand")
|
|
.sc(schemas_0.RegisterType$)
|
|
.build() {
|
|
}
|
|
|
|
class RollbackStackCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "RollbackStack", {})
|
|
.n("CloudFormationClient", "RollbackStackCommand")
|
|
.sc(schemas_0.RollbackStack$)
|
|
.build() {
|
|
}
|
|
|
|
class SetStackPolicyCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "SetStackPolicy", {})
|
|
.n("CloudFormationClient", "SetStackPolicyCommand")
|
|
.sc(schemas_0.SetStackPolicy$)
|
|
.build() {
|
|
}
|
|
|
|
class SetTypeConfigurationCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "SetTypeConfiguration", {})
|
|
.n("CloudFormationClient", "SetTypeConfigurationCommand")
|
|
.sc(schemas_0.SetTypeConfiguration$)
|
|
.build() {
|
|
}
|
|
|
|
class SetTypeDefaultVersionCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "SetTypeDefaultVersion", {})
|
|
.n("CloudFormationClient", "SetTypeDefaultVersionCommand")
|
|
.sc(schemas_0.SetTypeDefaultVersion$)
|
|
.build() {
|
|
}
|
|
|
|
class SignalResourceCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "SignalResource", {})
|
|
.n("CloudFormationClient", "SignalResourceCommand")
|
|
.sc(schemas_0.SignalResource$)
|
|
.build() {
|
|
}
|
|
|
|
class StartResourceScanCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "StartResourceScan", {})
|
|
.n("CloudFormationClient", "StartResourceScanCommand")
|
|
.sc(schemas_0.StartResourceScan$)
|
|
.build() {
|
|
}
|
|
|
|
class StopStackSetOperationCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "StopStackSetOperation", {})
|
|
.n("CloudFormationClient", "StopStackSetOperationCommand")
|
|
.sc(schemas_0.StopStackSetOperation$)
|
|
.build() {
|
|
}
|
|
|
|
class TestTypeCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "TestType", {})
|
|
.n("CloudFormationClient", "TestTypeCommand")
|
|
.sc(schemas_0.TestType$)
|
|
.build() {
|
|
}
|
|
|
|
class UpdateGeneratedTemplateCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "UpdateGeneratedTemplate", {})
|
|
.n("CloudFormationClient", "UpdateGeneratedTemplateCommand")
|
|
.sc(schemas_0.UpdateGeneratedTemplate$)
|
|
.build() {
|
|
}
|
|
|
|
class UpdateStackCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "UpdateStack", {})
|
|
.n("CloudFormationClient", "UpdateStackCommand")
|
|
.sc(schemas_0.UpdateStack$)
|
|
.build() {
|
|
}
|
|
|
|
class UpdateStackInstancesCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "UpdateStackInstances", {})
|
|
.n("CloudFormationClient", "UpdateStackInstancesCommand")
|
|
.sc(schemas_0.UpdateStackInstances$)
|
|
.build() {
|
|
}
|
|
|
|
class UpdateStackSetCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "UpdateStackSet", {})
|
|
.n("CloudFormationClient", "UpdateStackSetCommand")
|
|
.sc(schemas_0.UpdateStackSet$)
|
|
.build() {
|
|
}
|
|
|
|
class UpdateTerminationProtectionCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "UpdateTerminationProtection", {})
|
|
.n("CloudFormationClient", "UpdateTerminationProtectionCommand")
|
|
.sc(schemas_0.UpdateTerminationProtection$)
|
|
.build() {
|
|
}
|
|
|
|
class ValidateTemplateCommand extends client.Command
|
|
.classBuilder()
|
|
.ep(commonParams)
|
|
.m(function (Command, cs, config, o) {
|
|
return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
})
|
|
.s("CloudFormation", "ValidateTemplate", {})
|
|
.n("CloudFormationClient", "ValidateTemplateCommand")
|
|
.sc(schemas_0.ValidateTemplate$)
|
|
.build() {
|
|
}
|
|
|
|
const paginateDescribeAccountLimits = core.createPaginator(CloudFormationClient, DescribeAccountLimitsCommand, "NextToken", "NextToken", "");
|
|
|
|
const paginateDescribeChangeSet = core.createPaginator(CloudFormationClient, DescribeChangeSetCommand, "NextToken", "NextToken", "");
|
|
|
|
const paginateDescribeEvents = core.createPaginator(CloudFormationClient, DescribeEventsCommand, "NextToken", "NextToken", "");
|
|
|
|
const paginateDescribeStackEvents = core.createPaginator(CloudFormationClient, DescribeStackEventsCommand, "NextToken", "NextToken", "");
|
|
|
|
const paginateDescribeStackResourceDrifts = core.createPaginator(CloudFormationClient, DescribeStackResourceDriftsCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateDescribeStacks = core.createPaginator(CloudFormationClient, DescribeStacksCommand, "NextToken", "NextToken", "");
|
|
|
|
const paginateListChangeSets = core.createPaginator(CloudFormationClient, ListChangeSetsCommand, "NextToken", "NextToken", "");
|
|
|
|
const paginateListExports = core.createPaginator(CloudFormationClient, ListExportsCommand, "NextToken", "NextToken", "");
|
|
|
|
const paginateListGeneratedTemplates = core.createPaginator(CloudFormationClient, ListGeneratedTemplatesCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListImports = core.createPaginator(CloudFormationClient, ListImportsCommand, "NextToken", "NextToken", "");
|
|
|
|
const paginateListResourceScanRelatedResources = core.createPaginator(CloudFormationClient, ListResourceScanRelatedResourcesCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListResourceScanResources = core.createPaginator(CloudFormationClient, ListResourceScanResourcesCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListResourceScans = core.createPaginator(CloudFormationClient, ListResourceScansCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListStackInstances = core.createPaginator(CloudFormationClient, ListStackInstancesCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListStackRefactorActions = core.createPaginator(CloudFormationClient, ListStackRefactorActionsCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListStackRefactors = core.createPaginator(CloudFormationClient, ListStackRefactorsCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListStackResources = core.createPaginator(CloudFormationClient, ListStackResourcesCommand, "NextToken", "NextToken", "");
|
|
|
|
const paginateListStackSetOperationResults = core.createPaginator(CloudFormationClient, ListStackSetOperationResultsCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListStackSetOperations = core.createPaginator(CloudFormationClient, ListStackSetOperationsCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListStackSets = core.createPaginator(CloudFormationClient, ListStackSetsCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListStacks = core.createPaginator(CloudFormationClient, ListStacksCommand, "NextToken", "NextToken", "");
|
|
|
|
const paginateListTypeRegistrations = core.createPaginator(CloudFormationClient, ListTypeRegistrationsCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListTypes = core.createPaginator(CloudFormationClient, ListTypesCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const paginateListTypeVersions = core.createPaginator(CloudFormationClient, ListTypeVersionsCommand, "NextToken", "NextToken", "MaxResults");
|
|
|
|
const checkState$9 = async (client$1, input) => {
|
|
let reason;
|
|
try {
|
|
let result = await client$1.send(new DescribeChangeSetCommand(input));
|
|
reason = result;
|
|
try {
|
|
const returnComparator = () => {
|
|
return result.Status;
|
|
};
|
|
if (returnComparator() === "CREATE_COMPLETE") {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
return result.Status;
|
|
};
|
|
if (returnComparator() === "FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
}
|
|
catch (exception) {
|
|
reason = exception;
|
|
if (exception.name === "ValidationError") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
};
|
|
const waitForChangeSetCreateComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
|
|
};
|
|
const waitUntilChangeSetCreateComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
|
|
return client.checkExceptions(result);
|
|
};
|
|
|
|
const checkState$8 = async (client$1, input) => {
|
|
let reason;
|
|
try {
|
|
let result = await client$1.send(new DescribeStacksCommand(input));
|
|
reason = result;
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "CREATE_COMPLETE");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_COMPLETE");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_IN_PROGRESS");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_FAILED");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_IN_PROGRESS");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_FAILED");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_COMPLETE");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "CREATE_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "DELETE_COMPLETE") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "DELETE_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "ROLLBACK_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "ROLLBACK_COMPLETE") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
}
|
|
catch (exception) {
|
|
reason = exception;
|
|
if (exception.name === "ValidationError") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
};
|
|
const waitForStackCreateComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
|
|
};
|
|
const waitUntilStackCreateComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
|
|
return client.checkExceptions(result);
|
|
};
|
|
|
|
const checkState$7 = async (client$1, input) => {
|
|
let reason;
|
|
try {
|
|
let result = await client$1.send(new DescribeStacksCommand(input));
|
|
reason = result;
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "DELETE_COMPLETE");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "DELETE_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "CREATE_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "ROLLBACK_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "UPDATE_ROLLBACK_IN_PROGRESS") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "UPDATE_ROLLBACK_COMPLETE") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "UPDATE_COMPLETE") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
}
|
|
catch (exception) {
|
|
reason = exception;
|
|
if (exception.name === "ValidationError") {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
};
|
|
const waitForStackDeleteComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
|
|
};
|
|
const waitUntilStackDeleteComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
|
|
return client.checkExceptions(result);
|
|
};
|
|
|
|
const checkState$6 = async (client$1, input) => {
|
|
let reason;
|
|
try {
|
|
let result = await client$1.send(new DescribeStacksCommand(input));
|
|
reason = result;
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
catch (exception) {
|
|
reason = exception;
|
|
if (exception.name === "ValidationError") {
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
}
|
|
}
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
};
|
|
const waitForStackExists = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
|
|
};
|
|
const waitUntilStackExists = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
|
|
return client.checkExceptions(result);
|
|
};
|
|
|
|
const checkState$5 = async (client$1, input) => {
|
|
let reason;
|
|
try {
|
|
let result = await client$1.send(new DescribeStacksCommand(input));
|
|
reason = result;
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "IMPORT_COMPLETE");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "ROLLBACK_COMPLETE") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "ROLLBACK_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "IMPORT_ROLLBACK_IN_PROGRESS") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "IMPORT_ROLLBACK_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "IMPORT_ROLLBACK_COMPLETE") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
}
|
|
catch (exception) {
|
|
reason = exception;
|
|
if (exception.name === "ValidationError") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
};
|
|
const waitForStackImportComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
|
|
};
|
|
const waitUntilStackImportComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
|
|
return client.checkExceptions(result);
|
|
};
|
|
|
|
const checkState$4 = async (client$1, input) => {
|
|
let reason;
|
|
try {
|
|
let result = await client$1.send(new DescribeStackRefactorCommand(input));
|
|
reason = result;
|
|
try {
|
|
const returnComparator = () => {
|
|
return result.Status;
|
|
};
|
|
if (returnComparator() === "CREATE_COMPLETE") {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
return result.Status;
|
|
};
|
|
if (returnComparator() === "CREATE_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
}
|
|
catch (exception) {
|
|
reason = exception;
|
|
if (exception.name === "ValidationError") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
};
|
|
const waitForStackRefactorCreateComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
|
|
};
|
|
const waitUntilStackRefactorCreateComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
|
|
return client.checkExceptions(result);
|
|
};
|
|
|
|
const checkState$3 = async (client$1, input) => {
|
|
let reason;
|
|
try {
|
|
let result = await client$1.send(new DescribeStackRefactorCommand(input));
|
|
reason = result;
|
|
try {
|
|
const returnComparator = () => {
|
|
return result.ExecutionStatus;
|
|
};
|
|
if (returnComparator() === "EXECUTE_COMPLETE") {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
return result.ExecutionStatus;
|
|
};
|
|
if (returnComparator() === "EXECUTE_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
return result.ExecutionStatus;
|
|
};
|
|
if (returnComparator() === "ROLLBACK_COMPLETE") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
}
|
|
catch (exception) {
|
|
reason = exception;
|
|
if (exception.name === "ValidationError") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
};
|
|
const waitForStackRefactorExecuteComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 15, maxDelay: 120 };
|
|
return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
|
|
};
|
|
const waitUntilStackRefactorExecuteComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 15, maxDelay: 120 };
|
|
const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
|
|
return client.checkExceptions(result);
|
|
};
|
|
|
|
const checkState$2 = async (client$1, input) => {
|
|
let reason;
|
|
try {
|
|
let result = await client$1.send(new DescribeStacksCommand(input));
|
|
reason = result;
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_COMPLETE");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "UPDATE_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "DELETE_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
}
|
|
catch (exception) {
|
|
reason = exception;
|
|
if (exception.name === "ValidationError") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
};
|
|
const waitForStackRollbackComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
|
|
};
|
|
const waitUntilStackRollbackComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
|
|
return client.checkExceptions(result);
|
|
};
|
|
|
|
const checkState$1 = async (client$1, input) => {
|
|
let reason;
|
|
try {
|
|
let result = await client$1.send(new DescribeStacksCommand(input));
|
|
reason = result;
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
let allStringEq_5 = (returnComparator().length > 0);
|
|
for (let element_4 of returnComparator()) {
|
|
allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_COMPLETE");
|
|
}
|
|
if (allStringEq_5) {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "UPDATE_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
let flat_1 = [].concat(...result.Stacks);
|
|
let projection_3 = flat_1.map((element_2) => {
|
|
return element_2.StackStatus;
|
|
});
|
|
return projection_3;
|
|
};
|
|
for (let anyStringEq_4 of returnComparator()) {
|
|
if (anyStringEq_4 == "UPDATE_ROLLBACK_COMPLETE") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
}
|
|
catch (exception) {
|
|
reason = exception;
|
|
if (exception.name === "ValidationError") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
};
|
|
const waitForStackUpdateComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
|
|
};
|
|
const waitUntilStackUpdateComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
|
|
return client.checkExceptions(result);
|
|
};
|
|
|
|
const checkState = async (client$1, input) => {
|
|
let reason;
|
|
try {
|
|
let result = await client$1.send(new DescribeTypeRegistrationCommand(input));
|
|
reason = result;
|
|
try {
|
|
const returnComparator = () => {
|
|
return result.ProgressStatus;
|
|
};
|
|
if (returnComparator() === "COMPLETE") {
|
|
return { state: client.WaiterState.SUCCESS, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
const returnComparator = () => {
|
|
return result.ProgressStatus;
|
|
};
|
|
if (returnComparator() === "FAILED") {
|
|
return { state: client.WaiterState.FAILURE, reason };
|
|
}
|
|
}
|
|
catch (e) { }
|
|
}
|
|
catch (exception) {
|
|
reason = exception;
|
|
}
|
|
return { state: client.WaiterState.RETRY, reason };
|
|
};
|
|
const waitForTypeRegistrationComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
|
|
};
|
|
const waitUntilTypeRegistrationComplete = async (params, input) => {
|
|
const serviceDefaults = { minDelay: 30, maxDelay: 120 };
|
|
const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
|
|
return client.checkExceptions(result);
|
|
};
|
|
|
|
const commands = {
|
|
ActivateOrganizationsAccessCommand,
|
|
ActivateTypeCommand,
|
|
BatchDescribeTypeConfigurationsCommand,
|
|
CancelUpdateStackCommand,
|
|
ContinueUpdateRollbackCommand,
|
|
CreateChangeSetCommand,
|
|
CreateGeneratedTemplateCommand,
|
|
CreateStackCommand,
|
|
CreateStackInstancesCommand,
|
|
CreateStackRefactorCommand,
|
|
CreateStackSetCommand,
|
|
DeactivateOrganizationsAccessCommand,
|
|
DeactivateTypeCommand,
|
|
DeleteChangeSetCommand,
|
|
DeleteGeneratedTemplateCommand,
|
|
DeleteStackCommand,
|
|
DeleteStackInstancesCommand,
|
|
DeleteStackSetCommand,
|
|
DeregisterTypeCommand,
|
|
DescribeAccountLimitsCommand,
|
|
DescribeChangeSetCommand,
|
|
DescribeChangeSetHooksCommand,
|
|
DescribeEventsCommand,
|
|
DescribeGeneratedTemplateCommand,
|
|
DescribeOrganizationsAccessCommand,
|
|
DescribePublisherCommand,
|
|
DescribeResourceScanCommand,
|
|
DescribeStackDriftDetectionStatusCommand,
|
|
DescribeStackEventsCommand,
|
|
DescribeStackInstanceCommand,
|
|
DescribeStackRefactorCommand,
|
|
DescribeStackResourceCommand,
|
|
DescribeStackResourceDriftsCommand,
|
|
DescribeStackResourcesCommand,
|
|
DescribeStacksCommand,
|
|
DescribeStackSetCommand,
|
|
DescribeStackSetOperationCommand,
|
|
DescribeTypeCommand,
|
|
DescribeTypeRegistrationCommand,
|
|
DetectStackDriftCommand,
|
|
DetectStackResourceDriftCommand,
|
|
DetectStackSetDriftCommand,
|
|
EstimateTemplateCostCommand,
|
|
ExecuteChangeSetCommand,
|
|
ExecuteStackRefactorCommand,
|
|
GetGeneratedTemplateCommand,
|
|
GetHookResultCommand,
|
|
GetStackPolicyCommand,
|
|
GetTemplateCommand,
|
|
GetTemplateSummaryCommand,
|
|
ImportStacksToStackSetCommand,
|
|
ListChangeSetsCommand,
|
|
ListExportsCommand,
|
|
ListGeneratedTemplatesCommand,
|
|
ListHookResultsCommand,
|
|
ListImportsCommand,
|
|
ListResourceScanRelatedResourcesCommand,
|
|
ListResourceScanResourcesCommand,
|
|
ListResourceScansCommand,
|
|
ListStackInstanceResourceDriftsCommand,
|
|
ListStackInstancesCommand,
|
|
ListStackRefactorActionsCommand,
|
|
ListStackRefactorsCommand,
|
|
ListStackResourcesCommand,
|
|
ListStacksCommand,
|
|
ListStackSetAutoDeploymentTargetsCommand,
|
|
ListStackSetOperationResultsCommand,
|
|
ListStackSetOperationsCommand,
|
|
ListStackSetsCommand,
|
|
ListTypeRegistrationsCommand,
|
|
ListTypesCommand,
|
|
ListTypeVersionsCommand,
|
|
PublishTypeCommand,
|
|
RecordHandlerProgressCommand,
|
|
RegisterPublisherCommand,
|
|
RegisterTypeCommand,
|
|
RollbackStackCommand,
|
|
SetStackPolicyCommand,
|
|
SetTypeConfigurationCommand,
|
|
SetTypeDefaultVersionCommand,
|
|
SignalResourceCommand,
|
|
StartResourceScanCommand,
|
|
StopStackSetOperationCommand,
|
|
TestTypeCommand,
|
|
UpdateGeneratedTemplateCommand,
|
|
UpdateStackCommand,
|
|
UpdateStackInstancesCommand,
|
|
UpdateStackSetCommand,
|
|
UpdateTerminationProtectionCommand,
|
|
ValidateTemplateCommand,
|
|
};
|
|
const paginators = {
|
|
paginateDescribeAccountLimits,
|
|
paginateDescribeChangeSet,
|
|
paginateDescribeEvents,
|
|
paginateDescribeStackEvents,
|
|
paginateDescribeStackResourceDrifts,
|
|
paginateDescribeStacks,
|
|
paginateListChangeSets,
|
|
paginateListExports,
|
|
paginateListGeneratedTemplates,
|
|
paginateListImports,
|
|
paginateListResourceScanRelatedResources,
|
|
paginateListResourceScanResources,
|
|
paginateListResourceScans,
|
|
paginateListStackInstances,
|
|
paginateListStackRefactorActions,
|
|
paginateListStackRefactors,
|
|
paginateListStackResources,
|
|
paginateListStacks,
|
|
paginateListStackSetOperationResults,
|
|
paginateListStackSetOperations,
|
|
paginateListStackSets,
|
|
paginateListTypeRegistrations,
|
|
paginateListTypes,
|
|
paginateListTypeVersions,
|
|
};
|
|
const waiters = {
|
|
waitUntilChangeSetCreateComplete,
|
|
waitUntilStackRefactorCreateComplete,
|
|
waitUntilStackRefactorExecuteComplete,
|
|
waitUntilStackCreateComplete,
|
|
waitUntilStackDeleteComplete,
|
|
waitUntilStackExists,
|
|
waitUntilStackImportComplete,
|
|
waitUntilStackRollbackComplete,
|
|
waitUntilStackUpdateComplete,
|
|
waitUntilTypeRegistrationComplete,
|
|
};
|
|
class CloudFormation extends CloudFormationClient {
|
|
}
|
|
client.createAggregatedClient(commands, CloudFormation, { paginators, waiters });
|
|
|
|
const AccountFilterType = {
|
|
DIFFERENCE: "DIFFERENCE",
|
|
INTERSECTION: "INTERSECTION",
|
|
NONE: "NONE",
|
|
UNION: "UNION",
|
|
};
|
|
const AccountGateStatus = {
|
|
FAILED: "FAILED",
|
|
SKIPPED: "SKIPPED",
|
|
SUCCEEDED: "SUCCEEDED",
|
|
};
|
|
const ThirdPartyType = {
|
|
HOOK: "HOOK",
|
|
MODULE: "MODULE",
|
|
RESOURCE: "RESOURCE",
|
|
};
|
|
const VersionBump = {
|
|
MAJOR: "MAJOR",
|
|
MINOR: "MINOR",
|
|
};
|
|
const AfterValueFrom = {
|
|
TEMPLATE: "TEMPLATE",
|
|
};
|
|
const AnnotationSeverityLevel = {
|
|
CRITICAL: "CRITICAL",
|
|
HIGH: "HIGH",
|
|
INFORMATIONAL: "INFORMATIONAL",
|
|
LOW: "LOW",
|
|
MEDIUM: "MEDIUM",
|
|
};
|
|
const AnnotationStatus = {
|
|
FAILED: "FAILED",
|
|
PASSED: "PASSED",
|
|
SKIPPED: "SKIPPED",
|
|
};
|
|
const AttributeChangeType = {
|
|
Add: "Add",
|
|
Modify: "Modify",
|
|
Remove: "Remove",
|
|
SyncWithActual: "SyncWithActual",
|
|
};
|
|
const BeaconStackOperationStatus = {
|
|
FAILED: "FAILED",
|
|
IN_PROGRESS: "IN_PROGRESS",
|
|
SUCCEEDED: "SUCCEEDED",
|
|
};
|
|
const BeforeValueFrom = {
|
|
ACTUAL_STATE: "ACTUAL_STATE",
|
|
PREVIOUS_DEPLOYMENT_STATE: "PREVIOUS_DEPLOYMENT_STATE",
|
|
};
|
|
const CallAs = {
|
|
DELEGATED_ADMIN: "DELEGATED_ADMIN",
|
|
SELF: "SELF",
|
|
};
|
|
const Capability = {
|
|
CAPABILITY_AUTO_EXPAND: "CAPABILITY_AUTO_EXPAND",
|
|
CAPABILITY_IAM: "CAPABILITY_IAM",
|
|
CAPABILITY_NAMED_IAM: "CAPABILITY_NAMED_IAM",
|
|
};
|
|
const Category = {
|
|
ACTIVATED: "ACTIVATED",
|
|
AWS_TYPES: "AWS_TYPES",
|
|
REGISTERED: "REGISTERED",
|
|
THIRD_PARTY: "THIRD_PARTY",
|
|
};
|
|
const ChangeAction = {
|
|
Add: "Add",
|
|
Dynamic: "Dynamic",
|
|
Import: "Import",
|
|
Modify: "Modify",
|
|
Remove: "Remove",
|
|
SyncWithActual: "SyncWithActual",
|
|
};
|
|
const ChangeSource = {
|
|
Automatic: "Automatic",
|
|
DirectModification: "DirectModification",
|
|
NoModification: "NoModification",
|
|
ParameterReference: "ParameterReference",
|
|
ResourceAttribute: "ResourceAttribute",
|
|
ResourceReference: "ResourceReference",
|
|
};
|
|
const EvaluationType = {
|
|
Dynamic: "Dynamic",
|
|
Static: "Static",
|
|
};
|
|
const ResourceAttribute = {
|
|
CreationPolicy: "CreationPolicy",
|
|
DeletionPolicy: "DeletionPolicy",
|
|
Metadata: "Metadata",
|
|
Properties: "Properties",
|
|
Tags: "Tags",
|
|
UpdatePolicy: "UpdatePolicy",
|
|
UpdateReplacePolicy: "UpdateReplacePolicy",
|
|
};
|
|
const RequiresRecreation = {
|
|
Always: "Always",
|
|
Conditionally: "Conditionally",
|
|
Never: "Never",
|
|
};
|
|
const PolicyAction = {
|
|
Delete: "Delete",
|
|
ReplaceAndDelete: "ReplaceAndDelete",
|
|
ReplaceAndRetain: "ReplaceAndRetain",
|
|
ReplaceAndSnapshot: "ReplaceAndSnapshot",
|
|
Retain: "Retain",
|
|
Snapshot: "Snapshot",
|
|
};
|
|
const Replacement = {
|
|
Conditional: "Conditional",
|
|
False: "False",
|
|
True: "True",
|
|
};
|
|
const DriftIgnoredReason = {
|
|
MANAGED_BY_AWS: "MANAGED_BY_AWS",
|
|
WRITE_ONLY_PROPERTY: "WRITE_ONLY_PROPERTY",
|
|
};
|
|
const StackResourceDriftStatus = {
|
|
DELETED: "DELETED",
|
|
IN_SYNC: "IN_SYNC",
|
|
MODIFIED: "MODIFIED",
|
|
NOT_CHECKED: "NOT_CHECKED",
|
|
UNKNOWN: "UNKNOWN",
|
|
UNSUPPORTED: "UNSUPPORTED",
|
|
};
|
|
const ChangeType = {
|
|
Resource: "Resource",
|
|
};
|
|
const HookFailureMode = {
|
|
FAIL: "FAIL",
|
|
WARN: "WARN",
|
|
};
|
|
const HookInvocationPoint = {
|
|
PRE_PROVISION: "PRE_PROVISION",
|
|
};
|
|
const HookTargetType = {
|
|
RESOURCE: "RESOURCE",
|
|
};
|
|
const ChangeSetHooksStatus = {
|
|
PLANNED: "PLANNED",
|
|
PLANNING: "PLANNING",
|
|
UNAVAILABLE: "UNAVAILABLE",
|
|
};
|
|
const ChangeSetStatus = {
|
|
CREATE_COMPLETE: "CREATE_COMPLETE",
|
|
CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
|
|
CREATE_PENDING: "CREATE_PENDING",
|
|
DELETE_COMPLETE: "DELETE_COMPLETE",
|
|
DELETE_FAILED: "DELETE_FAILED",
|
|
DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
|
|
DELETE_PENDING: "DELETE_PENDING",
|
|
FAILED: "FAILED",
|
|
};
|
|
const ExecutionStatus = {
|
|
AVAILABLE: "AVAILABLE",
|
|
EXECUTE_COMPLETE: "EXECUTE_COMPLETE",
|
|
EXECUTE_FAILED: "EXECUTE_FAILED",
|
|
EXECUTE_IN_PROGRESS: "EXECUTE_IN_PROGRESS",
|
|
OBSOLETE: "OBSOLETE",
|
|
UNAVAILABLE: "UNAVAILABLE",
|
|
};
|
|
const ChangeSetType = {
|
|
CREATE: "CREATE",
|
|
IMPORT: "IMPORT",
|
|
UPDATE: "UPDATE",
|
|
};
|
|
const DeploymentMode = {
|
|
REVERT_DRIFT: "REVERT_DRIFT",
|
|
};
|
|
const OnStackFailure = {
|
|
DELETE: "DELETE",
|
|
DO_NOTHING: "DO_NOTHING",
|
|
ROLLBACK: "ROLLBACK",
|
|
};
|
|
const GeneratedTemplateDeletionPolicy = {
|
|
DELETE: "DELETE",
|
|
RETAIN: "RETAIN",
|
|
};
|
|
const GeneratedTemplateUpdateReplacePolicy = {
|
|
DELETE: "DELETE",
|
|
RETAIN: "RETAIN",
|
|
};
|
|
const OnFailure = {
|
|
DELETE: "DELETE",
|
|
DO_NOTHING: "DO_NOTHING",
|
|
ROLLBACK: "ROLLBACK",
|
|
};
|
|
const ConcurrencyMode = {
|
|
SOFT_FAILURE_TOLERANCE: "SOFT_FAILURE_TOLERANCE",
|
|
STRICT_FAILURE_TOLERANCE: "STRICT_FAILURE_TOLERANCE",
|
|
};
|
|
const RegionConcurrencyType = {
|
|
PARALLEL: "PARALLEL",
|
|
SEQUENTIAL: "SEQUENTIAL",
|
|
};
|
|
const PermissionModels = {
|
|
SELF_MANAGED: "SELF_MANAGED",
|
|
SERVICE_MANAGED: "SERVICE_MANAGED",
|
|
};
|
|
const DeletionMode = {
|
|
FORCE_DELETE_STACK: "FORCE_DELETE_STACK",
|
|
STANDARD: "STANDARD",
|
|
};
|
|
const RegistryType = {
|
|
HOOK: "HOOK",
|
|
MODULE: "MODULE",
|
|
RESOURCE: "RESOURCE",
|
|
};
|
|
const StackDriftStatus = {
|
|
DRIFTED: "DRIFTED",
|
|
IN_SYNC: "IN_SYNC",
|
|
NOT_CHECKED: "NOT_CHECKED",
|
|
UNKNOWN: "UNKNOWN",
|
|
};
|
|
const DetailedStatus = {
|
|
CONFIGURATION_COMPLETE: "CONFIGURATION_COMPLETE",
|
|
VALIDATION_FAILED: "VALIDATION_FAILED",
|
|
};
|
|
const EventType = {
|
|
HOOK_INVOCATION_ERROR: "HOOK_INVOCATION_ERROR",
|
|
PROGRESS_EVENT: "PROGRESS_EVENT",
|
|
PROVISIONING_ERROR: "PROVISIONING_ERROR",
|
|
STACK_EVENT: "STACK_EVENT",
|
|
VALIDATION_ERROR: "VALIDATION_ERROR",
|
|
};
|
|
const HookStatus = {
|
|
HOOK_COMPLETE_FAILED: "HOOK_COMPLETE_FAILED",
|
|
HOOK_COMPLETE_SUCCEEDED: "HOOK_COMPLETE_SUCCEEDED",
|
|
HOOK_FAILED: "HOOK_FAILED",
|
|
HOOK_IN_PROGRESS: "HOOK_IN_PROGRESS",
|
|
};
|
|
const OperationType = {
|
|
CONTINUE_ROLLBACK: "CONTINUE_ROLLBACK",
|
|
CREATE_CHANGESET: "CREATE_CHANGESET",
|
|
CREATE_STACK: "CREATE_STACK",
|
|
DELETE_STACK: "DELETE_STACK",
|
|
ROLLBACK: "ROLLBACK",
|
|
UPDATE_STACK: "UPDATE_STACK",
|
|
};
|
|
const ResourceStatus = {
|
|
CREATE_COMPLETE: "CREATE_COMPLETE",
|
|
CREATE_FAILED: "CREATE_FAILED",
|
|
CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
|
|
DELETE_COMPLETE: "DELETE_COMPLETE",
|
|
DELETE_FAILED: "DELETE_FAILED",
|
|
DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
|
|
DELETE_SKIPPED: "DELETE_SKIPPED",
|
|
EXPORT_COMPLETE: "EXPORT_COMPLETE",
|
|
EXPORT_FAILED: "EXPORT_FAILED",
|
|
EXPORT_IN_PROGRESS: "EXPORT_IN_PROGRESS",
|
|
EXPORT_ROLLBACK_COMPLETE: "EXPORT_ROLLBACK_COMPLETE",
|
|
EXPORT_ROLLBACK_FAILED: "EXPORT_ROLLBACK_FAILED",
|
|
EXPORT_ROLLBACK_IN_PROGRESS: "EXPORT_ROLLBACK_IN_PROGRESS",
|
|
IMPORT_COMPLETE: "IMPORT_COMPLETE",
|
|
IMPORT_FAILED: "IMPORT_FAILED",
|
|
IMPORT_IN_PROGRESS: "IMPORT_IN_PROGRESS",
|
|
IMPORT_ROLLBACK_COMPLETE: "IMPORT_ROLLBACK_COMPLETE",
|
|
IMPORT_ROLLBACK_FAILED: "IMPORT_ROLLBACK_FAILED",
|
|
IMPORT_ROLLBACK_IN_PROGRESS: "IMPORT_ROLLBACK_IN_PROGRESS",
|
|
ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE",
|
|
ROLLBACK_FAILED: "ROLLBACK_FAILED",
|
|
ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",
|
|
UPDATE_COMPLETE: "UPDATE_COMPLETE",
|
|
UPDATE_FAILED: "UPDATE_FAILED",
|
|
UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
|
|
UPDATE_ROLLBACK_COMPLETE: "UPDATE_ROLLBACK_COMPLETE",
|
|
UPDATE_ROLLBACK_FAILED: "UPDATE_ROLLBACK_FAILED",
|
|
UPDATE_ROLLBACK_IN_PROGRESS: "UPDATE_ROLLBACK_IN_PROGRESS",
|
|
};
|
|
const ValidationStatus = {
|
|
FAILED: "FAILED",
|
|
SKIPPED: "SKIPPED",
|
|
};
|
|
const GeneratedTemplateResourceStatus = {
|
|
COMPLETE: "COMPLETE",
|
|
FAILED: "FAILED",
|
|
IN_PROGRESS: "IN_PROGRESS",
|
|
PENDING: "PENDING",
|
|
};
|
|
const WarningType = {
|
|
EXCLUDED_PROPERTIES: "EXCLUDED_PROPERTIES",
|
|
EXCLUDED_RESOURCES: "EXCLUDED_RESOURCES",
|
|
MUTUALLY_EXCLUSIVE_PROPERTIES: "MUTUALLY_EXCLUSIVE_PROPERTIES",
|
|
MUTUALLY_EXCLUSIVE_TYPES: "MUTUALLY_EXCLUSIVE_TYPES",
|
|
UNSUPPORTED_PROPERTIES: "UNSUPPORTED_PROPERTIES",
|
|
};
|
|
const GeneratedTemplateStatus = {
|
|
COMPLETE: "COMPLETE",
|
|
CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
|
|
CREATE_PENDING: "CREATE_PENDING",
|
|
DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
|
|
DELETE_PENDING: "DELETE_PENDING",
|
|
FAILED: "FAILED",
|
|
UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
|
|
UPDATE_PENDING: "UPDATE_PENDING",
|
|
};
|
|
const OrganizationStatus = {
|
|
DISABLED: "DISABLED",
|
|
DISABLED_PERMANENTLY: "DISABLED_PERMANENTLY",
|
|
ENABLED: "ENABLED",
|
|
};
|
|
const IdentityProvider = {
|
|
AWS_Marketplace: "AWS_Marketplace",
|
|
Bitbucket: "Bitbucket",
|
|
GitHub: "GitHub",
|
|
};
|
|
const PublisherStatus = {
|
|
UNVERIFIED: "UNVERIFIED",
|
|
VERIFIED: "VERIFIED",
|
|
};
|
|
const ResourceScanStatus = {
|
|
COMPLETE: "COMPLETE",
|
|
EXPIRED: "EXPIRED",
|
|
FAILED: "FAILED",
|
|
IN_PROGRESS: "IN_PROGRESS",
|
|
};
|
|
const StackDriftDetectionStatus = {
|
|
DETECTION_COMPLETE: "DETECTION_COMPLETE",
|
|
DETECTION_FAILED: "DETECTION_FAILED",
|
|
DETECTION_IN_PROGRESS: "DETECTION_IN_PROGRESS",
|
|
};
|
|
const StackInstanceDetailedStatus = {
|
|
CANCELLED: "CANCELLED",
|
|
FAILED: "FAILED",
|
|
FAILED_IMPORT: "FAILED_IMPORT",
|
|
INOPERABLE: "INOPERABLE",
|
|
PENDING: "PENDING",
|
|
RUNNING: "RUNNING",
|
|
SKIPPED_SUSPENDED_ACCOUNT: "SKIPPED_SUSPENDED_ACCOUNT",
|
|
SUCCEEDED: "SUCCEEDED",
|
|
};
|
|
const StackInstanceStatus = {
|
|
CURRENT: "CURRENT",
|
|
INOPERABLE: "INOPERABLE",
|
|
OUTDATED: "OUTDATED",
|
|
};
|
|
const StackRefactorExecutionStatus = {
|
|
AVAILABLE: "AVAILABLE",
|
|
EXECUTE_COMPLETE: "EXECUTE_COMPLETE",
|
|
EXECUTE_FAILED: "EXECUTE_FAILED",
|
|
EXECUTE_IN_PROGRESS: "EXECUTE_IN_PROGRESS",
|
|
OBSOLETE: "OBSOLETE",
|
|
ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE",
|
|
ROLLBACK_FAILED: "ROLLBACK_FAILED",
|
|
ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",
|
|
UNAVAILABLE: "UNAVAILABLE",
|
|
};
|
|
const StackRefactorStatus = {
|
|
CREATE_COMPLETE: "CREATE_COMPLETE",
|
|
CREATE_FAILED: "CREATE_FAILED",
|
|
CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
|
|
DELETE_COMPLETE: "DELETE_COMPLETE",
|
|
DELETE_FAILED: "DELETE_FAILED",
|
|
DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
|
|
};
|
|
const DifferenceType = {
|
|
ADD: "ADD",
|
|
NOT_EQUAL: "NOT_EQUAL",
|
|
REMOVE: "REMOVE",
|
|
};
|
|
const StackStatus = {
|
|
CREATE_COMPLETE: "CREATE_COMPLETE",
|
|
CREATE_FAILED: "CREATE_FAILED",
|
|
CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
|
|
DELETE_COMPLETE: "DELETE_COMPLETE",
|
|
DELETE_FAILED: "DELETE_FAILED",
|
|
DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
|
|
IMPORT_COMPLETE: "IMPORT_COMPLETE",
|
|
IMPORT_IN_PROGRESS: "IMPORT_IN_PROGRESS",
|
|
IMPORT_ROLLBACK_COMPLETE: "IMPORT_ROLLBACK_COMPLETE",
|
|
IMPORT_ROLLBACK_FAILED: "IMPORT_ROLLBACK_FAILED",
|
|
IMPORT_ROLLBACK_IN_PROGRESS: "IMPORT_ROLLBACK_IN_PROGRESS",
|
|
REVIEW_IN_PROGRESS: "REVIEW_IN_PROGRESS",
|
|
ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE",
|
|
ROLLBACK_FAILED: "ROLLBACK_FAILED",
|
|
ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",
|
|
UPDATE_COMPLETE: "UPDATE_COMPLETE",
|
|
UPDATE_COMPLETE_CLEANUP_IN_PROGRESS: "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS",
|
|
UPDATE_FAILED: "UPDATE_FAILED",
|
|
UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
|
|
UPDATE_ROLLBACK_COMPLETE: "UPDATE_ROLLBACK_COMPLETE",
|
|
UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS: "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
|
|
UPDATE_ROLLBACK_FAILED: "UPDATE_ROLLBACK_FAILED",
|
|
UPDATE_ROLLBACK_IN_PROGRESS: "UPDATE_ROLLBACK_IN_PROGRESS",
|
|
};
|
|
const StackSetDriftDetectionStatus = {
|
|
COMPLETED: "COMPLETED",
|
|
FAILED: "FAILED",
|
|
IN_PROGRESS: "IN_PROGRESS",
|
|
PARTIAL_SUCCESS: "PARTIAL_SUCCESS",
|
|
STOPPED: "STOPPED",
|
|
};
|
|
const StackSetDriftStatus = {
|
|
DRIFTED: "DRIFTED",
|
|
IN_SYNC: "IN_SYNC",
|
|
NOT_CHECKED: "NOT_CHECKED",
|
|
};
|
|
const StackSetStatus = {
|
|
ACTIVE: "ACTIVE",
|
|
DELETED: "DELETED",
|
|
};
|
|
const StackSetOperationAction = {
|
|
CREATE: "CREATE",
|
|
DELETE: "DELETE",
|
|
DETECT_DRIFT: "DETECT_DRIFT",
|
|
UPDATE: "UPDATE",
|
|
};
|
|
const StackSetOperationStatus = {
|
|
FAILED: "FAILED",
|
|
QUEUED: "QUEUED",
|
|
RUNNING: "RUNNING",
|
|
STOPPED: "STOPPED",
|
|
STOPPING: "STOPPING",
|
|
SUCCEEDED: "SUCCEEDED",
|
|
};
|
|
const DeprecatedStatus = {
|
|
DEPRECATED: "DEPRECATED",
|
|
LIVE: "LIVE",
|
|
};
|
|
const ProvisioningType = {
|
|
FULLY_MUTABLE: "FULLY_MUTABLE",
|
|
IMMUTABLE: "IMMUTABLE",
|
|
NON_PROVISIONABLE: "NON_PROVISIONABLE",
|
|
};
|
|
const TypeTestsStatus = {
|
|
FAILED: "FAILED",
|
|
IN_PROGRESS: "IN_PROGRESS",
|
|
NOT_TESTED: "NOT_TESTED",
|
|
PASSED: "PASSED",
|
|
};
|
|
const Visibility = {
|
|
PRIVATE: "PRIVATE",
|
|
PUBLIC: "PUBLIC",
|
|
};
|
|
const RegistrationStatus = {
|
|
COMPLETE: "COMPLETE",
|
|
FAILED: "FAILED",
|
|
IN_PROGRESS: "IN_PROGRESS",
|
|
};
|
|
const TemplateFormat = {
|
|
JSON: "JSON",
|
|
YAML: "YAML",
|
|
};
|
|
const HookTargetAction = {
|
|
CREATE: "CREATE",
|
|
DELETE: "DELETE",
|
|
IMPORT: "IMPORT",
|
|
UPDATE: "UPDATE",
|
|
};
|
|
const TemplateStage = {
|
|
Original: "Original",
|
|
Processed: "Processed",
|
|
};
|
|
const ListHookResultsTargetType = {
|
|
CHANGE_SET: "CHANGE_SET",
|
|
CLOUD_CONTROL: "CLOUD_CONTROL",
|
|
RESOURCE: "RESOURCE",
|
|
STACK: "STACK",
|
|
};
|
|
const ScanType = {
|
|
FULL: "FULL",
|
|
PARTIAL: "PARTIAL",
|
|
};
|
|
const StackInstanceFilterName = {
|
|
DETAILED_STATUS: "DETAILED_STATUS",
|
|
DRIFT_STATUS: "DRIFT_STATUS",
|
|
LAST_OPERATION_ID: "LAST_OPERATION_ID",
|
|
};
|
|
const StackRefactorActionType = {
|
|
CREATE: "CREATE",
|
|
MOVE: "MOVE",
|
|
};
|
|
const StackRefactorDetection = {
|
|
AUTO: "AUTO",
|
|
MANUAL: "MANUAL",
|
|
};
|
|
const StackRefactorActionEntity = {
|
|
RESOURCE: "RESOURCE",
|
|
STACK: "STACK",
|
|
};
|
|
const OperationResultFilterName = {
|
|
OPERATION_RESULT_STATUS: "OPERATION_RESULT_STATUS",
|
|
};
|
|
const StackSetOperationResultStatus = {
|
|
CANCELLED: "CANCELLED",
|
|
FAILED: "FAILED",
|
|
PENDING: "PENDING",
|
|
RUNNING: "RUNNING",
|
|
SUCCEEDED: "SUCCEEDED",
|
|
};
|
|
const OperationStatus = {
|
|
FAILED: "FAILED",
|
|
IN_PROGRESS: "IN_PROGRESS",
|
|
PENDING: "PENDING",
|
|
SUCCESS: "SUCCESS",
|
|
};
|
|
const HandlerErrorCode = {
|
|
AccessDenied: "AccessDenied",
|
|
AlreadyExists: "AlreadyExists",
|
|
GeneralServiceException: "GeneralServiceException",
|
|
HandlerInternalFailure: "HandlerInternalFailure",
|
|
InternalFailure: "InternalFailure",
|
|
InvalidCredentials: "InvalidCredentials",
|
|
InvalidRequest: "InvalidRequest",
|
|
InvalidTypeConfiguration: "InvalidTypeConfiguration",
|
|
NetworkFailure: "NetworkFailure",
|
|
NonCompliant: "NonCompliant",
|
|
NotFound: "NotFound",
|
|
NotUpdatable: "NotUpdatable",
|
|
ResourceConflict: "ResourceConflict",
|
|
ServiceInternalError: "ServiceInternalError",
|
|
ServiceLimitExceeded: "ServiceLimitExceeded",
|
|
ServiceTimeout: "NotStabilized",
|
|
Throttling: "Throttling",
|
|
Unknown: "Unknown",
|
|
UnsupportedTarget: "UnsupportedTarget",
|
|
};
|
|
const ResourceSignalStatus = {
|
|
FAILURE: "FAILURE",
|
|
SUCCESS: "SUCCESS",
|
|
};
|
|
|
|
exports.$Command = client.Command;
|
|
exports.__Client = client.Client;
|
|
exports.CloudFormationServiceException = CloudFormationServiceException.CloudFormationServiceException;
|
|
exports.AccountFilterType = AccountFilterType;
|
|
exports.AccountGateStatus = AccountGateStatus;
|
|
exports.ActivateOrganizationsAccessCommand = ActivateOrganizationsAccessCommand;
|
|
exports.ActivateTypeCommand = ActivateTypeCommand;
|
|
exports.AfterValueFrom = AfterValueFrom;
|
|
exports.AnnotationSeverityLevel = AnnotationSeverityLevel;
|
|
exports.AnnotationStatus = AnnotationStatus;
|
|
exports.AttributeChangeType = AttributeChangeType;
|
|
exports.BatchDescribeTypeConfigurationsCommand = BatchDescribeTypeConfigurationsCommand;
|
|
exports.BeaconStackOperationStatus = BeaconStackOperationStatus;
|
|
exports.BeforeValueFrom = BeforeValueFrom;
|
|
exports.CallAs = CallAs;
|
|
exports.CancelUpdateStackCommand = CancelUpdateStackCommand;
|
|
exports.Capability = Capability;
|
|
exports.Category = Category;
|
|
exports.ChangeAction = ChangeAction;
|
|
exports.ChangeSetHooksStatus = ChangeSetHooksStatus;
|
|
exports.ChangeSetStatus = ChangeSetStatus;
|
|
exports.ChangeSetType = ChangeSetType;
|
|
exports.ChangeSource = ChangeSource;
|
|
exports.ChangeType = ChangeType;
|
|
exports.CloudFormation = CloudFormation;
|
|
exports.CloudFormationClient = CloudFormationClient;
|
|
exports.ConcurrencyMode = ConcurrencyMode;
|
|
exports.ContinueUpdateRollbackCommand = ContinueUpdateRollbackCommand;
|
|
exports.CreateChangeSetCommand = CreateChangeSetCommand;
|
|
exports.CreateGeneratedTemplateCommand = CreateGeneratedTemplateCommand;
|
|
exports.CreateStackCommand = CreateStackCommand;
|
|
exports.CreateStackInstancesCommand = CreateStackInstancesCommand;
|
|
exports.CreateStackRefactorCommand = CreateStackRefactorCommand;
|
|
exports.CreateStackSetCommand = CreateStackSetCommand;
|
|
exports.DeactivateOrganizationsAccessCommand = DeactivateOrganizationsAccessCommand;
|
|
exports.DeactivateTypeCommand = DeactivateTypeCommand;
|
|
exports.DeleteChangeSetCommand = DeleteChangeSetCommand;
|
|
exports.DeleteGeneratedTemplateCommand = DeleteGeneratedTemplateCommand;
|
|
exports.DeleteStackCommand = DeleteStackCommand;
|
|
exports.DeleteStackInstancesCommand = DeleteStackInstancesCommand;
|
|
exports.DeleteStackSetCommand = DeleteStackSetCommand;
|
|
exports.DeletionMode = DeletionMode;
|
|
exports.DeploymentMode = DeploymentMode;
|
|
exports.DeprecatedStatus = DeprecatedStatus;
|
|
exports.DeregisterTypeCommand = DeregisterTypeCommand;
|
|
exports.DescribeAccountLimitsCommand = DescribeAccountLimitsCommand;
|
|
exports.DescribeChangeSetCommand = DescribeChangeSetCommand;
|
|
exports.DescribeChangeSetHooksCommand = DescribeChangeSetHooksCommand;
|
|
exports.DescribeEventsCommand = DescribeEventsCommand;
|
|
exports.DescribeGeneratedTemplateCommand = DescribeGeneratedTemplateCommand;
|
|
exports.DescribeOrganizationsAccessCommand = DescribeOrganizationsAccessCommand;
|
|
exports.DescribePublisherCommand = DescribePublisherCommand;
|
|
exports.DescribeResourceScanCommand = DescribeResourceScanCommand;
|
|
exports.DescribeStackDriftDetectionStatusCommand = DescribeStackDriftDetectionStatusCommand;
|
|
exports.DescribeStackEventsCommand = DescribeStackEventsCommand;
|
|
exports.DescribeStackInstanceCommand = DescribeStackInstanceCommand;
|
|
exports.DescribeStackRefactorCommand = DescribeStackRefactorCommand;
|
|
exports.DescribeStackResourceCommand = DescribeStackResourceCommand;
|
|
exports.DescribeStackResourceDriftsCommand = DescribeStackResourceDriftsCommand;
|
|
exports.DescribeStackResourcesCommand = DescribeStackResourcesCommand;
|
|
exports.DescribeStackSetCommand = DescribeStackSetCommand;
|
|
exports.DescribeStackSetOperationCommand = DescribeStackSetOperationCommand;
|
|
exports.DescribeStacksCommand = DescribeStacksCommand;
|
|
exports.DescribeTypeCommand = DescribeTypeCommand;
|
|
exports.DescribeTypeRegistrationCommand = DescribeTypeRegistrationCommand;
|
|
exports.DetailedStatus = DetailedStatus;
|
|
exports.DetectStackDriftCommand = DetectStackDriftCommand;
|
|
exports.DetectStackResourceDriftCommand = DetectStackResourceDriftCommand;
|
|
exports.DetectStackSetDriftCommand = DetectStackSetDriftCommand;
|
|
exports.DifferenceType = DifferenceType;
|
|
exports.DriftIgnoredReason = DriftIgnoredReason;
|
|
exports.EstimateTemplateCostCommand = EstimateTemplateCostCommand;
|
|
exports.EvaluationType = EvaluationType;
|
|
exports.EventType = EventType;
|
|
exports.ExecuteChangeSetCommand = ExecuteChangeSetCommand;
|
|
exports.ExecuteStackRefactorCommand = ExecuteStackRefactorCommand;
|
|
exports.ExecutionStatus = ExecutionStatus;
|
|
exports.GeneratedTemplateDeletionPolicy = GeneratedTemplateDeletionPolicy;
|
|
exports.GeneratedTemplateResourceStatus = GeneratedTemplateResourceStatus;
|
|
exports.GeneratedTemplateStatus = GeneratedTemplateStatus;
|
|
exports.GeneratedTemplateUpdateReplacePolicy = GeneratedTemplateUpdateReplacePolicy;
|
|
exports.GetGeneratedTemplateCommand = GetGeneratedTemplateCommand;
|
|
exports.GetHookResultCommand = GetHookResultCommand;
|
|
exports.GetStackPolicyCommand = GetStackPolicyCommand;
|
|
exports.GetTemplateCommand = GetTemplateCommand;
|
|
exports.GetTemplateSummaryCommand = GetTemplateSummaryCommand;
|
|
exports.HandlerErrorCode = HandlerErrorCode;
|
|
exports.HookFailureMode = HookFailureMode;
|
|
exports.HookInvocationPoint = HookInvocationPoint;
|
|
exports.HookStatus = HookStatus;
|
|
exports.HookTargetAction = HookTargetAction;
|
|
exports.HookTargetType = HookTargetType;
|
|
exports.IdentityProvider = IdentityProvider;
|
|
exports.ImportStacksToStackSetCommand = ImportStacksToStackSetCommand;
|
|
exports.ListChangeSetsCommand = ListChangeSetsCommand;
|
|
exports.ListExportsCommand = ListExportsCommand;
|
|
exports.ListGeneratedTemplatesCommand = ListGeneratedTemplatesCommand;
|
|
exports.ListHookResultsCommand = ListHookResultsCommand;
|
|
exports.ListHookResultsTargetType = ListHookResultsTargetType;
|
|
exports.ListImportsCommand = ListImportsCommand;
|
|
exports.ListResourceScanRelatedResourcesCommand = ListResourceScanRelatedResourcesCommand;
|
|
exports.ListResourceScanResourcesCommand = ListResourceScanResourcesCommand;
|
|
exports.ListResourceScansCommand = ListResourceScansCommand;
|
|
exports.ListStackInstanceResourceDriftsCommand = ListStackInstanceResourceDriftsCommand;
|
|
exports.ListStackInstancesCommand = ListStackInstancesCommand;
|
|
exports.ListStackRefactorActionsCommand = ListStackRefactorActionsCommand;
|
|
exports.ListStackRefactorsCommand = ListStackRefactorsCommand;
|
|
exports.ListStackResourcesCommand = ListStackResourcesCommand;
|
|
exports.ListStackSetAutoDeploymentTargetsCommand = ListStackSetAutoDeploymentTargetsCommand;
|
|
exports.ListStackSetOperationResultsCommand = ListStackSetOperationResultsCommand;
|
|
exports.ListStackSetOperationsCommand = ListStackSetOperationsCommand;
|
|
exports.ListStackSetsCommand = ListStackSetsCommand;
|
|
exports.ListStacksCommand = ListStacksCommand;
|
|
exports.ListTypeRegistrationsCommand = ListTypeRegistrationsCommand;
|
|
exports.ListTypeVersionsCommand = ListTypeVersionsCommand;
|
|
exports.ListTypesCommand = ListTypesCommand;
|
|
exports.OnFailure = OnFailure;
|
|
exports.OnStackFailure = OnStackFailure;
|
|
exports.OperationResultFilterName = OperationResultFilterName;
|
|
exports.OperationStatus = OperationStatus;
|
|
exports.OperationType = OperationType;
|
|
exports.OrganizationStatus = OrganizationStatus;
|
|
exports.PermissionModels = PermissionModels;
|
|
exports.PolicyAction = PolicyAction;
|
|
exports.ProvisioningType = ProvisioningType;
|
|
exports.PublishTypeCommand = PublishTypeCommand;
|
|
exports.PublisherStatus = PublisherStatus;
|
|
exports.RecordHandlerProgressCommand = RecordHandlerProgressCommand;
|
|
exports.RegionConcurrencyType = RegionConcurrencyType;
|
|
exports.RegisterPublisherCommand = RegisterPublisherCommand;
|
|
exports.RegisterTypeCommand = RegisterTypeCommand;
|
|
exports.RegistrationStatus = RegistrationStatus;
|
|
exports.RegistryType = RegistryType;
|
|
exports.Replacement = Replacement;
|
|
exports.RequiresRecreation = RequiresRecreation;
|
|
exports.ResourceAttribute = ResourceAttribute;
|
|
exports.ResourceScanStatus = ResourceScanStatus;
|
|
exports.ResourceSignalStatus = ResourceSignalStatus;
|
|
exports.ResourceStatus = ResourceStatus;
|
|
exports.RollbackStackCommand = RollbackStackCommand;
|
|
exports.ScanType = ScanType;
|
|
exports.SetStackPolicyCommand = SetStackPolicyCommand;
|
|
exports.SetTypeConfigurationCommand = SetTypeConfigurationCommand;
|
|
exports.SetTypeDefaultVersionCommand = SetTypeDefaultVersionCommand;
|
|
exports.SignalResourceCommand = SignalResourceCommand;
|
|
exports.StackDriftDetectionStatus = StackDriftDetectionStatus;
|
|
exports.StackDriftStatus = StackDriftStatus;
|
|
exports.StackInstanceDetailedStatus = StackInstanceDetailedStatus;
|
|
exports.StackInstanceFilterName = StackInstanceFilterName;
|
|
exports.StackInstanceStatus = StackInstanceStatus;
|
|
exports.StackRefactorActionEntity = StackRefactorActionEntity;
|
|
exports.StackRefactorActionType = StackRefactorActionType;
|
|
exports.StackRefactorDetection = StackRefactorDetection;
|
|
exports.StackRefactorExecutionStatus = StackRefactorExecutionStatus;
|
|
exports.StackRefactorStatus = StackRefactorStatus;
|
|
exports.StackResourceDriftStatus = StackResourceDriftStatus;
|
|
exports.StackSetDriftDetectionStatus = StackSetDriftDetectionStatus;
|
|
exports.StackSetDriftStatus = StackSetDriftStatus;
|
|
exports.StackSetOperationAction = StackSetOperationAction;
|
|
exports.StackSetOperationResultStatus = StackSetOperationResultStatus;
|
|
exports.StackSetOperationStatus = StackSetOperationStatus;
|
|
exports.StackSetStatus = StackSetStatus;
|
|
exports.StackStatus = StackStatus;
|
|
exports.StartResourceScanCommand = StartResourceScanCommand;
|
|
exports.StopStackSetOperationCommand = StopStackSetOperationCommand;
|
|
exports.TemplateFormat = TemplateFormat;
|
|
exports.TemplateStage = TemplateStage;
|
|
exports.TestTypeCommand = TestTypeCommand;
|
|
exports.ThirdPartyType = ThirdPartyType;
|
|
exports.TypeTestsStatus = TypeTestsStatus;
|
|
exports.UpdateGeneratedTemplateCommand = UpdateGeneratedTemplateCommand;
|
|
exports.UpdateStackCommand = UpdateStackCommand;
|
|
exports.UpdateStackInstancesCommand = UpdateStackInstancesCommand;
|
|
exports.UpdateStackSetCommand = UpdateStackSetCommand;
|
|
exports.UpdateTerminationProtectionCommand = UpdateTerminationProtectionCommand;
|
|
exports.ValidateTemplateCommand = ValidateTemplateCommand;
|
|
exports.ValidationStatus = ValidationStatus;
|
|
exports.VersionBump = VersionBump;
|
|
exports.Visibility = Visibility;
|
|
exports.WarningType = WarningType;
|
|
exports.paginateDescribeAccountLimits = paginateDescribeAccountLimits;
|
|
exports.paginateDescribeChangeSet = paginateDescribeChangeSet;
|
|
exports.paginateDescribeEvents = paginateDescribeEvents;
|
|
exports.paginateDescribeStackEvents = paginateDescribeStackEvents;
|
|
exports.paginateDescribeStackResourceDrifts = paginateDescribeStackResourceDrifts;
|
|
exports.paginateDescribeStacks = paginateDescribeStacks;
|
|
exports.paginateListChangeSets = paginateListChangeSets;
|
|
exports.paginateListExports = paginateListExports;
|
|
exports.paginateListGeneratedTemplates = paginateListGeneratedTemplates;
|
|
exports.paginateListImports = paginateListImports;
|
|
exports.paginateListResourceScanRelatedResources = paginateListResourceScanRelatedResources;
|
|
exports.paginateListResourceScanResources = paginateListResourceScanResources;
|
|
exports.paginateListResourceScans = paginateListResourceScans;
|
|
exports.paginateListStackInstances = paginateListStackInstances;
|
|
exports.paginateListStackRefactorActions = paginateListStackRefactorActions;
|
|
exports.paginateListStackRefactors = paginateListStackRefactors;
|
|
exports.paginateListStackResources = paginateListStackResources;
|
|
exports.paginateListStackSetOperationResults = paginateListStackSetOperationResults;
|
|
exports.paginateListStackSetOperations = paginateListStackSetOperations;
|
|
exports.paginateListStackSets = paginateListStackSets;
|
|
exports.paginateListStacks = paginateListStacks;
|
|
exports.paginateListTypeRegistrations = paginateListTypeRegistrations;
|
|
exports.paginateListTypeVersions = paginateListTypeVersions;
|
|
exports.paginateListTypes = paginateListTypes;
|
|
exports.waitForChangeSetCreateComplete = waitForChangeSetCreateComplete;
|
|
exports.waitForStackCreateComplete = waitForStackCreateComplete;
|
|
exports.waitForStackDeleteComplete = waitForStackDeleteComplete;
|
|
exports.waitForStackExists = waitForStackExists;
|
|
exports.waitForStackImportComplete = waitForStackImportComplete;
|
|
exports.waitForStackRefactorCreateComplete = waitForStackRefactorCreateComplete;
|
|
exports.waitForStackRefactorExecuteComplete = waitForStackRefactorExecuteComplete;
|
|
exports.waitForStackRollbackComplete = waitForStackRollbackComplete;
|
|
exports.waitForStackUpdateComplete = waitForStackUpdateComplete;
|
|
exports.waitForTypeRegistrationComplete = waitForTypeRegistrationComplete;
|
|
exports.waitUntilChangeSetCreateComplete = waitUntilChangeSetCreateComplete;
|
|
exports.waitUntilStackCreateComplete = waitUntilStackCreateComplete;
|
|
exports.waitUntilStackDeleteComplete = waitUntilStackDeleteComplete;
|
|
exports.waitUntilStackExists = waitUntilStackExists;
|
|
exports.waitUntilStackImportComplete = waitUntilStackImportComplete;
|
|
exports.waitUntilStackRefactorCreateComplete = waitUntilStackRefactorCreateComplete;
|
|
exports.waitUntilStackRefactorExecuteComplete = waitUntilStackRefactorExecuteComplete;
|
|
exports.waitUntilStackRollbackComplete = waitUntilStackRollbackComplete;
|
|
exports.waitUntilStackUpdateComplete = waitUntilStackUpdateComplete;
|
|
exports.waitUntilTypeRegistrationComplete = waitUntilTypeRegistrationComplete;
|
|
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];
|
|
});
|