@aws-sdk/client-cloudfront 3.32.0 → 3.36.0

package/dist-es/commands/ListInvalidationsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListInvalidationsRequest, ListInvalidationsResult } from "../models/models_1";
+import { deserializeAws_restXmlListInvalidationsCommand, serializeAws_restXmlListInvalidationsCommand, } from "../protocols/Aws_restXml";
+var ListInvalidationsCommand = (function (_super) {
+    __extends(ListInvalidationsCommand, _super);
+    function ListInvalidationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListInvalidationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "ListInvalidationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListInvalidationsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListInvalidationsResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListInvalidationsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlListInvalidationsCommand(input, context);
+    };
+    ListInvalidationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlListInvalidationsCommand(output, context);
+    };
+    return ListInvalidationsCommand;
+}($Command));
+export { ListInvalidationsCommand };

package/dist-es/commands/ListKeyGroupsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListKeyGroupsRequest, ListKeyGroupsResult } from "../models/models_1";
+import { deserializeAws_restXmlListKeyGroupsCommand, serializeAws_restXmlListKeyGroupsCommand, } from "../protocols/Aws_restXml";
+var ListKeyGroupsCommand = (function (_super) {
+    __extends(ListKeyGroupsCommand, _super);
+    function ListKeyGroupsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListKeyGroupsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "ListKeyGroupsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListKeyGroupsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListKeyGroupsResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListKeyGroupsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlListKeyGroupsCommand(input, context);
+    };
+    ListKeyGroupsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlListKeyGroupsCommand(output, context);
+    };
+    return ListKeyGroupsCommand;
+}($Command));
+export { ListKeyGroupsCommand };

package/dist-es/commands/ListOriginRequestPoliciesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListOriginRequestPoliciesRequest, ListOriginRequestPoliciesResult } from "../models/models_1";
+import { deserializeAws_restXmlListOriginRequestPoliciesCommand, serializeAws_restXmlListOriginRequestPoliciesCommand, } from "../protocols/Aws_restXml";
+var ListOriginRequestPoliciesCommand = (function (_super) {
+    __extends(ListOriginRequestPoliciesCommand, _super);
+    function ListOriginRequestPoliciesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListOriginRequestPoliciesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "ListOriginRequestPoliciesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListOriginRequestPoliciesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListOriginRequestPoliciesResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListOriginRequestPoliciesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlListOriginRequestPoliciesCommand(input, context);
+    };
+    ListOriginRequestPoliciesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlListOriginRequestPoliciesCommand(output, context);
+    };
+    return ListOriginRequestPoliciesCommand;
+}($Command));
+export { ListOriginRequestPoliciesCommand };

package/dist-es/commands/ListPublicKeysCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListPublicKeysRequest, ListPublicKeysResult } from "../models/models_1";
+import { deserializeAws_restXmlListPublicKeysCommand, serializeAws_restXmlListPublicKeysCommand, } from "../protocols/Aws_restXml";
+var ListPublicKeysCommand = (function (_super) {
+    __extends(ListPublicKeysCommand, _super);
+    function ListPublicKeysCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListPublicKeysCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "ListPublicKeysCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListPublicKeysRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListPublicKeysResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListPublicKeysCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlListPublicKeysCommand(input, context);
+    };
+    ListPublicKeysCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlListPublicKeysCommand(output, context);
+    };
+    return ListPublicKeysCommand;
+}($Command));
+export { ListPublicKeysCommand };

package/dist-es/commands/ListRealtimeLogConfigsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListRealtimeLogConfigsRequest, ListRealtimeLogConfigsResult } from "../models/models_1";
+import { deserializeAws_restXmlListRealtimeLogConfigsCommand, serializeAws_restXmlListRealtimeLogConfigsCommand, } from "../protocols/Aws_restXml";
+var ListRealtimeLogConfigsCommand = (function (_super) {
+    __extends(ListRealtimeLogConfigsCommand, _super);
+    function ListRealtimeLogConfigsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListRealtimeLogConfigsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "ListRealtimeLogConfigsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListRealtimeLogConfigsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListRealtimeLogConfigsResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListRealtimeLogConfigsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlListRealtimeLogConfigsCommand(input, context);
+    };
+    ListRealtimeLogConfigsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlListRealtimeLogConfigsCommand(output, context);
+    };
+    return ListRealtimeLogConfigsCommand;
+}($Command));
+export { ListRealtimeLogConfigsCommand };

