@aws-sdk/client-resource-explorer-2 3.206.0

package/dist-es/endpoint/ruleset.js

@@ -0,0 +1,248 @@
+export const ruleSet = {
+    version: "1.0",
+    parameters: {
+        Region: {
+            builtIn: "AWS::Region",
+            required: false,
+            documentation: "The AWS region used to dispatch the request.",
+            type: "String",
+        },
+        UseFIPS: {
+            builtIn: "AWS::UseFIPS",
+            required: true,
+            default: false,
+            documentation: "When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.",
+            type: "Boolean",
+        },
+        Endpoint: {
+            builtIn: "SDK::Endpoint",
+            required: false,
+            documentation: "Override the endpoint used to send this request",
+            type: "String",
+        },
+    },
+    rules: [
+        {
+            conditions: [
+                {
+                    fn: "aws.partition",
+                    argv: [
+                        {
+                            ref: "Region",
+                        },
+                    ],
+                    assign: "PartitionResult",
+                },
+            ],
+            type: "tree",
+            rules: [
+                {
+                    conditions: [
+                        {
+                            fn: "isSet",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            fn: "parseURL",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                            assign: "url",
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        {
+                                            ref: "UseFIPS",
+                                        },
+                                        true,
+                                    ],
+                                },
+                            ],
+                            error: "Invalid Configuration: FIPS and custom endpoint are not supported",
+                            type: "error",
+                        },
+                        {
+                            conditions: [],
+                            endpoint: {
+                                url: {
+                                    ref: "Endpoint",
+                                },
+                                properties: {},
+                                headers: {},
+                            },
+                            type: "endpoint",
+                        },
+                    ],
+                },
+                {
+                    conditions: [],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [
+                                        {
+                                            fn: "booleanEquals",
+                                            argv: [
+                                                {
+                                                    ref: "UseFIPS",
+                                                },
+                                                true,
+                                            ],
+                                        },
+                                    ],
+                                    type: "tree",
+                                    rules: [
+                                        {
+                                            conditions: [
+                                                {
+                                                    fn: "booleanEquals",
+                                                    argv: [
+                                                        true,
+                                                        {
+                                                            fn: "getAttr",
+                                                            argv: [
+                                                                {
+                                                                    ref: "PartitionResult",
+                                                                },
+                                                                "supportsFIPS",
+                                                            ],
+                                                        },
+                                                    ],
+                                                },
+                                            ],
+                                            type: "tree",
+                                            rules: [
+                                                {
+                                                    conditions: [],
+                                                    endpoint: {
+                                                        url: "https://resource-explorer-2-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                                        properties: {},
+                                                        headers: {},
+                                                    },
+                                                    type: "endpoint",
+                                                },
+                                            ],
+                                        },
+                                        {
+                                            conditions: [],
+                                            error: "FIPS is enabled but this partition does not support FIPS",
+                                            type: "error",
+                                        },
+                                    ],
+                                },
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://resource-explorer-2.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [
+                                        {
+                                            fn: "booleanEquals",
+                                            argv: [
+                                                {
+                                                    ref: "UseFIPS",
+                                                },
+                                                true,
+                                            ],
+                                        },
+                                    ],
+                                    type: "tree",
+                                    rules: [
+                                        {
+                                            conditions: [
+                                                {
+                                                    fn: "booleanEquals",
+                                                    argv: [
+                                                        true,
+                                                        {
+                                                            fn: "getAttr",
+                                                            argv: [
+                                                                {
+                                                                    ref: "PartitionResult",
+                                                                },
+                                                                "supportsFIPS",
+                                                            ],
+                                                        },
+                                                    ],
+                                                },
+                                            ],
+                                            type: "tree",
+                                            rules: [
+                                                {
+                                                    conditions: [],
+                                                    endpoint: {
+                                                        url: "https://resource-explorer-2-fips.{Region}.{PartitionResult#dnsSuffix}",
+                                                        properties: {},
+                                                        headers: {},
+                                                    },
+                                                    type: "endpoint",
+                                                },
+                                            ],
+                                        },
+                                        {
+                                            conditions: [],
+                                            error: "FIPS is enabled but this partition does not support FIPS",
+                                            type: "error",
+                                        },
+                                    ],
+                                },
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://resource-explorer-2.{Region}.{PartitionResult#dnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+};

package/dist-es/index.js

@@ -0,0 +1,6 @@
+export * from "./ResourceExplorer2";
+export * from "./ResourceExplorer2Client";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export { ResourceExplorer2ServiceException } from "./models/ResourceExplorer2ServiceException";

package/dist-es/models/ResourceExplorer2ServiceException.js

@@ -0,0 +1,7 @@
+import { ServiceException as __ServiceException, } from "@aws-sdk/smithy-client";
+export class ResourceExplorer2ServiceException extends __ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, ResourceExplorer2ServiceException.prototype);
+    }
+}

package/dist-es/models/index.js

@@ -0,0 +1 @@
+export * from "./models_0";

