@aws-sdk/client-amp 3.32.0 → 3.36.0

package/{dist/cjs → dist-cjs}/runtimeConfig.browser.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeConfig = void 0;
 const tslib_1 = require("tslib");
-const package_json_1 = tslib_1.__importDefault(require("./package.json"));
+// @ts-ignore: package.json will be imported from dist folders
+const package_json_1 = tslib_1.__importDefault(require("../package.json")); // eslint-disable-line
 const sha256_browser_1 = require("@aws-crypto/sha256-browser");
 const fetch_http_handler_1 = require("@aws-sdk/fetch-http-handler");
 const invalid_dependency_1 = require("@aws-sdk/invalid-dependency");
@@ -38,4 +39,3 @@ const getRuntimeConfig = (config) => {
     };
 };
 exports.getRuntimeConfig = getRuntimeConfig;
-//# sourceMappingURL=runtimeConfig.browser.js.map

package/{dist/cjs → dist-cjs}/runtimeConfig.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeConfig = void 0;
 const tslib_1 = require("tslib");
-const package_json_1 = tslib_1.__importDefault(require("./package.json"));
+// @ts-ignore: package.json will be imported from dist folders
+const package_json_1 = tslib_1.__importDefault(require("../package.json")); // eslint-disable-line
 const client_sts_1 = require("@aws-sdk/client-sts");
 const config_resolver_1 = require("@aws-sdk/config-resolver");
 const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
@@ -43,4 +44,3 @@ const getRuntimeConfig = (config) => {
     };
 };
 exports.getRuntimeConfig = getRuntimeConfig;
-//# sourceMappingURL=runtimeConfig.js.map

package/{dist/cjs → dist-cjs}/runtimeConfig.native.js

@@ -17,4 +17,3 @@ const getRuntimeConfig = (config) => {
     };
 };
 exports.getRuntimeConfig = getRuntimeConfig;
-//# sourceMappingURL=runtimeConfig.native.js.map

package/{dist/cjs → dist-cjs}/runtimeConfig.shared.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeConfig = void 0;
-const endpoints_1 = require("./endpoints");
 const url_parser_1 = require("@aws-sdk/url-parser");
+const endpoints_1 = require("./endpoints");
 /**
  * @internal
  */
@@ -18,4 +18,3 @@ const getRuntimeConfig = (config) => {
     });
 };
 exports.getRuntimeConfig = getRuntimeConfig;
-//# sourceMappingURL=runtimeConfig.shared.js.map

