@aws-sdk/client-amp 3.920.0 → 3.922.0

package/dist-es/Amp.js

@@ -1,12 +1,14 @@
 import { createAggregatedClient } from "@smithy/smithy-client";
 import { AmpClient } from "./AmpClient";
 import { CreateAlertManagerDefinitionCommand, } from "./commands/CreateAlertManagerDefinitionCommand";
+import { CreateAnomalyDetectorCommand, } from "./commands/CreateAnomalyDetectorCommand";
 import { CreateLoggingConfigurationCommand, } from "./commands/CreateLoggingConfigurationCommand";
 import { CreateQueryLoggingConfigurationCommand, } from "./commands/CreateQueryLoggingConfigurationCommand";
 import { CreateRuleGroupsNamespaceCommand, } from "./commands/CreateRuleGroupsNamespaceCommand";
 import { CreateScraperCommand, } from "./commands/CreateScraperCommand";
 import { CreateWorkspaceCommand, } from "./commands/CreateWorkspaceCommand";
 import { DeleteAlertManagerDefinitionCommand, } from "./commands/DeleteAlertManagerDefinitionCommand";
+import { DeleteAnomalyDetectorCommand, } from "./commands/DeleteAnomalyDetectorCommand";
 import { DeleteLoggingConfigurationCommand, } from "./commands/DeleteLoggingConfigurationCommand";
 import { DeleteQueryLoggingConfigurationCommand, } from "./commands/DeleteQueryLoggingConfigurationCommand";
 import { DeleteResourcePolicyCommand, } from "./commands/DeleteResourcePolicyCommand";
@@ -15,6 +17,7 @@ import { DeleteScraperCommand, } from "./commands/DeleteScraperCommand";
 import { DeleteScraperLoggingConfigurationCommand, } from "./commands/DeleteScraperLoggingConfigurationCommand";
 import { DeleteWorkspaceCommand, } from "./commands/DeleteWorkspaceCommand";
 import { DescribeAlertManagerDefinitionCommand, } from "./commands/DescribeAlertManagerDefinitionCommand";
+import { DescribeAnomalyDetectorCommand, } from "./commands/DescribeAnomalyDetectorCommand";
 import { DescribeLoggingConfigurationCommand, } from "./commands/DescribeLoggingConfigurationCommand";
 import { DescribeQueryLoggingConfigurationCommand, } from "./commands/DescribeQueryLoggingConfigurationCommand";
 import { DescribeResourcePolicyCommand, } from "./commands/DescribeResourcePolicyCommand";
@@ -24,11 +27,13 @@ import { DescribeScraperLoggingConfigurationCommand, } from "./commands/Describe
 import { DescribeWorkspaceCommand, } from "./commands/DescribeWorkspaceCommand";
 import { DescribeWorkspaceConfigurationCommand, } from "./commands/DescribeWorkspaceConfigurationCommand";
 import { GetDefaultScraperConfigurationCommand, } from "./commands/GetDefaultScraperConfigurationCommand";
+import { ListAnomalyDetectorsCommand, } from "./commands/ListAnomalyDetectorsCommand";
 import { ListRuleGroupsNamespacesCommand, } from "./commands/ListRuleGroupsNamespacesCommand";
 import { ListScrapersCommand, } from "./commands/ListScrapersCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
 import { ListWorkspacesCommand, } from "./commands/ListWorkspacesCommand";
 import { PutAlertManagerDefinitionCommand, } from "./commands/PutAlertManagerDefinitionCommand";
+import { PutAnomalyDetectorCommand, } from "./commands/PutAnomalyDetectorCommand";
 import { PutResourcePolicyCommand, } from "./commands/PutResourcePolicyCommand";
 import { PutRuleGroupsNamespaceCommand, } from "./commands/PutRuleGroupsNamespaceCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