package/dist-es/models/models_0.js

@@ -0,0 +1,262 @@
+import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
+import { ResourceExplorer2ServiceException as __BaseException } from "./ResourceExplorer2ServiceException";
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.Message = opts.Message;
+        this.FieldList = opts.FieldList;
+    }
+}
+export class UnauthorizedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "UnauthorizedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "UnauthorizedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, UnauthorizedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export var IndexState;
+(function (IndexState) {
+    IndexState["ACTIVE"] = "ACTIVE";
+    IndexState["CREATING"] = "CREATING";
+    IndexState["DELETED"] = "DELETED";
+    IndexState["DELETING"] = "DELETING";
+    IndexState["UPDATING"] = "UPDATING";
+})(IndexState || (IndexState = {}));
+export var IndexType;
+(function (IndexType) {
+    IndexType["AGGREGATOR"] = "AGGREGATOR";
+    IndexType["LOCAL"] = "LOCAL";
+})(IndexType || (IndexType = {}));
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.Message = opts.Message;
+        this.Name = opts.Name;
+        this.Value = opts.Value;
+    }
+}
+export const AssociateDefaultViewInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AssociateDefaultViewOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ValidationExceptionFieldFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BatchGetViewInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BatchGetViewErrorFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SearchFilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const IncludedPropertyFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ViewFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Filters && { Filters: SENSITIVE_STRING }),
+});
+export const BatchGetViewOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Views && { Views: obj.Views.map((item) => ViewFilterSensitiveLog(item)) }),
+});
+export const CreateIndexInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateIndexOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteIndexInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteIndexOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListIndexesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const IndexFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListIndexesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateIndexTypeInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateIndexTypeOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateViewInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Filters && { Filters: SENSITIVE_STRING }),
+});
+export const CreateViewOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.View && { View: ViewFilterSensitiveLog(obj.View) }),
+});
+export const DeleteViewInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteViewOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetViewInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetViewOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.View && { View: ViewFilterSensitiveLog(obj.View) }),
+});
+export const ListViewsInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListViewsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateViewInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Filters && { Filters: SENSITIVE_STRING }),
+});
+export const UpdateViewOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.View && { View: ViewFilterSensitiveLog(obj.View) }),
+});
+export const GetDefaultViewOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetIndexOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSupportedResourceTypesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SupportedResourceTypeFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSupportedResourceTypesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListTagsForResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListTagsForResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ResourcePropertyFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ResourceFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ResourceCountFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SearchInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.QueryString && { QueryString: SENSITIVE_STRING }),
+});
+export const SearchOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TagResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TagResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UntagResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UntagResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/ListIndexesPaginator.js

@@ -0,0 +1,32 @@
+import { ListIndexesCommand } from "../commands/ListIndexesCommand";
+import { ResourceExplorer2 } from "../ResourceExplorer2";
+import { ResourceExplorer2Client } from "../ResourceExplorer2Client";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListIndexesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listIndexes(input, ...args);
+};
+export async function* paginateListIndexes(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof ResourceExplorer2) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ResourceExplorer2Client) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ResourceExplorer2 | ResourceExplorer2Client");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListSupportedResourceTypesPaginator.js

@@ -0,0 +1,32 @@
+import { ListSupportedResourceTypesCommand, } from "../commands/ListSupportedResourceTypesCommand";
+import { ResourceExplorer2 } from "../ResourceExplorer2";
+import { ResourceExplorer2Client } from "../ResourceExplorer2Client";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSupportedResourceTypesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listSupportedResourceTypes(input, ...args);
+};
+export async function* paginateListSupportedResourceTypes(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof ResourceExplorer2) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ResourceExplorer2Client) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ResourceExplorer2 | ResourceExplorer2Client");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListViewsPaginator.js

@@ -0,0 +1,32 @@
+import { ListViewsCommand } from "../commands/ListViewsCommand";
+import { ResourceExplorer2 } from "../ResourceExplorer2";
+import { ResourceExplorer2Client } from "../ResourceExplorer2Client";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListViewsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listViews(input, ...args);
+};
+export async function* paginateListViews(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof ResourceExplorer2) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ResourceExplorer2Client) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ResourceExplorer2 | ResourceExplorer2Client");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/SearchPaginator.js

@@ -0,0 +1,32 @@
+import { SearchCommand } from "../commands/SearchCommand";
+import { ResourceExplorer2 } from "../ResourceExplorer2";
+import { ResourceExplorer2Client } from "../ResourceExplorer2Client";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new SearchCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.search(input, ...args);
+};
+export async function* paginateSearch(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof ResourceExplorer2) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ResourceExplorer2Client) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ResourceExplorer2 | ResourceExplorer2Client");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -0,0 +1,5 @@
+export * from "./Interfaces";
+export * from "./ListIndexesPaginator";
+export * from "./ListSupportedResourceTypesPaginator";
+export * from "./ListViewsPaginator";
+export * from "./SearchPaginator";