package/dist-es/commands/ListStreamingDistributionsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListStreamingDistributionsRequest, ListStreamingDistributionsResult } from "../models/models_1";
+import { deserializeAws_restXmlListStreamingDistributionsCommand, serializeAws_restXmlListStreamingDistributionsCommand, } from "../protocols/Aws_restXml";
+var ListStreamingDistributionsCommand = (function (_super) {
+    __extends(ListStreamingDistributionsCommand, _super);
+    function ListStreamingDistributionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListStreamingDistributionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "ListStreamingDistributionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListStreamingDistributionsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListStreamingDistributionsResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListStreamingDistributionsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlListStreamingDistributionsCommand(input, context);
+    };
+    ListStreamingDistributionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlListStreamingDistributionsCommand(output, context);
+    };
+    return ListStreamingDistributionsCommand;
+}($Command));
+export { ListStreamingDistributionsCommand };

package/dist-es/commands/ListTagsForResourceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListTagsForResourceRequest, ListTagsForResourceResult } from "../models/models_1";
+import { deserializeAws_restXmlListTagsForResourceCommand, serializeAws_restXmlListTagsForResourceCommand, } from "../protocols/Aws_restXml";
+var ListTagsForResourceCommand = (function (_super) {
+    __extends(ListTagsForResourceCommand, _super);
+    function ListTagsForResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListTagsForResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "ListTagsForResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListTagsForResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListTagsForResourceResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListTagsForResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlListTagsForResourceCommand(input, context);
+    };
+    ListTagsForResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlListTagsForResourceCommand(output, context);
+    };
+    return ListTagsForResourceCommand;
+}($Command));
+export { ListTagsForResourceCommand };

package/dist-es/commands/PublishFunctionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PublishFunctionRequest, PublishFunctionResult } from "../models/models_1";
+import { deserializeAws_restXmlPublishFunctionCommand, serializeAws_restXmlPublishFunctionCommand, } from "../protocols/Aws_restXml";
+var PublishFunctionCommand = (function (_super) {
+    __extends(PublishFunctionCommand, _super);
+    function PublishFunctionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PublishFunctionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "PublishFunctionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PublishFunctionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: PublishFunctionResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PublishFunctionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlPublishFunctionCommand(input, context);
+    };
+    PublishFunctionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlPublishFunctionCommand(output, context);
+    };
+    return PublishFunctionCommand;
+}($Command));
+export { PublishFunctionCommand };

package/dist-es/commands/TagResourceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { TagResourceRequest } from "../models/models_1";
+import { deserializeAws_restXmlTagResourceCommand, serializeAws_restXmlTagResourceCommand, } from "../protocols/Aws_restXml";
+var TagResourceCommand = (function (_super) {
+    __extends(TagResourceCommand, _super);
+    function TagResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    TagResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "TagResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: TagResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    TagResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlTagResourceCommand(input, context);
+    };
+    TagResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlTagResourceCommand(output, context);
+    };
+    return TagResourceCommand;
+}($Command));
+export { TagResourceCommand };

package/dist-es/commands/TestFunctionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { TestFunctionRequest, TestFunctionResult } from "../models/models_1";
+import { deserializeAws_restXmlTestFunctionCommand, serializeAws_restXmlTestFunctionCommand, } from "../protocols/Aws_restXml";
+var TestFunctionCommand = (function (_super) {
+    __extends(TestFunctionCommand, _super);
+    function TestFunctionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    TestFunctionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "TestFunctionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: TestFunctionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: TestFunctionResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    TestFunctionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlTestFunctionCommand(input, context);
+    };
+    TestFunctionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlTestFunctionCommand(output, context);
+    };
+    return TestFunctionCommand;
+}($Command));
+export { TestFunctionCommand };

package/dist-es/commands/UntagResourceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UntagResourceRequest } from "../models/models_1";
+import { deserializeAws_restXmlUntagResourceCommand, serializeAws_restXmlUntagResourceCommand, } from "../protocols/Aws_restXml";
+var UntagResourceCommand = (function (_super) {
+    __extends(UntagResourceCommand, _super);
+    function UntagResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UntagResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "UntagResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UntagResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UntagResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlUntagResourceCommand(input, context);
+    };
+    UntagResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlUntagResourceCommand(output, context);
+    };
+    return UntagResourceCommand;
+}($Command));
+export { UntagResourceCommand };

package/dist-es/commands/UpdateCachePolicyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateCachePolicyRequest, UpdateCachePolicyResult } from "../models/models_1";
+import { deserializeAws_restXmlUpdateCachePolicyCommand, serializeAws_restXmlUpdateCachePolicyCommand, } from "../protocols/Aws_restXml";
+var UpdateCachePolicyCommand = (function (_super) {
+    __extends(UpdateCachePolicyCommand, _super);
+    function UpdateCachePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateCachePolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "UpdateCachePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateCachePolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateCachePolicyResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateCachePolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlUpdateCachePolicyCommand(input, context);
+    };
+    UpdateCachePolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlUpdateCachePolicyCommand(output, context);
+    };
+    return UpdateCachePolicyCommand;
+}($Command));
+export { UpdateCachePolicyCommand };