@@ -41,12 +46,14 @@ import { UpdateWorkspaceAliasCommand, } from "./commands/UpdateWorkspaceAliasCom
 import { UpdateWorkspaceConfigurationCommand, } from "./commands/UpdateWorkspaceConfigurationCommand";
 const commands = {
     CreateAlertManagerDefinitionCommand,
+    CreateAnomalyDetectorCommand,
     CreateLoggingConfigurationCommand,
     CreateQueryLoggingConfigurationCommand,
     CreateRuleGroupsNamespaceCommand,
     CreateScraperCommand,
     CreateWorkspaceCommand,
     DeleteAlertManagerDefinitionCommand,
+    DeleteAnomalyDetectorCommand,
     DeleteLoggingConfigurationCommand,
     DeleteQueryLoggingConfigurationCommand,
     DeleteResourcePolicyCommand,
@@ -55,6 +62,7 @@ const commands = {
     DeleteScraperLoggingConfigurationCommand,
     DeleteWorkspaceCommand,
     DescribeAlertManagerDefinitionCommand,
+    DescribeAnomalyDetectorCommand,
     DescribeLoggingConfigurationCommand,
     DescribeQueryLoggingConfigurationCommand,
     DescribeResourcePolicyCommand,
@@ -64,11 +72,13 @@ const commands = {
     DescribeWorkspaceCommand,
     DescribeWorkspaceConfigurationCommand,
     GetDefaultScraperConfigurationCommand,
+    ListAnomalyDetectorsCommand,
     ListRuleGroupsNamespacesCommand,
     ListScrapersCommand,
     ListTagsForResourceCommand,
     ListWorkspacesCommand,
     PutAlertManagerDefinitionCommand,
+    PutAnomalyDetectorCommand,
     PutResourcePolicyCommand,
     PutRuleGroupsNamespaceCommand,
     TagResourceCommand,

package/dist-es/commands/CreateAnomalyDetectorCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_CreateAnomalyDetectorCommand, se_CreateAnomalyDetectorCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateAnomalyDetectorCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonPrometheusService", "CreateAnomalyDetector", {})
+    .n("AmpClient", "CreateAnomalyDetectorCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateAnomalyDetectorCommand)
+    .de(de_CreateAnomalyDetectorCommand)
+    .build() {
+}

package/dist-es/commands/DeleteAnomalyDetectorCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_DeleteAnomalyDetectorCommand, se_DeleteAnomalyDetectorCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteAnomalyDetectorCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonPrometheusService", "DeleteAnomalyDetector", {})
+    .n("AmpClient", "DeleteAnomalyDetectorCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteAnomalyDetectorCommand)
+    .de(de_DeleteAnomalyDetectorCommand)
+    .build() {
+}

package/dist-es/commands/DescribeAnomalyDetectorCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_DescribeAnomalyDetectorCommand, se_DescribeAnomalyDetectorCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DescribeAnomalyDetectorCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonPrometheusService", "DescribeAnomalyDetector", {})
+    .n("AmpClient", "DescribeAnomalyDetectorCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeAnomalyDetectorCommand)
+    .de(de_DescribeAnomalyDetectorCommand)
+    .build() {
+}

package/dist-es/commands/ListAnomalyDetectorsCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_ListAnomalyDetectorsCommand, se_ListAnomalyDetectorsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListAnomalyDetectorsCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonPrometheusService", "ListAnomalyDetectors", {})
+    .n("AmpClient", "ListAnomalyDetectorsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListAnomalyDetectorsCommand)
+    .de(de_ListAnomalyDetectorsCommand)
+    .build() {
+}

package/dist-es/commands/PutAnomalyDetectorCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_PutAnomalyDetectorCommand, se_PutAnomalyDetectorCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class PutAnomalyDetectorCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonPrometheusService", "PutAnomalyDetector", {})
+    .n("AmpClient", "PutAnomalyDetectorCommand")
+    .f(void 0, void 0)
+    .ser(se_PutAnomalyDetectorCommand)
+    .de(de_PutAnomalyDetectorCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -1,10 +1,12 @@
 export * from "./CreateAlertManagerDefinitionCommand";
+export * from "./CreateAnomalyDetectorCommand";
 export * from "./CreateLoggingConfigurationCommand";
 export * from "./CreateQueryLoggingConfigurationCommand";
 export * from "./CreateRuleGroupsNamespaceCommand";
 export * from "./CreateScraperCommand";
 export * from "./CreateWorkspaceCommand";
 export * from "./DeleteAlertManagerDefinitionCommand";
+export * from "./DeleteAnomalyDetectorCommand";
 export * from "./DeleteLoggingConfigurationCommand";
 export * from "./DeleteQueryLoggingConfigurationCommand";
 export * from "./DeleteResourcePolicyCommand";
@@ -13,6 +15,7 @@ export * from "./DeleteScraperCommand";
 export * from "./DeleteScraperLoggingConfigurationCommand";
 export * from "./DeleteWorkspaceCommand";
 export * from "./DescribeAlertManagerDefinitionCommand";
+export * from "./DescribeAnomalyDetectorCommand";
 export * from "./DescribeLoggingConfigurationCommand";
 export * from "./DescribeQueryLoggingConfigurationCommand";
 export * from "./DescribeResourcePolicyCommand";
@@ -22,11 +25,13 @@ export * from "./DescribeScraperLoggingConfigurationCommand";
 export * from "./DescribeWorkspaceCommand";
 export * from "./DescribeWorkspaceConfigurationCommand";
 export * from "./GetDefaultScraperConfigurationCommand";
+export * from "./ListAnomalyDetectorsCommand";
 export * from "./ListRuleGroupsNamespacesCommand";
 export * from "./ListScrapersCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./ListWorkspacesCommand";
 export * from "./PutAlertManagerDefinitionCommand";
+export * from "./PutAnomalyDetectorCommand";
 export * from "./PutResourcePolicyCommand";
 export * from "./PutRuleGroupsNamespaceCommand";
 export * from "./TagResourceCommand";

package/dist-es/models/models_0.js

@@ -181,6 +181,43 @@ export const ScraperLoggingConfigurationStatusCode = {
     UPDATE_FAILED: "UPDATE_FAILED",
     UPDATING: "UPDATING",
 };
+export var IgnoreNearExpected;
+(function (IgnoreNearExpected) {
+    IgnoreNearExpected.visit = (value, visitor) => {
+        if (value.amount !== undefined)
+            return visitor.amount(value.amount);
+        if (value.ratio !== undefined)
+            return visitor.ratio(value.ratio);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(IgnoreNearExpected || (IgnoreNearExpected = {}));
+export var AnomalyDetectorConfiguration;
+(function (AnomalyDetectorConfiguration) {
+    AnomalyDetectorConfiguration.visit = (value, visitor) => {
+        if (value.randomCutForest !== undefined)
+            return visitor.randomCutForest(value.randomCutForest);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AnomalyDetectorConfiguration || (AnomalyDetectorConfiguration = {}));
+export var AnomalyDetectorMissingDataAction;
+(function (AnomalyDetectorMissingDataAction) {
+    AnomalyDetectorMissingDataAction.visit = (value, visitor) => {
+        if (value.markAsAnomaly !== undefined)
+            return visitor.markAsAnomaly(value.markAsAnomaly);
+        if (value.skip !== undefined)
+            return visitor.skip(value.skip);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AnomalyDetectorMissingDataAction || (AnomalyDetectorMissingDataAction = {}));
+export const AnomalyDetectorStatusCode = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    CREATION_FAILED: "CREATION_FAILED",
+    DELETING: "DELETING",
+    DELETION_FAILED: "DELETION_FAILED",
+    UPDATE_FAILED: "UPDATE_FAILED",
+    UPDATING: "UPDATING",
+};
 export const WorkspaceStatusCode = {
     ACTIVE: "ACTIVE",
     CREATING: "CREATING",

package/dist-es/pagination/ListAnomalyDetectorsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { AmpClient } from "../AmpClient";
+import { ListAnomalyDetectorsCommand, } from "../commands/ListAnomalyDetectorsCommand";
+export const paginateListAnomalyDetectors = createPaginator(AmpClient, ListAnomalyDetectorsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/index.js

@@ -1,4 +1,5 @@
 export * from "./Interfaces";
+export * from "./ListAnomalyDetectorsPaginator";
 export * from "./ListRuleGroupsNamespacesPaginator";
 export * from "./ListScrapersPaginator";
 export * from "./ListWorkspacesPaginator";

package/dist-es/protocols/Aws_restJson1.js

@@ -1,9 +1,9 @@
 import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
-import { _json, collectBody, convertMap, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
+import { _json, collectBody, convertMap, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "@smithy/uuid";
 import { AmpServiceException as __BaseException } from "../models/AmpServiceException";
-import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ScrapeConfiguration, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, AnomalyDetectorConfiguration, ConflictException, IgnoreNearExpected, InternalServerException, ResourceNotFoundException, ScrapeConfiguration, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
 export const se_CreateAlertManagerDefinitionCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -19,6 +19,26 @@ export const se_CreateAlertManagerDefinitionCommand = async (input, context) =>
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_CreateAnomalyDetectorCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/workspaces/{workspaceId}/anomalydetectors");
+    b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        alias: [],
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        configuration: (_) => se_AnomalyDetectorConfiguration(_, context),
+        evaluationIntervalInSeconds: [],
+        labels: (_) => _json(_),
+        missingDataAction: (_) => _json(_),
+        tags: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_CreateLoggingConfigurationCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -113,6 +133,19 @@ export const se_DeleteAlertManagerDefinitionCommand = async (input, context) =>
     b.m("DELETE").h(headers).q(query).b(body);
     return b.build();
 };
+export const se_DeleteAnomalyDetectorCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/workspaces/{workspaceId}/anomalydetectors/{anomalyDetectorId}");
+    b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
+    b.p("anomalyDetectorId", () => input.anomalyDetectorId, "{anomalyDetectorId}", false);
+    const query = map({
+        [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
+    });
+    let body;
+    b.m("DELETE").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_DeleteLoggingConfigurationCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -208,6 +241,16 @@ export const se_DescribeAlertManagerDefinitionCommand = async (input, context) =
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+export const se_DescribeAnomalyDetectorCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/workspaces/{workspaceId}/anomalydetectors/{anomalyDetectorId}");
+    b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
+    b.p("anomalyDetectorId", () => input.anomalyDetectorId, "{anomalyDetectorId}", false);
+    let body;
+    b.m("GET").h(headers).b(body);
+    return b.build();
+};
 export const se_DescribeLoggingConfigurationCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -289,6 +332,20 @@ export const se_GetDefaultScraperConfigurationCommand = async (input, context) =
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+export const se_ListAnomalyDetectorsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/workspaces/{workspaceId}/anomalydetectors");
+    b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
+    const query = map({
+        [_a]: [, input[_a]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_nT]: [, input[_nT]],
+    });
+    let body;
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_ListRuleGroupsNamespacesCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -353,6 +410,25 @@ export const se_PutAlertManagerDefinitionCommand = async (input, context) => {
     b.m("PUT").h(headers).b(body);
     return b.build();
 };
+export const se_PutAnomalyDetectorCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/workspaces/{workspaceId}/anomalydetectors/{anomalyDetectorId}");
+    b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
+    b.p("anomalyDetectorId", () => input.anomalyDetectorId, "{anomalyDetectorId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        configuration: (_) => se_AnomalyDetectorConfiguration(_, context),
+        evaluationIntervalInSeconds: [],
+        labels: (_) => _json(_),
+        missingDataAction: (_) => _json(_),
+    }));
+    b.m("PUT").h(headers).b(body);
+    return b.build();
+};
 export const se_PutResourcePolicyCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -519,6 +595,23 @@ export const de_CreateAlertManagerDefinitionCommand = async (output, context) =>
     Object.assign(contents, doc);
     return contents;
 };
+export const de_CreateAnomalyDetectorCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        anomalyDetectorId: __expectString,
+        arn: __expectString,
+        status: _json,
+        tags: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_CreateLoggingConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -609,6 +702,16 @@ export const de_DeleteAlertManagerDefinitionCommand = async (output, context) =>
     await collectBody(output.body, context);
     return contents;
 };
+export const de_DeleteAnomalyDetectorCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_DeleteLoggingConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -698,6 +801,20 @@ export const de_DescribeAlertManagerDefinitionCommand = async (output, context)
     Object.assign(contents, doc);
     return contents;
 };
+export const de_DescribeAnomalyDetectorCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        anomalyDetector: (_) => de_AnomalyDetectorDescription(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_DescribeLoggingConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -830,6 +947,21 @@ export const de_GetDefaultScraperConfigurationCommand = async (output, context)
     Object.assign(contents, doc);
     return contents;
 };
+export const de_ListAnomalyDetectorsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        anomalyDetectors: (_) => de_AnomalyDetectorSummaryList(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_ListRuleGroupsNamespacesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -903,6 +1035,23 @@ export const de_PutAlertManagerDefinitionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_PutAnomalyDetectorCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        anomalyDetectorId: __expectString,
+        arn: __expectString,
+        status: _json,
+        tags: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_PutResourcePolicyCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -1183,6 +1332,28 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const se_AnomalyDetectorConfiguration = (input, context) => {
+    return AnomalyDetectorConfiguration.visit(input, {
+        randomCutForest: (value) => ({ randomCutForest: se_RandomCutForestConfiguration(value, context) }),
+        _: (name, value) => ({ [name]: value }),
+    });
+};
+const se_IgnoreNearExpected = (input, context) => {
+    return IgnoreNearExpected.visit(input, {
+        amount: (value) => ({ amount: __serializeFloat(value) }),
+        ratio: (value) => ({ ratio: __serializeFloat(value) }),
+        _: (name, value) => ({ [name]: value }),
+    });
+};
+const se_RandomCutForestConfiguration = (input, context) => {
+    return take(input, {
+        ignoreNearExpectedFromAbove: (_) => se_IgnoreNearExpected(_, context),
+        ignoreNearExpectedFromBelow: (_) => se_IgnoreNearExpected(_, context),
+        query: [],
+        sampleSize: [],
+        shingleSize: [],
+    });
+};
 const se_ScrapeConfiguration = (input, context) => {
     return ScrapeConfiguration.visit(input, {
         configurationBlob: (value) => ({ configurationBlob: context.base64Encoder(value) }),
@@ -1197,6 +1368,57 @@ const de_AlertManagerDefinitionDescription = (output, context) => {
         status: _json,
     });
 };
+const de_AnomalyDetectorConfiguration = (output, context) => {
+    if (output.randomCutForest != null) {
+        return {
+            randomCutForest: de_RandomCutForestConfiguration(output.randomCutForest, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_AnomalyDetectorDescription = (output, context) => {
+    return take(output, {
+        alias: __expectString,
+        anomalyDetectorId: __expectString,
+        arn: __expectString,
+        configuration: (_) => de_AnomalyDetectorConfiguration(__expectUnion(_), context),
+        createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        evaluationIntervalInSeconds: __expectInt32,
+        labels: _json,
+        missingDataAction: (_) => _json(__expectUnion(_)),
+        modifiedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        status: _json,
+        tags: _json,
+    });
+};
+const de_AnomalyDetectorSummary = (output, context) => {
+    return take(output, {
+        alias: __expectString,
+        anomalyDetectorId: __expectString,
+        arn: __expectString,
+        createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        modifiedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        status: _json,
+        tags: _json,
+    });
+};
+const de_AnomalyDetectorSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_AnomalyDetectorSummary(entry, context);
+    });
+    return retVal;
+};
+const de_IgnoreNearExpected = (output, context) => {
+    if (__limitedParseDouble(output.amount) !== undefined) {
+        return { amount: __limitedParseDouble(output.amount) };
+    }
+    if (__limitedParseDouble(output.ratio) !== undefined) {
+        return { ratio: __limitedParseDouble(output.ratio) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
 const de_LoggingConfigurationMetadata = (output, context) => {
     return take(output, {
         createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
@@ -1215,6 +1437,15 @@ const de_QueryLoggingConfigurationMetadata = (output, context) => {
         workspace: __expectString,
     });
 };
+const de_RandomCutForestConfiguration = (output, context) => {
+    return take(output, {
+        ignoreNearExpectedFromAbove: (_) => de_IgnoreNearExpected(__expectUnion(_), context),
+        ignoreNearExpectedFromBelow: (_) => de_IgnoreNearExpected(__expectUnion(_), context),
+        query: __expectString,
+        sampleSize: __expectInt32,
+        shingleSize: __expectInt32,
+    });
+};
 const de_RuleGroupsNamespaceDescription = (output, context) => {
     return take(output, {
         arn: __expectString,

package/dist-es/waiters/index.js

@@ -1,3 +1,5 @@
+export * from "./waitForAnomalyDetectorActive";
+export * from "./waitForAnomalyDetectorDeleted";
 export * from "./waitForScraperActive";
 export * from "./waitForScraperDeleted";
 export * from "./waitForWorkspaceActive";

package/dist-es/waiters/waitForAnomalyDetectorActive.js

@@ -0,0 +1,49 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeAnomalyDetectorCommand, } from "../commands/DescribeAnomalyDetectorCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeAnomalyDetectorCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.anomalyDetector.status.statusCode;
+            };
+            if (returnComparator() === "ACTIVE") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.anomalyDetector.status.statusCode;
+            };
+            if (returnComparator() === "CREATING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.anomalyDetector.status.statusCode;
+            };
+            if (returnComparator() === "UPDATING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForAnomalyDetectorActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilAnomalyDetectorActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};