package/dist-cjs/waiters/waitForWorkspaceActive.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilWorkspaceActive = exports.waitForWorkspaceActive = void 0;
+const util_waiter_1 = require("@aws-sdk/util-waiter");
+const DescribeWorkspaceCommand_1 = require("../commands/DescribeWorkspaceCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeWorkspaceCommand_1.DescribeWorkspaceCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.workspace.status.statusCode;
+            };
+            if (returnComparator() === "ACTIVE") {
+                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.workspace.status.statusCode;
+            };
+            if (returnComparator() === "UPDATING") {
+                return { state: util_waiter_1.WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.workspace.status.statusCode;
+            };
+            if (returnComparator() === "CREATING") {
+                return { state: util_waiter_1.WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+/**
+ * Wait until a workspace reaches ACTIVE status
+ *  @deprecated Use waitUntilWorkspaceActive instead. waitForWorkspaceActive does not throw error in non-success cases.
+ */
+const waitForWorkspaceActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    return util_waiter_1.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForWorkspaceActive = waitForWorkspaceActive;
+/**
+ * Wait until a workspace reaches ACTIVE status
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeWorkspaceCommand for polling.
+ */
+const waitUntilWorkspaceActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    const result = await util_waiter_1.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return util_waiter_1.checkExceptions(result);
+};
+exports.waitUntilWorkspaceActive = waitUntilWorkspaceActive;

package/dist-cjs/waiters/waitForWorkspaceDeleted.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilWorkspaceDeleted = exports.waitForWorkspaceDeleted = void 0;
+const util_waiter_1 = require("@aws-sdk/util-waiter");
+const DescribeWorkspaceCommand_1 = require("../commands/DescribeWorkspaceCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeWorkspaceCommand_1.DescribeWorkspaceCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.workspace.status.statusCode;
+            };
+            if (returnComparator() === "DELETING") {
+                return { state: util_waiter_1.WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+/**
+ * Wait until a workspace reaches DELETED status
+ *  @deprecated Use waitUntilWorkspaceDeleted instead. waitForWorkspaceDeleted does not throw error in non-success cases.
+ */
+const waitForWorkspaceDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    return util_waiter_1.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForWorkspaceDeleted = waitForWorkspaceDeleted;
+/**
+ * Wait until a workspace reaches DELETED status
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeWorkspaceCommand for polling.
+ */
+const waitUntilWorkspaceDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    const result = await util_waiter_1.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return util_waiter_1.checkExceptions(result);
+};
+exports.waitUntilWorkspaceDeleted = waitUntilWorkspaceDeleted;

package/dist-es/Amp.js

@@ -0,0 +1,265 @@
+import { __extends } from "tslib";
+import { AmpClient } from "./AmpClient";
+import { CreateAlertManagerDefinitionCommand, } from "./commands/CreateAlertManagerDefinitionCommand";
+import { CreateRuleGroupsNamespaceCommand, } from "./commands/CreateRuleGroupsNamespaceCommand";
+import { CreateWorkspaceCommand, } from "./commands/CreateWorkspaceCommand";
+import { DeleteAlertManagerDefinitionCommand, } from "./commands/DeleteAlertManagerDefinitionCommand";
+import { DeleteRuleGroupsNamespaceCommand, } from "./commands/DeleteRuleGroupsNamespaceCommand";
+import { DeleteWorkspaceCommand, } from "./commands/DeleteWorkspaceCommand";
+import { DescribeAlertManagerDefinitionCommand, } from "./commands/DescribeAlertManagerDefinitionCommand";
+import { DescribeRuleGroupsNamespaceCommand, } from "./commands/DescribeRuleGroupsNamespaceCommand";
+import { DescribeWorkspaceCommand, } from "./commands/DescribeWorkspaceCommand";
+import { ListRuleGroupsNamespacesCommand, } from "./commands/ListRuleGroupsNamespacesCommand";
+import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
+import { ListWorkspacesCommand, } from "./commands/ListWorkspacesCommand";
+import { PutAlertManagerDefinitionCommand, } from "./commands/PutAlertManagerDefinitionCommand";
+import { PutRuleGroupsNamespaceCommand, } from "./commands/PutRuleGroupsNamespaceCommand";
+import { TagResourceCommand } from "./commands/TagResourceCommand";
+import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
+import { UpdateWorkspaceAliasCommand, } from "./commands/UpdateWorkspaceAliasCommand";
+var Amp = (function (_super) {
+    __extends(Amp, _super);
+    function Amp() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Amp.prototype.createAlertManagerDefinition = function (args, optionsOrCb, cb) {
+        var command = new CreateAlertManagerDefinitionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.createRuleGroupsNamespace = function (args, optionsOrCb, cb) {
+        var command = new CreateRuleGroupsNamespaceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.createWorkspace = function (args, optionsOrCb, cb) {
+        var command = new CreateWorkspaceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.deleteAlertManagerDefinition = function (args, optionsOrCb, cb) {
+        var command = new DeleteAlertManagerDefinitionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.deleteRuleGroupsNamespace = function (args, optionsOrCb, cb) {
+        var command = new DeleteRuleGroupsNamespaceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.deleteWorkspace = function (args, optionsOrCb, cb) {
+        var command = new DeleteWorkspaceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.describeAlertManagerDefinition = function (args, optionsOrCb, cb) {
+        var command = new DescribeAlertManagerDefinitionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.describeRuleGroupsNamespace = function (args, optionsOrCb, cb) {
+        var command = new DescribeRuleGroupsNamespaceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.describeWorkspace = function (args, optionsOrCb, cb) {
+        var command = new DescribeWorkspaceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.listRuleGroupsNamespaces = function (args, optionsOrCb, cb) {
+        var command = new ListRuleGroupsNamespacesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
+        var command = new ListTagsForResourceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.listWorkspaces = function (args, optionsOrCb, cb) {
+        var command = new ListWorkspacesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.putAlertManagerDefinition = function (args, optionsOrCb, cb) {
+        var command = new PutAlertManagerDefinitionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.putRuleGroupsNamespace = function (args, optionsOrCb, cb) {
+        var command = new PutRuleGroupsNamespaceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Amp.prototype.updateWorkspaceAlias = function (args, optionsOrCb, cb) {
+        var command = new UpdateWorkspaceAliasCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    return Amp;
+}(AmpClient));
+export { Amp };

package/{dist/es → dist-es}/AmpClient.js

@@ -1,5 +1,4 @@
 import { __extends } from "tslib";
-import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
 import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
@@ -8,10 +7,8 @@ import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
 import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
 import { Client as __Client, } from "@aws-sdk/smithy-client";
-/**
- * Amazon Managed Service for Prometheus
- */
-var AmpClient = /** @class */ (function (_super) {
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var AmpClient = (function (_super) {
     __extends(AmpClient, _super);
     function AmpClient(configuration) {
         var _this = this;
@@ -32,15 +29,9 @@ var AmpClient = /** @class */ (function (_super) {
         _this.middlewareStack.use(getUserAgentPlugin(_this.config));
         return _this;
     }
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
     AmpClient.prototype.destroy = function () {
         _super.prototype.destroy.call(this);
     };
     return AmpClient;
 }(__Client));
 export { AmpClient };
-//# sourceMappingURL=AmpClient.js.map

package/dist-es/commands/CreateAlertManagerDefinitionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateAlertManagerDefinitionRequest, CreateAlertManagerDefinitionResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateAlertManagerDefinitionCommand, serializeAws_restJson1CreateAlertManagerDefinitionCommand, } from "../protocols/Aws_restJson1";
+var CreateAlertManagerDefinitionCommand = (function (_super) {
+    __extends(CreateAlertManagerDefinitionCommand, _super);
+    function CreateAlertManagerDefinitionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateAlertManagerDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AmpClient";
+        var commandName = "CreateAlertManagerDefinitionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateAlertManagerDefinitionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateAlertManagerDefinitionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateAlertManagerDefinitionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateAlertManagerDefinitionCommand(input, context);
+    };
+    CreateAlertManagerDefinitionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateAlertManagerDefinitionCommand(output, context);
+    };
+    return CreateAlertManagerDefinitionCommand;
+}($Command));
+export { CreateAlertManagerDefinitionCommand };

package/dist-es/commands/CreateRuleGroupsNamespaceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateRuleGroupsNamespaceRequest, CreateRuleGroupsNamespaceResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateRuleGroupsNamespaceCommand, serializeAws_restJson1CreateRuleGroupsNamespaceCommand, } from "../protocols/Aws_restJson1";
+var CreateRuleGroupsNamespaceCommand = (function (_super) {
+    __extends(CreateRuleGroupsNamespaceCommand, _super);
+    function CreateRuleGroupsNamespaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateRuleGroupsNamespaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AmpClient";
+        var commandName = "CreateRuleGroupsNamespaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateRuleGroupsNamespaceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateRuleGroupsNamespaceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateRuleGroupsNamespaceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateRuleGroupsNamespaceCommand(input, context);
+    };
+    CreateRuleGroupsNamespaceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateRuleGroupsNamespaceCommand(output, context);
+    };
+    return CreateRuleGroupsNamespaceCommand;
+}($Command));
+export { CreateRuleGroupsNamespaceCommand };

package/{dist/es → dist-es}/commands/CreateWorkspaceCommand.js

@@ -1,40 +1,15 @@
 import { __extends } from "tslib";
-import { CreateWorkspaceRequest, CreateWorkspaceResponse } from "../models/models_0";
-import { deserializeAws_restJson1CreateWorkspaceCommand, serializeAws_restJson1CreateWorkspaceCommand, } from "../protocols/Aws_restJson1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * Creates a new AMP workspace.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AmpClient, CreateWorkspaceCommand } from "@aws-sdk/client-amp"; // ES Modules import
- * // const { AmpClient, CreateWorkspaceCommand } = require("@aws-sdk/client-amp"); // CommonJS import
- * const client = new AmpClient(config);
- * const command = new CreateWorkspaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateWorkspaceCommandInput} for command's `input` shape.
- * @see {@link CreateWorkspaceCommandOutput} for command's `response` shape.
- * @see {@link AmpClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var CreateWorkspaceCommand = /** @class */ (function (_super) {
+import { CreateWorkspaceRequest, CreateWorkspaceResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateWorkspaceCommand, serializeAws_restJson1CreateWorkspaceCommand, } from "../protocols/Aws_restJson1";
+var CreateWorkspaceCommand = (function (_super) {
     __extends(CreateWorkspaceCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function CreateWorkspaceCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     CreateWorkspaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -62,4 +37,3 @@ var CreateWorkspaceCommand = /** @class */ (function (_super) {
     return CreateWorkspaceCommand;
 }($Command));
 export { CreateWorkspaceCommand };
-//# sourceMappingURL=CreateWorkspaceCommand.js.map

package/dist-es/commands/DeleteAlertManagerDefinitionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteAlertManagerDefinitionRequest } from "../models/models_0";
+import { deserializeAws_restJson1DeleteAlertManagerDefinitionCommand, serializeAws_restJson1DeleteAlertManagerDefinitionCommand, } from "../protocols/Aws_restJson1";
+var DeleteAlertManagerDefinitionCommand = (function (_super) {
+    __extends(DeleteAlertManagerDefinitionCommand, _super);
+    function DeleteAlertManagerDefinitionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteAlertManagerDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AmpClient";
+        var commandName = "DeleteAlertManagerDefinitionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteAlertManagerDefinitionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteAlertManagerDefinitionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteAlertManagerDefinitionCommand(input, context);
+    };
+    DeleteAlertManagerDefinitionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteAlertManagerDefinitionCommand(output, context);
+    };
+    return DeleteAlertManagerDefinitionCommand;
+}($Command));
+export { DeleteAlertManagerDefinitionCommand };