@aws-sdk/client-amp 3.454.0 → 3.460.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,8 +1,9 @@
+import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
+import { _json, collectBody, convertMap, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { AmpServiceException as __BaseException } from "../models/AmpServiceException";
-import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ScrapeConfiguration, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
 export const se_CreateAlertManagerDefinitionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -73,6 +74,31 @@ export const se_CreateRuleGroupsNamespaceCommand = async (input, context) => {
         body,
     });
 };
+export const se_CreateScraperCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/scrapers";
+    let body;
+    body = JSON.stringify(take(input, {
+        alias: [],
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        destination: (_) => _json(_),
+        scrapeConfiguration: (_) => se_ScrapeConfiguration(_, context),
+        source: (_) => _json(_),
+        tags: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_CreateWorkspaceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -158,6 +184,26 @@ export const se_DeleteRuleGroupsNamespaceCommand = async (input, context) => {
         body,
     });
 };
+export const se_DeleteScraperCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/scrapers/{scraperId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "scraperId", () => input.scraperId, "{scraperId}", false);
+    const query = map({
+        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_DeleteWorkspaceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -229,6 +275,22 @@ export const se_DescribeRuleGroupsNamespaceCommand = async (input, context) => {
         body,
     });
 };
+export const se_DescribeScraperCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/scrapers/{scraperId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "scraperId", () => input.scraperId, "{scraperId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DescribeWorkspaceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -245,6 +307,24 @@ export const se_DescribeWorkspaceCommand = async (input, context) => {
         body,
     });
 };
+export const se_GetDefaultScraperConfigurationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/scraperconfiguration";
+    let body;
+    body = "";
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_ListRuleGroupsNamespacesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -268,6 +348,27 @@ export const se_ListRuleGroupsNamespacesCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListScrapersCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/scrapers";
+    const query = map({
+        ...convertMap(input.filters),
+        nextToken: [, input.nextToken],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListTagsForResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -587,6 +688,60 @@ const de_CreateRuleGroupsNamespaceCommandError = async (output, context) => {
             });
     }
 };
+export const de_CreateScraperCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_CreateScraperCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        arn: __expectString,
+        scraperId: __expectString,
+        status: _json,
+        tags: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CreateScraperCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.amp#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.amp#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.amp#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.amp#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.amp#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.amp#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.amp#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_CreateWorkspaceCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
         return de_CreateWorkspaceCommandError(output, context);
@@ -767,6 +922,55 @@ const de_DeleteRuleGroupsNamespaceCommandError = async (output, context) => {
             });
     }
 };
+export const de_DeleteScraperCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_DeleteScraperCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        scraperId: __expectString,
+        status: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DeleteScraperCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.amp#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.amp#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.amp#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.amp#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.amp#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.amp#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_DeleteWorkspaceCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
         return de_DeleteWorkspaceCommandError(output, context);
@@ -943,6 +1147,51 @@ const de_DescribeRuleGroupsNamespaceCommandError = async (output, context) => {
             });
     }
 };
+export const de_DescribeScraperCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DescribeScraperCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        scraper: (_) => de_ScraperDescription(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DescribeScraperCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.amp#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.amp#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.amp#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.amp#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.amp#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_DescribeWorkspaceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_DescribeWorkspaceCommandError(output, context);
@@ -988,6 +1237,45 @@ const de_DescribeWorkspaceCommandError = async (output, context) => {
             });
     }
 };
