@aws-sdk/client-amp 3.919.0 → 3.921.0

package/dist-cjs/index.js

@@ -301,6 +301,43 @@ const ScraperLoggingConfigurationStatusCode = {
     UPDATE_FAILED: "UPDATE_FAILED",
     UPDATING: "UPDATING",
 };
+exports.IgnoreNearExpected = void 0;
+(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]);
+    };
+})(exports.IgnoreNearExpected || (exports.IgnoreNearExpected = {}));
+exports.AnomalyDetectorConfiguration = void 0;
+(function (AnomalyDetectorConfiguration) {
+    AnomalyDetectorConfiguration.visit = (value, visitor) => {
+        if (value.randomCutForest !== undefined)
+            return visitor.randomCutForest(value.randomCutForest);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(exports.AnomalyDetectorConfiguration || (exports.AnomalyDetectorConfiguration = {}));
+exports.AnomalyDetectorMissingDataAction = void 0;
+(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]);
+    };
+})(exports.AnomalyDetectorMissingDataAction || (exports.AnomalyDetectorMissingDataAction = {}));
+const AnomalyDetectorStatusCode = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    CREATION_FAILED: "CREATION_FAILED",
+    DELETING: "DELETING",
+    DELETION_FAILED: "DELETION_FAILED",
+    UPDATE_FAILED: "UPDATE_FAILED",
+    UPDATING: "UPDATING",
+};
 const WorkspaceStatusCode = {
     ACTIVE: "ACTIVE",
     CREATING: "CREATING",
@@ -359,6 +396,26 @@ const se_CreateAlertManagerDefinitionCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+const se_CreateAnomalyDetectorCommand = async (input, context) => {
+    const b = core.requestBuilder(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(smithyClient.take(input, {
+        alias: [],
+        clientToken: [true, (_) => _ ?? uuid.v4()],
+        configuration: (_) => se_AnomalyDetectorConfiguration(_),
+        evaluationIntervalInSeconds: [],
+        labels: (_) => smithyClient._json(_),
+        missingDataAction: (_) => smithyClient._json(_),
+        tags: (_) => smithyClient._json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 const se_CreateLoggingConfigurationCommand = async (input, context) => {
     const b = core.requestBuilder(input, context);
     const headers = {
@@ -453,6 +510,19 @@ const se_DeleteAlertManagerDefinitionCommand = async (input, context) => {
     b.m("DELETE").h(headers).q(query).b(body);
     return b.build();
 };
+const se_DeleteAnomalyDetectorCommand = async (input, context) => {
+    const b = core.requestBuilder(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 = smithyClient.map({
+        [_cT]: [, input[_cT] ?? uuid.v4()],
+    });
+    let body;
+    b.m("DELETE").h(headers).q(query).b(body);
+    return b.build();
+};
 const se_DeleteLoggingConfigurationCommand = async (input, context) => {
     const b = core.requestBuilder(input, context);
     const headers = {};
@@ -548,6 +618,16 @@ const se_DescribeAlertManagerDefinitionCommand = async (input, context) => {
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+const se_DescribeAnomalyDetectorCommand = async (input, context) => {
+    const b = core.requestBuilder(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();
+};
 const se_DescribeLoggingConfigurationCommand = async (input, context) => {
     const b = core.requestBuilder(input, context);
     const headers = {};
@@ -629,6 +709,20 @@ const se_GetDefaultScraperConfigurationCommand = async (input, context) => {
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+const se_ListAnomalyDetectorsCommand = async (input, context) => {
+    const b = core.requestBuilder(input, context);
+    const headers = {};
+    b.bp("/workspaces/{workspaceId}/anomalydetectors");
+    b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
+    const query = smithyClient.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();
+};
 const se_ListRuleGroupsNamespacesCommand = async (input, context) => {
     const b = core.requestBuilder(input, context);
     const headers = {};
@@ -693,6 +787,25 @@ const se_PutAlertManagerDefinitionCommand = async (input, context) => {
     b.m("PUT").h(headers).b(body);
     return b.build();
 };
+const se_PutAnomalyDetectorCommand = async (input, context) => {
+    const b = core.requestBuilder(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(smithyClient.take(input, {
+        clientToken: [true, (_) => _ ?? uuid.v4()],
+        configuration: (_) => se_AnomalyDetectorConfiguration(_),
+        evaluationIntervalInSeconds: [],
+        labels: (_) => smithyClient._json(_),
+        missingDataAction: (_) => smithyClient._json(_),
+    }));
+    b.m("PUT").h(headers).b(body);
+    return b.build();
+};
 const se_PutResourcePolicyCommand = async (input, context) => {
     const b = core.requestBuilder(input, context);
     const headers = {
@@ -859,6 +972,23 @@ const de_CreateAlertManagerDefinitionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+const de_CreateAnomalyDetectorCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+    const doc = smithyClient.take(data, {
+        anomalyDetectorId: smithyClient.expectString,
+        arn: smithyClient.expectString,
+        status: smithyClient._json,
+        tags: smithyClient._json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 const de_CreateLoggingConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -949,6 +1079,16 @@ const de_DeleteAlertManagerDefinitionCommand = async (output, context) => {
     await smithyClient.collectBody(output.body, context);
     return contents;
 };
+const de_DeleteAnomalyDetectorCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    await smithyClient.collectBody(output.body, context);
+    return contents;
+};
 const de_DeleteLoggingConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -1038,6 +1178,20 @@ const de_DescribeAlertManagerDefinitionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+const de_DescribeAnomalyDetectorCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+    const doc = smithyClient.take(data, {
+        anomalyDetector: (_) => de_AnomalyDetectorDescription(_),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 const de_DescribeLoggingConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -1170,6 +1324,21 @@ const de_GetDefaultScraperConfigurationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+const de_ListAnomalyDetectorsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+    const doc = smithyClient.take(data, {
+        anomalyDetectors: (_) => de_AnomalyDetectorSummaryList(_),
+        nextToken: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 const de_ListRuleGroupsNamespacesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -1243,6 +1412,23 @@ const de_PutAlertManagerDefinitionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+const de_PutAnomalyDetectorCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+    const doc = smithyClient.take(data, {
+        anomalyDetectorId: smithyClient.expectString,
+        arn: smithyClient.expectString,
+        status: smithyClient._json,
+        tags: smithyClient._json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 const de_PutResourcePolicyCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -1523,6 +1709,28 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
+const se_AnomalyDetectorConfiguration = (input, context) => {
+    return exports.AnomalyDetectorConfiguration.visit(input, {
+        randomCutForest: (value) => ({ randomCutForest: se_RandomCutForestConfiguration(value) }),
+        _: (name, value) => ({ [name]: value }),
+    });
+};
+const se_IgnoreNearExpected = (input, context) => {
+    return exports.IgnoreNearExpected.visit(input, {
+        amount: (value) => ({ amount: smithyClient.serializeFloat(value) }),
+        ratio: (value) => ({ ratio: smithyClient.serializeFloat(value) }),
+        _: (name, value) => ({ [name]: value }),
+    });
+};
+const se_RandomCutForestConfiguration = (input, context) => {
+    return smithyClient.take(input, {
+        ignoreNearExpectedFromAbove: (_) => se_IgnoreNearExpected(_),
+        ignoreNearExpectedFromBelow: (_) => se_IgnoreNearExpected(_),
+        query: [],
+        sampleSize: [],
+        shingleSize: [],
+    });
+};
 const se_ScrapeConfiguration = (input, context) => {
     return exports.ScrapeConfiguration.visit(input, {
         configurationBlob: (value) => ({ configurationBlob: context.base64Encoder(value) }),
@@ -1537,6 +1745,57 @@ const de_AlertManagerDefinitionDescription = (output, context) => {
         status: smithyClient._json,
     });
 };
+const de_AnomalyDetectorConfiguration = (output, context) => {
+    if (output.randomCutForest != null) {
+        return {
+            randomCutForest: de_RandomCutForestConfiguration(output.randomCutForest),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_AnomalyDetectorDescription = (output, context) => {
+    return smithyClient.take(output, {
+        alias: smithyClient.expectString,
+        anomalyDetectorId: smithyClient.expectString,
+        arn: smithyClient.expectString,
+        configuration: (_) => de_AnomalyDetectorConfiguration(core$1.awsExpectUnion(_)),
+        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        evaluationIntervalInSeconds: smithyClient.expectInt32,
+        labels: smithyClient._json,
+        missingDataAction: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
+        modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        status: smithyClient._json,
+        tags: smithyClient._json,
+    });
+};
+const de_AnomalyDetectorSummary = (output, context) => {
+    return smithyClient.take(output, {
+        alias: smithyClient.expectString,
+        anomalyDetectorId: smithyClient.expectString,
+        arn: smithyClient.expectString,
+        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        status: smithyClient._json,
+        tags: smithyClient._json,
+    });
+};
+const de_AnomalyDetectorSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_AnomalyDetectorSummary(entry);
+    });
+    return retVal;
+};
+const de_IgnoreNearExpected = (output, context) => {
+    if (smithyClient.limitedParseDouble(output.amount) !== undefined) {
+        return { amount: smithyClient.limitedParseDouble(output.amount) };
+    }
+    if (smithyClient.limitedParseDouble(output.ratio) !== undefined) {
+        return { ratio: smithyClient.limitedParseDouble(output.ratio) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
 const de_LoggingConfigurationMetadata = (output, context) => {
     return smithyClient.take(output, {
         createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
@@ -1555,6 +1814,15 @@ const de_QueryLoggingConfigurationMetadata = (output, context) => {
         workspace: smithyClient.expectString,
     });
 };
+const de_RandomCutForestConfiguration = (output, context) => {
+    return smithyClient.take(output, {
+        ignoreNearExpectedFromAbove: (_) => de_IgnoreNearExpected(core$1.awsExpectUnion(_)),
+        ignoreNearExpectedFromBelow: (_) => de_IgnoreNearExpected(core$1.awsExpectUnion(_)),
+        query: smithyClient.expectString,
+        sampleSize: smithyClient.expectInt32,
+        shingleSize: smithyClient.expectInt32,
+    });
+};
 const de_RuleGroupsNamespaceDescription = (output, context) => {
     return smithyClient.take(output, {
         arn: smithyClient.expectString,
@@ -1697,6 +1965,23 @@ class CreateAlertManagerDefinitionCommand extends smithyClient.Command
     .build() {
 }
 
+class CreateAnomalyDetectorCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonPrometheusService", "CreateAnomalyDetector", {})
+    .n("AmpClient", "CreateAnomalyDetectorCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateAnomalyDetectorCommand)
+    .de(de_CreateAnomalyDetectorCommand)
+    .build() {
+}
+
 class CreateLoggingConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
@@ -1799,6 +2084,23 @@ class DeleteAlertManagerDefinitionCommand extends smithyClient.Command
     .build() {
 }
 
+class DeleteAnomalyDetectorCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonPrometheusService", "DeleteAnomalyDetector", {})
+    .n("AmpClient", "DeleteAnomalyDetectorCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteAnomalyDetectorCommand)
+    .de(de_DeleteAnomalyDetectorCommand)
+    .build() {
+}
+
 class DeleteLoggingConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
@@ -1935,6 +2237,23 @@ class DescribeAlertManagerDefinitionCommand extends smithyClient.Command
     .build() {
 }
 
+class DescribeAnomalyDetectorCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonPrometheusService", "DescribeAnomalyDetector", {})
+    .n("AmpClient", "DescribeAnomalyDetectorCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeAnomalyDetectorCommand)
+    .de(de_DescribeAnomalyDetectorCommand)
+    .build() {
+}
+
 class DescribeLoggingConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
@@ -2088,6 +2407,23 @@ class GetDefaultScraperConfigurationCommand extends smithyClient.Command
     .build() {
 }
 
+class ListAnomalyDetectorsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonPrometheusService", "ListAnomalyDetectors", {})
+    .n("AmpClient", "ListAnomalyDetectorsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListAnomalyDetectorsCommand)
+    .de(de_ListAnomalyDetectorsCommand)
+    .build() {
+}
+
 class ListRuleGroupsNamespacesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
@@ -2173,6 +2509,23 @@ class PutAlertManagerDefinitionCommand extends smithyClient.Command
     .build() {
 }
 
+class PutAnomalyDetectorCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonPrometheusService", "PutAnomalyDetector", {})
+    .n("AmpClient", "PutAnomalyDetectorCommand")
+    .f(void 0, void 0)
+    .ser(se_PutAnomalyDetectorCommand)
+    .de(de_PutAnomalyDetectorCommand)
+    .build() {
+}
+
 class PutResourcePolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
@@ -2345,12 +2698,14 @@ class UpdateWorkspaceConfigurationCommand extends smithyClient.Command
 
 const commands = {
     CreateAlertManagerDefinitionCommand,
+    CreateAnomalyDetectorCommand,
     CreateLoggingConfigurationCommand,
     CreateQueryLoggingConfigurationCommand,
     CreateRuleGroupsNamespaceCommand,
     CreateScraperCommand,
     CreateWorkspaceCommand,
     DeleteAlertManagerDefinitionCommand,
+    DeleteAnomalyDetectorCommand,
     DeleteLoggingConfigurationCommand,
     DeleteQueryLoggingConfigurationCommand,
     DeleteResourcePolicyCommand,
@@ -2359,6 +2714,7 @@ const commands = {
     DeleteScraperLoggingConfigurationCommand,
     DeleteWorkspaceCommand,
     DescribeAlertManagerDefinitionCommand,
+    DescribeAnomalyDetectorCommand,
     DescribeLoggingConfigurationCommand,
     DescribeQueryLoggingConfigurationCommand,
     DescribeResourcePolicyCommand,
@@ -2368,11 +2724,13 @@ const commands = {
     DescribeWorkspaceCommand,
     DescribeWorkspaceConfigurationCommand,
     GetDefaultScraperConfigurationCommand,
+    ListAnomalyDetectorsCommand,
     ListRuleGroupsNamespacesCommand,
     ListScrapersCommand,
     ListTagsForResourceCommand,
     ListWorkspacesCommand,
     PutAlertManagerDefinitionCommand,
+    PutAnomalyDetectorCommand,
     PutResourcePolicyCommand,
     PutRuleGroupsNamespaceCommand,
     TagResourceCommand,
@@ -2388,12 +2746,95 @@ class Amp extends AmpClient {
 }
 smithyClient.createAggregatedClient(commands, Amp);
 
+const paginateListAnomalyDetectors = core.createPaginator(AmpClient, ListAnomalyDetectorsCommand, "nextToken", "nextToken", "maxResults");
+
 const paginateListRuleGroupsNamespaces = core.createPaginator(AmpClient, ListRuleGroupsNamespacesCommand, "nextToken", "nextToken", "maxResults");
 
 const paginateListScrapers = core.createPaginator(AmpClient, ListScrapersCommand, "nextToken", "nextToken", "maxResults");
 
 const paginateListWorkspaces = core.createPaginator(AmpClient, ListWorkspacesCommand, "nextToken", "nextToken", "maxResults");
 
+const checkState$5 = 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: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.anomalyDetector.status.statusCode;
+            };
+            if (returnComparator() === "CREATING") {
+                return { state: utilWaiter.WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.anomalyDetector.status.statusCode;
+            };
+            if (returnComparator() === "UPDATING") {
+                return { state: utilWaiter.WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForAnomalyDetectorActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+};
+const waitUntilAnomalyDetectorActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState$4 = 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() === "DELETING") {
+                return { state: utilWaiter.WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForAnomalyDetectorDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+};
+const waitUntilAnomalyDetectorDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return utilWaiter.checkExceptions(result);
+};
+
 const checkState$3 = async (client, input) => {
     let reason;
     try {
@@ -2560,14 +3001,17 @@ exports.AlertManagerDefinitionStatusCode = AlertManagerDefinitionStatusCode;
 exports.Amp = Amp;
 exports.AmpClient = AmpClient;
 exports.AmpServiceException = AmpServiceException;
+exports.AnomalyDetectorStatusCode = AnomalyDetectorStatusCode;
 exports.ConflictException = ConflictException;
 exports.CreateAlertManagerDefinitionCommand = CreateAlertManagerDefinitionCommand;
+exports.CreateAnomalyDetectorCommand = CreateAnomalyDetectorCommand;
 exports.CreateLoggingConfigurationCommand = CreateLoggingConfigurationCommand;
 exports.CreateQueryLoggingConfigurationCommand = CreateQueryLoggingConfigurationCommand;
 exports.CreateRuleGroupsNamespaceCommand = CreateRuleGroupsNamespaceCommand;
 exports.CreateScraperCommand = CreateScraperCommand;
 exports.CreateWorkspaceCommand = CreateWorkspaceCommand;
 exports.DeleteAlertManagerDefinitionCommand = DeleteAlertManagerDefinitionCommand;
+exports.DeleteAnomalyDetectorCommand = DeleteAnomalyDetectorCommand;
 exports.DeleteLoggingConfigurationCommand = DeleteLoggingConfigurationCommand;
 exports.DeleteQueryLoggingConfigurationCommand = DeleteQueryLoggingConfigurationCommand;
 exports.DeleteResourcePolicyCommand = DeleteResourcePolicyCommand;
@@ -2576,6 +3020,7 @@ exports.DeleteScraperCommand = DeleteScraperCommand;
 exports.DeleteScraperLoggingConfigurationCommand = DeleteScraperLoggingConfigurationCommand;
 exports.DeleteWorkspaceCommand = DeleteWorkspaceCommand;
 exports.DescribeAlertManagerDefinitionCommand = DescribeAlertManagerDefinitionCommand;
+exports.DescribeAnomalyDetectorCommand = DescribeAnomalyDetectorCommand;
 exports.DescribeLoggingConfigurationCommand = DescribeLoggingConfigurationCommand;
 exports.DescribeQueryLoggingConfigurationCommand = DescribeQueryLoggingConfigurationCommand;
 exports.DescribeResourcePolicyCommand = DescribeResourcePolicyCommand;
@@ -2586,12 +3031,14 @@ exports.DescribeWorkspaceCommand = DescribeWorkspaceCommand;
 exports.DescribeWorkspaceConfigurationCommand = DescribeWorkspaceConfigurationCommand;
 exports.GetDefaultScraperConfigurationCommand = GetDefaultScraperConfigurationCommand;
 exports.InternalServerException = InternalServerException;
+exports.ListAnomalyDetectorsCommand = ListAnomalyDetectorsCommand;
 exports.ListRuleGroupsNamespacesCommand = ListRuleGroupsNamespacesCommand;
 exports.ListScrapersCommand = ListScrapersCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.ListWorkspacesCommand = ListWorkspacesCommand;
 exports.LoggingConfigurationStatusCode = LoggingConfigurationStatusCode;
 exports.PutAlertManagerDefinitionCommand = PutAlertManagerDefinitionCommand;
+exports.PutAnomalyDetectorCommand = PutAnomalyDetectorCommand;
 exports.PutResourcePolicyCommand = PutResourcePolicyCommand;
 exports.PutRuleGroupsNamespaceCommand = PutRuleGroupsNamespaceCommand;
 exports.QueryLoggingConfigurationStatusCode = QueryLoggingConfigurationStatusCode;
@@ -2615,13 +3062,18 @@ exports.ValidationExceptionReason = ValidationExceptionReason;
 exports.WorkspaceConfigurationStatusCode = WorkspaceConfigurationStatusCode;
 exports.WorkspacePolicyStatusCode = WorkspacePolicyStatusCode;
 exports.WorkspaceStatusCode = WorkspaceStatusCode;
+exports.paginateListAnomalyDetectors = paginateListAnomalyDetectors;
 exports.paginateListRuleGroupsNamespaces = paginateListRuleGroupsNamespaces;
 exports.paginateListScrapers = paginateListScrapers;
 exports.paginateListWorkspaces = paginateListWorkspaces;
+exports.waitForAnomalyDetectorActive = waitForAnomalyDetectorActive;
+exports.waitForAnomalyDetectorDeleted = waitForAnomalyDetectorDeleted;
 exports.waitForScraperActive = waitForScraperActive;
 exports.waitForScraperDeleted = waitForScraperDeleted;
 exports.waitForWorkspaceActive = waitForWorkspaceActive;
 exports.waitForWorkspaceDeleted = waitForWorkspaceDeleted;
+exports.waitUntilAnomalyDetectorActive = waitUntilAnomalyDetectorActive;
+exports.waitUntilAnomalyDetectorDeleted = waitUntilAnomalyDetectorDeleted;
 exports.waitUntilScraperActive = waitUntilScraperActive;
 exports.waitUntilScraperDeleted = waitUntilScraperDeleted;
 exports.waitUntilWorkspaceActive = waitUntilWorkspaceActive;