@aws-sdk/client-backup-gateway 3.231.0 → 3.234.0

package/dist-es/BackupGateway.js

@@ -4,14 +4,20 @@ import { CreateGatewayCommand, } from "./commands/CreateGatewayCommand";
 import { DeleteGatewayCommand, } from "./commands/DeleteGatewayCommand";
 import { DeleteHypervisorCommand, } from "./commands/DeleteHypervisorCommand";
 import { DisassociateGatewayFromServerCommand, } from "./commands/DisassociateGatewayFromServerCommand";
+import { GetBandwidthRateLimitScheduleCommand, } from "./commands/GetBandwidthRateLimitScheduleCommand";
 import { GetGatewayCommand } from "./commands/GetGatewayCommand";
+import { GetHypervisorCommand, } from "./commands/GetHypervisorCommand";
+import { GetHypervisorPropertyMappingsCommand, } from "./commands/GetHypervisorPropertyMappingsCommand";
 import { GetVirtualMachineCommand, } from "./commands/GetVirtualMachineCommand";
 import { ImportHypervisorConfigurationCommand, } from "./commands/ImportHypervisorConfigurationCommand";
 import { ListGatewaysCommand, } from "./commands/ListGatewaysCommand";
 import { ListHypervisorsCommand, } from "./commands/ListHypervisorsCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
 import { ListVirtualMachinesCommand, } from "./commands/ListVirtualMachinesCommand";
+import { PutBandwidthRateLimitScheduleCommand, } from "./commands/PutBandwidthRateLimitScheduleCommand";
+import { PutHypervisorPropertyMappingsCommand, } from "./commands/PutHypervisorPropertyMappingsCommand";
 import { PutMaintenanceStartTimeCommand, } from "./commands/PutMaintenanceStartTimeCommand";
+import { StartVirtualMachinesMetadataSyncCommand, } from "./commands/StartVirtualMachinesMetadataSyncCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { TestHypervisorConfigurationCommand, } from "./commands/TestHypervisorConfigurationCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
@@ -89,6 +95,20 @@ export class BackupGateway extends BackupGatewayClient {
             return this.send(command, optionsOrCb);
         }
     }
+    getBandwidthRateLimitSchedule(args, optionsOrCb, cb) {
+        const command = new GetBandwidthRateLimitScheduleCommand(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);
+        }
+    }
     getGateway(args, optionsOrCb, cb) {
         const command = new GetGatewayCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -103,6 +123,34 @@ export class BackupGateway extends BackupGatewayClient {
             return this.send(command, optionsOrCb);
         }
     }
+    getHypervisor(args, optionsOrCb, cb) {
+        const command = new GetHypervisorCommand(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);
+        }
+    }
+    getHypervisorPropertyMappings(args, optionsOrCb, cb) {
+        const command = new GetHypervisorPropertyMappingsCommand(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);
+        }
+    }
     getVirtualMachine(args, optionsOrCb, cb) {
         const command = new GetVirtualMachineCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -187,6 +235,34 @@ export class BackupGateway extends BackupGatewayClient {
             return this.send(command, optionsOrCb);
         }
     }
+    putBandwidthRateLimitSchedule(args, optionsOrCb, cb) {
+        const command = new PutBandwidthRateLimitScheduleCommand(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);
+        }
+    }
+    putHypervisorPropertyMappings(args, optionsOrCb, cb) {
+        const command = new PutHypervisorPropertyMappingsCommand(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);
+        }
+    }
     putMaintenanceStartTime(args, optionsOrCb, cb) {
         const command = new PutMaintenanceStartTimeCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -201,6 +277,20 @@ export class BackupGateway extends BackupGatewayClient {
             return this.send(command, optionsOrCb);
         }
     }
+    startVirtualMachinesMetadataSync(args, optionsOrCb, cb) {
+        const command = new StartVirtualMachinesMetadataSyncCommand(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);
+        }
+    }
     tagResource(args, optionsOrCb, cb) {
         const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/GetBandwidthRateLimitScheduleCommand.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 { GetBandwidthRateLimitScheduleInputFilterSensitiveLog, GetBandwidthRateLimitScheduleOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetBandwidthRateLimitScheduleCommand, serializeAws_json1_0GetBandwidthRateLimitScheduleCommand, } from "../protocols/Aws_json1_0";
+export class GetBandwidthRateLimitScheduleCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetBandwidthRateLimitScheduleCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "BackupGatewayClient";
+        const commandName = "GetBandwidthRateLimitScheduleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetBandwidthRateLimitScheduleInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetBandwidthRateLimitScheduleOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetBandwidthRateLimitScheduleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetBandwidthRateLimitScheduleCommand(output, context);
+    }
+}