+export const de_GetDefaultScraperConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetDefaultScraperConfigurationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        configuration: context.base64Decoder,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetDefaultScraperConfigurationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.amp#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.amp#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.amp#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListRuleGroupsNamespacesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListRuleGroupsNamespacesCommandError(output, context);
@@ -1034,6 +1322,49 @@ const de_ListRuleGroupsNamespacesCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListScrapersCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListScrapersCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        nextToken: __expectString,
+        scrapers: (_) => de_ScraperSummaryList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListScrapersCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.amp#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.amp#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.amp#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.amp#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListTagsForResourceCommandError(output, context);
@@ -1515,6 +1846,12 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const se_ScrapeConfiguration = (input, context) => {
+    return ScrapeConfiguration.visit(input, {
+        configurationBlob: (value) => ({ configurationBlob: context.base64Encoder(value) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
 const de_AlertManagerDefinitionDescription = (output, context) => {
     return take(output, {
         createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
@@ -1561,6 +1898,53 @@ const de_RuleGroupsNamespaceSummaryList = (output, context) => {
     });
     return retVal;
 };
+const de_ScrapeConfiguration = (output, context) => {
+    if (output.configurationBlob != null) {
+        return {
+            configurationBlob: context.base64Decoder(output.configurationBlob),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_ScraperDescription = (output, context) => {
+    return take(output, {
+        alias: __expectString,
+        arn: __expectString,
+        createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        destination: (_) => _json(__expectUnion(_)),
+        lastModifiedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        roleArn: __expectString,
+        scrapeConfiguration: (_) => de_ScrapeConfiguration(__expectUnion(_), context),
+        scraperId: __expectString,
+        source: (_) => _json(__expectUnion(_)),
+        status: _json,
+        statusReason: __expectString,
+        tags: _json,
+    });
+};
+const de_ScraperSummary = (output, context) => {
+    return take(output, {
+        alias: __expectString,
+        arn: __expectString,
+        createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        destination: (_) => _json(__expectUnion(_)),
+        lastModifiedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        roleArn: __expectString,
+        scraperId: __expectString,
+        source: (_) => _json(__expectUnion(_)),
+        status: _json,
+        statusReason: __expectString,
+        tags: _json,
+    });
+};
+const de_ScraperSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ScraperSummary(entry, context);
+    });
+    return retVal;
+};
 const de_WorkspaceDescription = (output, context) => {
     return take(output, {
         alias: __expectString,

package/dist-es/waiters/index.js

@@ -1,2 +1,4 @@
+export * from "./waitForScraperActive";
+export * from "./waitForScraperDeleted";
 export * from "./waitForWorkspaceActive";
 export * from "./waitForWorkspaceDeleted";

package/dist-es/waiters/waitForScraperActive.js

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

package/dist-es/waiters/waitForScraperDeleted.js

@@ -0,0 +1,34 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeScraperCommand } from "../commands/DescribeScraperCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeScraperCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.scraper.status.statusCode;
+            };
+            if (returnComparator() === "DELETION_FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForScraperDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilScraperDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-types/Amp.d.ts

@@ -3,16 +3,21 @@ import { AmpClient } from "./AmpClient";
 import { CreateAlertManagerDefinitionCommandInput, CreateAlertManagerDefinitionCommandOutput } from "./commands/CreateAlertManagerDefinitionCommand";
 import { CreateLoggingConfigurationCommandInput, CreateLoggingConfigurationCommandOutput } from "./commands/CreateLoggingConfigurationCommand";
 import { CreateRuleGroupsNamespaceCommandInput, CreateRuleGroupsNamespaceCommandOutput } from "./commands/CreateRuleGroupsNamespaceCommand";
+import { CreateScraperCommandInput, CreateScraperCommandOutput } from "./commands/CreateScraperCommand";
 import { CreateWorkspaceCommandInput, CreateWorkspaceCommandOutput } from "./commands/CreateWorkspaceCommand";
 import { DeleteAlertManagerDefinitionCommandInput, DeleteAlertManagerDefinitionCommandOutput } from "./commands/DeleteAlertManagerDefinitionCommand";
 import { DeleteLoggingConfigurationCommandInput, DeleteLoggingConfigurationCommandOutput } from "./commands/DeleteLoggingConfigurationCommand";
 import { DeleteRuleGroupsNamespaceCommandInput, DeleteRuleGroupsNamespaceCommandOutput } from "./commands/DeleteRuleGroupsNamespaceCommand";
+import { DeleteScraperCommandInput, DeleteScraperCommandOutput } from "./commands/DeleteScraperCommand";
 import { DeleteWorkspaceCommandInput, DeleteWorkspaceCommandOutput } from "./commands/DeleteWorkspaceCommand";
 import { DescribeAlertManagerDefinitionCommandInput, DescribeAlertManagerDefinitionCommandOutput } from "./commands/DescribeAlertManagerDefinitionCommand";
 import { DescribeLoggingConfigurationCommandInput, DescribeLoggingConfigurationCommandOutput } from "./commands/DescribeLoggingConfigurationCommand";
 import { DescribeRuleGroupsNamespaceCommandInput, DescribeRuleGroupsNamespaceCommandOutput } from "./commands/DescribeRuleGroupsNamespaceCommand";
+import { DescribeScraperCommandInput, DescribeScraperCommandOutput } from "./commands/DescribeScraperCommand";
 import { DescribeWorkspaceCommandInput, DescribeWorkspaceCommandOutput } from "./commands/DescribeWorkspaceCommand";
+import { GetDefaultScraperConfigurationCommandInput, GetDefaultScraperConfigurationCommandOutput } from "./commands/GetDefaultScraperConfigurationCommand";
 import { ListRuleGroupsNamespacesCommandInput, ListRuleGroupsNamespacesCommandOutput } from "./commands/ListRuleGroupsNamespacesCommand";
+import { ListScrapersCommandInput, ListScrapersCommandOutput } from "./commands/ListScrapersCommand";
 import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "./commands/ListTagsForResourceCommand";
 import { ListWorkspacesCommandInput, ListWorkspacesCommandOutput } from "./commands/ListWorkspacesCommand";
 import { PutAlertManagerDefinitionCommandInput, PutAlertManagerDefinitionCommandOutput } from "./commands/PutAlertManagerDefinitionCommand";
@@ -40,6 +45,12 @@ export interface Amp {
     createRuleGroupsNamespace(args: CreateRuleGroupsNamespaceCommandInput, options?: __HttpHandlerOptions): Promise<CreateRuleGroupsNamespaceCommandOutput>;
     createRuleGroupsNamespace(args: CreateRuleGroupsNamespaceCommandInput, cb: (err: any, data?: CreateRuleGroupsNamespaceCommandOutput) => void): void;
     createRuleGroupsNamespace(args: CreateRuleGroupsNamespaceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateRuleGroupsNamespaceCommandOutput) => void): void;
+    /**
+     * @see {@link CreateScraperCommand}
+     */
+    createScraper(args: CreateScraperCommandInput, options?: __HttpHandlerOptions): Promise<CreateScraperCommandOutput>;
+    createScraper(args: CreateScraperCommandInput, cb: (err: any, data?: CreateScraperCommandOutput) => void): void;
+    createScraper(args: CreateScraperCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateScraperCommandOutput) => void): void;
     /**
      * @see {@link CreateWorkspaceCommand}
      */
@@ -64,6 +75,12 @@ export interface Amp {
     deleteRuleGroupsNamespace(args: DeleteRuleGroupsNamespaceCommandInput, options?: __HttpHandlerOptions): Promise<DeleteRuleGroupsNamespaceCommandOutput>;
     deleteRuleGroupsNamespace(args: DeleteRuleGroupsNamespaceCommandInput, cb: (err: any, data?: DeleteRuleGroupsNamespaceCommandOutput) => void): void;
     deleteRuleGroupsNamespace(args: DeleteRuleGroupsNamespaceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteRuleGroupsNamespaceCommandOutput) => void): void;
+    /**
+     * @see {@link DeleteScraperCommand}
+     */
+    deleteScraper(args: DeleteScraperCommandInput, options?: __HttpHandlerOptions): Promise<DeleteScraperCommandOutput>;
+    deleteScraper(args: DeleteScraperCommandInput, cb: (err: any, data?: DeleteScraperCommandOutput) => void): void;
+    deleteScraper(args: DeleteScraperCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteScraperCommandOutput) => void): void;
     /**
      * @see {@link DeleteWorkspaceCommand}
      */
@@ -88,18 +105,36 @@ export interface Amp {
     describeRuleGroupsNamespace(args: DescribeRuleGroupsNamespaceCommandInput, options?: __HttpHandlerOptions): Promise<DescribeRuleGroupsNamespaceCommandOutput>;
     describeRuleGroupsNamespace(args: DescribeRuleGroupsNamespaceCommandInput, cb: (err: any, data?: DescribeRuleGroupsNamespaceCommandOutput) => void): void;
     describeRuleGroupsNamespace(args: DescribeRuleGroupsNamespaceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeRuleGroupsNamespaceCommandOutput) => void): void;
+    /**
+     * @see {@link DescribeScraperCommand}
+     */
+    describeScraper(args: DescribeScraperCommandInput, options?: __HttpHandlerOptions): Promise<DescribeScraperCommandOutput>;
+    describeScraper(args: DescribeScraperCommandInput, cb: (err: any, data?: DescribeScraperCommandOutput) => void): void;
+    describeScraper(args: DescribeScraperCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeScraperCommandOutput) => void): void;
     /**
      * @see {@link DescribeWorkspaceCommand}
      */
     describeWorkspace(args: DescribeWorkspaceCommandInput, options?: __HttpHandlerOptions): Promise<DescribeWorkspaceCommandOutput>;
     describeWorkspace(args: DescribeWorkspaceCommandInput, cb: (err: any, data?: DescribeWorkspaceCommandOutput) => void): void;
     describeWorkspace(args: DescribeWorkspaceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeWorkspaceCommandOutput) => void): void;
+    /**
+     * @see {@link GetDefaultScraperConfigurationCommand}
+     */
+    getDefaultScraperConfiguration(args: GetDefaultScraperConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<GetDefaultScraperConfigurationCommandOutput>;
+    getDefaultScraperConfiguration(args: GetDefaultScraperConfigurationCommandInput, cb: (err: any, data?: GetDefaultScraperConfigurationCommandOutput) => void): void;
+    getDefaultScraperConfiguration(args: GetDefaultScraperConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDefaultScraperConfigurationCommandOutput) => void): void;
     /**
      * @see {@link ListRuleGroupsNamespacesCommand}
      */
     listRuleGroupsNamespaces(args: ListRuleGroupsNamespacesCommandInput, options?: __HttpHandlerOptions): Promise<ListRuleGroupsNamespacesCommandOutput>;
     listRuleGroupsNamespaces(args: ListRuleGroupsNamespacesCommandInput, cb: (err: any, data?: ListRuleGroupsNamespacesCommandOutput) => void): void;
     listRuleGroupsNamespaces(args: ListRuleGroupsNamespacesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListRuleGroupsNamespacesCommandOutput) => void): void;
+    /**
+     * @see {@link ListScrapersCommand}
+     */
+    listScrapers(args: ListScrapersCommandInput, options?: __HttpHandlerOptions): Promise<ListScrapersCommandOutput>;
+    listScrapers(args: ListScrapersCommandInput, cb: (err: any, data?: ListScrapersCommandOutput) => void): void;
+    listScrapers(args: ListScrapersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListScrapersCommandOutput) => void): void;
     /**
      * @see {@link ListTagsForResourceCommand}
      */