@aws-sdk/client-mgn 3.295.0 → 3.297.0

package/dist-es/Mgn.js

@@ -28,6 +28,10 @@ import { GetLaunchConfigurationCommand, } from "./commands/GetLaunchConfiguratio
 import { GetReplicationConfigurationCommand, } from "./commands/GetReplicationConfigurationCommand";
 import { InitializeServiceCommand, } from "./commands/InitializeServiceCommand";
 import { ListApplicationsCommand, } from "./commands/ListApplicationsCommand";
+import { ListExportErrorsCommand, } from "./commands/ListExportErrorsCommand";
+import { ListExportsCommand } from "./commands/ListExportsCommand";
+import { ListImportErrorsCommand, } from "./commands/ListImportErrorsCommand";
+import { ListImportsCommand } from "./commands/ListImportsCommand";
 import { ListSourceServerActionsCommand, } from "./commands/ListSourceServerActionsCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
 import { ListTemplateActionsCommand, } from "./commands/ListTemplateActionsCommand";
@@ -39,6 +43,8 @@ import { RemoveSourceServerActionCommand, } from "./commands/RemoveSourceServerA
 import { RemoveTemplateActionCommand, } from "./commands/RemoveTemplateActionCommand";
 import { RetryDataReplicationCommand, } from "./commands/RetryDataReplicationCommand";
 import { StartCutoverCommand, } from "./commands/StartCutoverCommand";
+import { StartExportCommand } from "./commands/StartExportCommand";
+import { StartImportCommand } from "./commands/StartImportCommand";
 import { StartReplicationCommand, } from "./commands/StartReplicationCommand";
 import { StartTestCommand } from "./commands/StartTestCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
@@ -475,6 +481,62 @@ export class Mgn extends MgnClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listExportErrors(args, optionsOrCb, cb) {
+        const command = new ListExportErrorsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listExports(args, optionsOrCb, cb) {
+        const command = new ListExportsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listImportErrors(args, optionsOrCb, cb) {
+        const command = new ListImportErrorsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listImports(args, optionsOrCb, cb) {
+        const command = new ListImportsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listSourceServerActions(args, optionsOrCb, cb) {
         const command = new ListSourceServerActionsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -629,6 +691,34 @@ export class Mgn extends MgnClient {
             return this.send(command, optionsOrCb);
         }
     }
+    startExport(args, optionsOrCb, cb) {
+        const command = new StartExportCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    startImport(args, optionsOrCb, cb) {
+        const command = new StartImportCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     startReplication(args, optionsOrCb, cb) {
         const command = new StartReplicationCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/ListExportErrorsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListExportErrorsRequestFilterSensitiveLog, ListExportErrorsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListExportErrorsCommand, serializeAws_restJson1ListExportErrorsCommand, } from "../protocols/Aws_restJson1";
+export class ListExportErrorsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListExportErrorsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "ListExportErrorsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListExportErrorsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListExportErrorsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListExportErrorsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListExportErrorsCommand(output, context);
+    }
+}

package/dist-es/commands/ListExportsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListExportsRequestFilterSensitiveLog, ListExportsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListExportsCommand, serializeAws_restJson1ListExportsCommand, } from "../protocols/Aws_restJson1";
+export class ListExportsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListExportsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "ListExportsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListExportsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListExportsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListExportsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListExportsCommand(output, context);
+    }
+}

package/dist-es/commands/ListImportErrorsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListImportErrorsRequestFilterSensitiveLog, ListImportErrorsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListImportErrorsCommand, serializeAws_restJson1ListImportErrorsCommand, } from "../protocols/Aws_restJson1";
+export class ListImportErrorsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListImportErrorsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "ListImportErrorsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListImportErrorsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListImportErrorsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListImportErrorsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListImportErrorsCommand(output, context);
+    }
+}

package/dist-es/commands/ListImportsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListImportsRequestFilterSensitiveLog, ListImportsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListImportsCommand, serializeAws_restJson1ListImportsCommand, } from "../protocols/Aws_restJson1";
+export class ListImportsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListImportsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "ListImportsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListImportsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListImportsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListImportsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListImportsCommand(output, context);
+    }
+}