package/dist-es/commands/GetHypervisorCommand.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 { GetHypervisorInputFilterSensitiveLog, GetHypervisorOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetHypervisorCommand, serializeAws_json1_0GetHypervisorCommand, } from "../protocols/Aws_json1_0";
+export class GetHypervisorCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetHypervisorCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "BackupGatewayClient";
+        const commandName = "GetHypervisorCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetHypervisorInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetHypervisorOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetHypervisorCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetHypervisorCommand(output, context);
+    }
+}

package/dist-es/commands/GetHypervisorPropertyMappingsCommand.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 { GetHypervisorPropertyMappingsInputFilterSensitiveLog, GetHypervisorPropertyMappingsOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetHypervisorPropertyMappingsCommand, serializeAws_json1_0GetHypervisorPropertyMappingsCommand, } from "../protocols/Aws_json1_0";
+export class GetHypervisorPropertyMappingsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetHypervisorPropertyMappingsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "BackupGatewayClient";
+        const commandName = "GetHypervisorPropertyMappingsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetHypervisorPropertyMappingsInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetHypervisorPropertyMappingsOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetHypervisorPropertyMappingsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetHypervisorPropertyMappingsCommand(output, context);
+    }
+}

package/dist-es/commands/PutBandwidthRateLimitScheduleCommand.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 { PutBandwidthRateLimitScheduleInputFilterSensitiveLog, PutBandwidthRateLimitScheduleOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0PutBandwidthRateLimitScheduleCommand, serializeAws_json1_0PutBandwidthRateLimitScheduleCommand, } from "../protocols/Aws_json1_0";
+export class PutBandwidthRateLimitScheduleCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PutBandwidthRateLimitScheduleCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "BackupGatewayClient";
+        const commandName = "PutBandwidthRateLimitScheduleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: PutBandwidthRateLimitScheduleInputFilterSensitiveLog,
+            outputFilterSensitiveLog: PutBandwidthRateLimitScheduleOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0PutBandwidthRateLimitScheduleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0PutBandwidthRateLimitScheduleCommand(output, context);
+    }
+}

package/dist-es/commands/PutHypervisorPropertyMappingsCommand.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 { PutHypervisorPropertyMappingsInputFilterSensitiveLog, PutHypervisorPropertyMappingsOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0PutHypervisorPropertyMappingsCommand, serializeAws_json1_0PutHypervisorPropertyMappingsCommand, } from "../protocols/Aws_json1_0";
+export class PutHypervisorPropertyMappingsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PutHypervisorPropertyMappingsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "BackupGatewayClient";
+        const commandName = "PutHypervisorPropertyMappingsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: PutHypervisorPropertyMappingsInputFilterSensitiveLog,
+            outputFilterSensitiveLog: PutHypervisorPropertyMappingsOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0PutHypervisorPropertyMappingsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0PutHypervisorPropertyMappingsCommand(output, context);
+    }
+}

package/dist-es/commands/StartVirtualMachinesMetadataSyncCommand.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 { StartVirtualMachinesMetadataSyncInputFilterSensitiveLog, StartVirtualMachinesMetadataSyncOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0StartVirtualMachinesMetadataSyncCommand, serializeAws_json1_0StartVirtualMachinesMetadataSyncCommand, } from "../protocols/Aws_json1_0";
+export class StartVirtualMachinesMetadataSyncCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartVirtualMachinesMetadataSyncCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "BackupGatewayClient";
+        const commandName = "StartVirtualMachinesMetadataSyncCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartVirtualMachinesMetadataSyncInputFilterSensitiveLog,
+            outputFilterSensitiveLog: StartVirtualMachinesMetadataSyncOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0StartVirtualMachinesMetadataSyncCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0StartVirtualMachinesMetadataSyncCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -3,14 +3,20 @@ export * from "./CreateGatewayCommand";
 export * from "./DeleteGatewayCommand";
 export * from "./DeleteHypervisorCommand";
 export * from "./DisassociateGatewayFromServerCommand";
+export * from "./GetBandwidthRateLimitScheduleCommand";
 export * from "./GetGatewayCommand";