package/dist-es/commands/UpdateCloudFrontOriginAccessIdentityCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateCloudFrontOriginAccessIdentityRequest, UpdateCloudFrontOriginAccessIdentityResult, } from "../models/models_1";
+import { deserializeAws_restXmlUpdateCloudFrontOriginAccessIdentityCommand, serializeAws_restXmlUpdateCloudFrontOriginAccessIdentityCommand, } from "../protocols/Aws_restXml";
+var UpdateCloudFrontOriginAccessIdentityCommand = (function (_super) {
+    __extends(UpdateCloudFrontOriginAccessIdentityCommand, _super);
+    function UpdateCloudFrontOriginAccessIdentityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateCloudFrontOriginAccessIdentityCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "UpdateCloudFrontOriginAccessIdentityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateCloudFrontOriginAccessIdentityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateCloudFrontOriginAccessIdentityResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateCloudFrontOriginAccessIdentityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlUpdateCloudFrontOriginAccessIdentityCommand(input, context);
+    };
+    UpdateCloudFrontOriginAccessIdentityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlUpdateCloudFrontOriginAccessIdentityCommand(output, context);
+    };
+    return UpdateCloudFrontOriginAccessIdentityCommand;
+}($Command));
+export { UpdateCloudFrontOriginAccessIdentityCommand };

package/dist-es/commands/UpdateDistributionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateDistributionRequest, UpdateDistributionResult } from "../models/models_1";
+import { deserializeAws_restXmlUpdateDistributionCommand, serializeAws_restXmlUpdateDistributionCommand, } from "../protocols/Aws_restXml";
+var UpdateDistributionCommand = (function (_super) {
+    __extends(UpdateDistributionCommand, _super);
+    function UpdateDistributionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateDistributionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "UpdateDistributionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateDistributionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateDistributionResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateDistributionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlUpdateDistributionCommand(input, context);
+    };
+    UpdateDistributionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlUpdateDistributionCommand(output, context);
+    };
+    return UpdateDistributionCommand;
+}($Command));
+export { UpdateDistributionCommand };

package/dist-es/commands/UpdateFieldLevelEncryptionConfigCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateFieldLevelEncryptionConfigRequest, UpdateFieldLevelEncryptionConfigResult } from "../models/models_1";
+import { deserializeAws_restXmlUpdateFieldLevelEncryptionConfigCommand, serializeAws_restXmlUpdateFieldLevelEncryptionConfigCommand, } from "../protocols/Aws_restXml";
+var UpdateFieldLevelEncryptionConfigCommand = (function (_super) {
+    __extends(UpdateFieldLevelEncryptionConfigCommand, _super);
+    function UpdateFieldLevelEncryptionConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateFieldLevelEncryptionConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "UpdateFieldLevelEncryptionConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateFieldLevelEncryptionConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateFieldLevelEncryptionConfigResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateFieldLevelEncryptionConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlUpdateFieldLevelEncryptionConfigCommand(input, context);
+    };
+    UpdateFieldLevelEncryptionConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlUpdateFieldLevelEncryptionConfigCommand(output, context);
+    };
+    return UpdateFieldLevelEncryptionConfigCommand;
+}($Command));
+export { UpdateFieldLevelEncryptionConfigCommand };

package/dist-es/commands/UpdateFieldLevelEncryptionProfileCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateFieldLevelEncryptionProfileRequest, UpdateFieldLevelEncryptionProfileResult } from "../models/models_1";
+import { deserializeAws_restXmlUpdateFieldLevelEncryptionProfileCommand, serializeAws_restXmlUpdateFieldLevelEncryptionProfileCommand, } from "../protocols/Aws_restXml";
+var UpdateFieldLevelEncryptionProfileCommand = (function (_super) {
+    __extends(UpdateFieldLevelEncryptionProfileCommand, _super);
+    function UpdateFieldLevelEncryptionProfileCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateFieldLevelEncryptionProfileCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "UpdateFieldLevelEncryptionProfileCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateFieldLevelEncryptionProfileRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateFieldLevelEncryptionProfileResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateFieldLevelEncryptionProfileCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlUpdateFieldLevelEncryptionProfileCommand(input, context);
+    };
+    UpdateFieldLevelEncryptionProfileCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlUpdateFieldLevelEncryptionProfileCommand(output, context);
+    };
+    return UpdateFieldLevelEncryptionProfileCommand;
+}($Command));
+export { UpdateFieldLevelEncryptionProfileCommand };