package/dist-es/commands/StartExportCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartExportRequestFilterSensitiveLog, StartExportResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartExportCommand, serializeAws_restJson1StartExportCommand, } from "../protocols/Aws_restJson1";
+export class StartExportCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartExportCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "StartExportCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartExportRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartExportResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartExportCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartExportCommand(output, context);
+    }
+}

package/dist-es/commands/StartImportCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartImportRequestFilterSensitiveLog, StartImportResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartImportCommand, serializeAws_restJson1StartImportCommand, } from "../protocols/Aws_restJson1";
+export class StartImportCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartImportCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "StartImportCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartImportRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartImportResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartImportCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartImportCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -28,6 +28,10 @@ export * from "./GetLaunchConfigurationCommand";
 export * from "./GetReplicationConfigurationCommand";
 export * from "./InitializeServiceCommand";
 export * from "./ListApplicationsCommand";
+export * from "./ListExportErrorsCommand";
+export * from "./ListExportsCommand";
+export * from "./ListImportErrorsCommand";
+export * from "./ListImportsCommand";
 export * from "./ListSourceServerActionsCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./ListTemplateActionsCommand";
@@ -39,6 +43,8 @@ export * from "./RemoveSourceServerActionCommand";
 export * from "./RemoveTemplateActionCommand";
 export * from "./RetryDataReplicationCommand";
 export * from "./StartCutoverCommand";
+export * from "./StartExportCommand";
+export * from "./StartImportCommand";
 export * from "./StartReplicationCommand";
 export * from "./StartTestCommand";
 export * from "./TagResourceCommand";

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
-const p = "required", q = "fn", r = "argv", s = "ref";
-const a = "PartitionResult", b = "tree", c = "error", d = "endpoint", e = { [p]: false, "type": "String" }, f = { [p]: true, "default": false, "type": "Boolean" }, g = { [s]: "Endpoint" }, h = { [q]: "booleanEquals", [r]: [{ [s]: "UseFIPS" }, true] }, i = { [q]: "booleanEquals", [r]: [{ [s]: "UseDualStack" }, true] }, j = {}, k = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: a }, "supportsFIPS"] }] }, l = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: a }, "supportsDualStack"] }] }, m = [g], n = [h], o = [i];
-const _data = { version: "1.0", parameters: { Region: e, UseDualStack: f, UseFIPS: f, Endpoint: e }, rules: [{ conditions: [{ [q]: "aws.partition", [r]: [{ [s]: "Region" }], assign: a }], type: b, rules: [{ conditions: [{ [q]: "isSet", [r]: m }, { [q]: "parseURL", [r]: m, assign: "url" }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: g, properties: j, headers: j }, type: d }] }] }, { conditions: [h, i], type: b, rules: [{ conditions: [k, l], type: b, rules: [{ endpoint: { url: "https://mgn-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: j, headers: j }, type: d }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [k], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://mgn-fips.{Region}.{PartitionResult#dnsSuffix}", properties: j, headers: j }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [l], type: b, rules: [{ endpoint: { url: "https://mgn.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: j, headers: j }, type: d }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { endpoint: { url: "https://mgn.{Region}.{PartitionResult#dnsSuffix}", properties: j, headers: j }, type: d }] }] };
+const q = "required", r = "fn", s = "argv", t = "ref";
+const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = { [q]: false, "type": "String" }, g = { [q]: true, "default": false, "type": "Boolean" }, h = { [t]: "Endpoint" }, i = { [r]: "booleanEquals", [s]: [{ [t]: "UseFIPS" }, true] }, j = { [r]: "booleanEquals", [s]: [{ [t]: "UseDualStack" }, true] }, k = {}, l = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsFIPS"] }] }, m = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsDualStack"] }] }, n = [i], o = [j], p = [{ [t]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: f, UseDualStack: g, UseFIPS: g, Endpoint: f }, rules: [{ conditions: [{ [r]: a, [s]: [h] }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: h, properties: k, headers: k }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [r]: a, [s]: p }], type: b, rules: [{ conditions: [{ [r]: "aws.partition", [s]: p, assign: e }], type: b, rules: [{ conditions: [i, j], type: b, rules: [{ conditions: [l, m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://mgn-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [l], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://mgn-fips.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://mgn.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://mgn.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
 export const ruleSet = _data;