+export * from "./GetHypervisorCommand";
+export * from "./GetHypervisorPropertyMappingsCommand";
 export * from "./GetVirtualMachineCommand";
 export * from "./ImportHypervisorConfigurationCommand";
 export * from "./ListGatewaysCommand";
 export * from "./ListHypervisorsCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./ListVirtualMachinesCommand";
+export * from "./PutBandwidthRateLimitScheduleCommand";
+export * from "./PutHypervisorPropertyMappingsCommand";
 export * from "./PutMaintenanceStartTimeCommand";
+export * from "./StartVirtualMachinesMetadataSyncCommand";
 export * from "./TagResourceCommand";
 export * from "./TestHypervisorConfigurationCommand";
 export * from "./UntagResourceCommand";

package/dist-es/endpoint/ruleset.js

@@ -3,7 +3,7 @@ export const ruleSet = {
     parameters: {
         Region: {
             builtIn: "AWS::Region",
-            required: false,
+            required: true,
             documentation: "The AWS region used to dispatch the request.",
             type: "String",
         },
@@ -53,15 +53,6 @@ export const ruleSet = {
                                 },
                             ],
                         },
-                        {
-                            fn: "parseURL",
-                            argv: [
-                                {
-                                    ref: "Endpoint",
-                                },
-                            ],
-                            assign: "url",
-                        },
                     ],
                     type: "tree",
                     rules: [

package/dist-es/models/models_0.js

@@ -70,10 +70,6 @@ export class ValidationException extends __BaseException {
         this.Message = opts.Message;
     }
 }
-export var GatewayType;
-(function (GatewayType) {
-    GatewayType["BACKUP_VM"] = "BACKUP_VM";
-})(GatewayType || (GatewayType = {}));
 export class ResourceNotFoundException extends __BaseException {
     constructor(opts) {
         super({
@@ -88,6 +84,18 @@ export class ResourceNotFoundException extends __BaseException {
         this.Message = opts.Message;
     }
 }
+export var GatewayType;
+(function (GatewayType) {
+    GatewayType["BACKUP_VM"] = "BACKUP_VM";
+})(GatewayType || (GatewayType = {}));
+export var SyncMetadataStatus;
+(function (SyncMetadataStatus) {
+    SyncMetadataStatus["CREATED"] = "CREATED";
+    SyncMetadataStatus["FAILED"] = "FAILED";
+    SyncMetadataStatus["PARTIALLY_FAILED"] = "PARTIALLY_FAILED";
+    SyncMetadataStatus["RUNNING"] = "RUNNING";
+    SyncMetadataStatus["SUCCEEDED"] = "SUCCEEDED";
+})(SyncMetadataStatus || (SyncMetadataStatus = {}));
 export var HypervisorState;
 (function (HypervisorState) {
     HypervisorState["ERROR"] = "ERROR";
@@ -101,6 +109,21 @@ export const AssociateGatewayToServerInputFilterSensitiveLog = (obj) => ({
 export const AssociateGatewayToServerOutputFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const GetBandwidthRateLimitScheduleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BandwidthRateLimitIntervalFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetBandwidthRateLimitScheduleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutBandwidthRateLimitScheduleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutBandwidthRateLimitScheduleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const TagFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -175,6 +198,30 @@ export const DeleteHypervisorInputFilterSensitiveLog = (obj) => ({
 export const DeleteHypervisorOutputFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const GetHypervisorInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const HypervisorDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetHypervisorOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetHypervisorPropertyMappingsInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const VmwareToAwsTagMappingFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetHypervisorPropertyMappingsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutHypervisorPropertyMappingsInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutHypervisorPropertyMappingsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const ImportHypervisorConfigurationInputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.Username && { Username: SENSITIVE_STRING }),
@@ -192,6 +239,12 @@ export const HypervisorFilterSensitiveLog = (obj) => ({
 export const ListHypervisorsOutputFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const StartVirtualMachinesMetadataSyncInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const StartVirtualMachinesMetadataSyncOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const UpdateHypervisorInputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.Username && { Username: SENSITIVE_STRING }),
@@ -221,6 +274,9 @@ export const UntagResourceOutputFilterSensitiveLog = (obj) => ({
 export const GetVirtualMachineInputFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const VmwareTagFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const VirtualMachineDetailsFilterSensitiveLog = (obj) => ({
     ...obj,
 });