/******************************************************************************* * Copyright 2012-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * Licensed under the Apache License, Version 2.0 (the "License"). You may not use * this file except in compliance with the License. A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. * This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. * ***************************************************************************** * * AWS Tools for Windows (TM) PowerShell (TM) * */ using System; using System.Collections.Generic; using System.Linq; using System.Management.Automation; using System.Text; using Amazon.PowerShell.Common; using Amazon.Runtime; using Amazon.CloudFront; using Amazon.CloudFront.Model; namespace Amazon.PowerShell.Cmdlets.CF { /// /// Creates a CloudFront distribution. /// [Cmdlet("New", "CFDistribution", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)] [OutputType("Amazon.CloudFront.Model.CreateDistributionResponse")] [AWSCmdlet("Calls the Amazon CloudFront CreateDistribution API operation.", Operation = new[] {"CreateDistribution"}, SelectReturnType = typeof(Amazon.CloudFront.Model.CreateDistributionResponse))] [AWSCmdletOutput("Amazon.CloudFront.Model.CreateDistributionResponse", "This cmdlet returns an Amazon.CloudFront.Model.CreateDistributionResponse object containing multiple properties. The object can also be referenced from properties attached to the cmdlet entry in the $AWSHistory stack." )] public partial class NewCFDistributionCmdlet : AmazonCloudFrontClientCmdlet, IExecutor { protected override bool IsSensitiveRequest { get; set; } = true; protected override bool IsSensitiveResponse { get; set; } = true; #region Parameter ViewerCertificate_ACMCertificateArn /// /// /// If the distribution uses Aliases (alternate domain names or CNAMEs) and /// the SSL/TLS certificate is stored in Certificate /// Manager (ACM), provide the Amazon Resource Name (ARN) of the ACM certificate. /// CloudFront only supports ACM certificates in the US East (N. Virginia) Region (us-east-1).If you specify an ACM certificate ARN, you must also specify values for MinimumProtocolVersion /// and SSLSupportMethod. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_ViewerCertificate_ACMCertificateArn")] public System.String ViewerCertificate_ACMCertificateArn { get; set; } #endregion #region Parameter Logging_Bucket /// /// /// The Amazon S3 bucket to store the access logs in, for example, myawslogbucket.s3.amazonaws.com. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_Logging_Bucket")] public System.String Logging_Bucket { get; set; } #endregion #region Parameter DefaultCacheBehavior_CachePolicyId /// /// /// The unique identifier of the cache policy that is attached to the default cache behavior. /// For more information, see Creating /// cache policies or Using /// the managed cache policies in the Amazon CloudFront Developer Guide.A DefaultCacheBehavior must include either a CachePolicyId /// or ForwardedValues. We recommend that you use a CachePolicyId. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_CachePolicyId")] public System.String DefaultCacheBehavior_CachePolicyId { get; set; } #endregion #region Parameter DistributionConfig_CallerReference /// /// /// A unique value (for example, a date-time stamp) that ensures that the request can't /// be replayed.If the value of CallerReference is new (regardless of the content of /// the DistributionConfig object), CloudFront creates a new distribution.If CallerReference is a value that you already sent in a previous request /// to create a distribution, CloudFront returns a DistributionAlreadyExists /// error. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowEmptyString] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] public System.String DistributionConfig_CallerReference { get; set; } #endregion #region Parameter ViewerCertificate_CloudFrontDefaultCertificate /// /// /// If the distribution uses the CloudFront domain name such as d111111abcdef8.cloudfront.net, /// set this field to true.If the distribution uses Aliases (alternate domain names or CNAMEs), /// set this field to false and specify values for the following fields: /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_ViewerCertificate_CloudFrontDefaultCertificate")] public System.Boolean? ViewerCertificate_CloudFrontDefaultCertificate { get; set; } #endregion #region Parameter DistributionConfig_Comment /// /// /// A comment to describe the distribution. The comment cannot be longer than 128 characters. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowEmptyString] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] public System.String DistributionConfig_Comment { get; set; } #endregion #region Parameter DefaultCacheBehavior_Compress /// /// /// Whether you want CloudFront to automatically compress certain files for this cache /// behavior. If so, specify true; if not, specify false. For /// more information, see Serving /// Compressed Files in the Amazon CloudFront Developer Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_Compress")] public System.Boolean? DefaultCacheBehavior_Compress { get; set; } #endregion #region Parameter DistributionConfig_ContinuousDeploymentPolicyId /// /// /// The identifier of a continuous deployment policy. For more information, see CreateContinuousDeploymentPolicy. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String DistributionConfig_ContinuousDeploymentPolicyId { get; set; } #endregion #region Parameter DistributionConfig_DefaultRootObject /// /// /// The object that you want CloudFront to request from your origin (for example, index.html) /// when a viewer requests the root URL for your distribution (https://www.example.com) /// instead of an object in your distribution (https://www.example.com/product-description.html). /// Specifying a default root object avoids exposing the contents of your distribution.Specify only the object name, for example, index.html. Don't add a / /// before the object name.If you don't want to specify a default root object when you create a distribution, /// include an empty DefaultRootObject element.To delete the default root object from an existing distribution, update the distribution /// configuration and include an empty DefaultRootObject element.To replace the default root object, update the distribution configuration and specify /// the new object.For more information about the default root object, see Creating /// a Default Root Object in the Amazon CloudFront Developer Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String DistributionConfig_DefaultRootObject { get; set; } #endregion #region Parameter TrustedKeyGroups_Enabled /// /// /// This field is true if any of the key groups in the list have public keys /// that CloudFront can use to verify the signatures of signed URLs and signed cookies. /// If not, this field is false. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_TrustedKeyGroups_Enabled")] public System.Boolean? TrustedKeyGroups_Enabled { get; set; } #endregion #region Parameter TrustedSigners_Enabled /// /// /// This field is true if any of the Amazon Web Services accounts in the /// list are configured as trusted signers. If not, this field is false. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_TrustedSigners_Enabled")] public System.Boolean? TrustedSigners_Enabled { get; set; } #endregion #region Parameter DistributionConfig_Enabled /// /// /// From this field, you can enable or disable the selected distribution. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] public System.Boolean? DistributionConfig_Enabled { get; set; } #endregion #region Parameter Logging_Enabled /// /// /// Specifies whether you want CloudFront to save access logs to an Amazon S3 bucket. /// If you don't want to enable logging when you create a distribution or if you want /// to disable logging for an existing distribution, specify false for Enabled, /// and specify empty Bucket and Prefix elements. If you specify /// false for Enabled but you specify values for Bucket, /// prefix, and IncludeCookies, the values are automatically /// deleted. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_Logging_Enabled")] public System.Boolean? Logging_Enabled { get; set; } #endregion #region Parameter DefaultCacheBehavior_FieldLevelEncryptionId /// /// /// The value of ID for the field-level encryption configuration that you /// want CloudFront to use for encrypting specific fields of data for the default cache /// behavior. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_FieldLevelEncryptionId")] public System.String DefaultCacheBehavior_FieldLevelEncryptionId { get; set; } #endregion #region Parameter Cookies_Forward /// /// /// This field is deprecated. We recommend that you use a cache policy or an origin request /// policy instead of this field.If you want to include cookies in the cache key, use a cache policy. For more information, /// see Creating /// cache policies in the Amazon CloudFront Developer Guide.If you want to send cookies to the origin but not include them in the cache key, use /// origin request policy. For more information, see Creating /// origin request policies in the Amazon CloudFront Developer Guide.Specifies which cookies to forward to the origin for this cache behavior: all, none, /// or the list of cookies specified in the WhitelistedNames complex type.Amazon S3 doesn't process cookies. When the cache behavior is forwarding requests /// to an Amazon S3 origin, specify none for the Forward element. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_Forward")] [AWSConstantClassSource("Amazon.CloudFront.ItemSelection")] public Amazon.CloudFront.ItemSelection Cookies_Forward { get; set; } #endregion #region Parameter DistributionConfig_HttpVersion /// /// /// (Optional) Specify the maximum HTTP version(s) that you want viewers to use to communicate /// with CloudFront. The default value for new web distributions is http2. /// Viewers that don't support HTTP/2 automatically use an earlier HTTP version.For viewers and CloudFront to use HTTP/2, viewers must support TLSv1.2 or later, and /// must support Server Name Indication (SNI).For viewers and CloudFront to use HTTP/3, viewers must support TLSv1.3 and Server /// Name Indication (SNI). CloudFront supports HTTP/3 connection migration to allow the /// viewer to switch networks without losing connection. For more information about connection /// migration, see Connection /// Migration at RFC 9000. For more information about supported TLSv1.3 ciphers, see /// Supported /// protocols and ciphers between viewers and CloudFront. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [AWSConstantClassSource("Amazon.CloudFront.HttpVersion")] public Amazon.CloudFront.HttpVersion DistributionConfig_HttpVersion { get; set; } #endregion #region Parameter ViewerCertificate_IAMCertificateId /// /// /// If the distribution uses Aliases (alternate domain names or CNAMEs) and /// the SSL/TLS certificate is stored in Identity /// and Access Management (IAM), provide the ID of the IAM certificate.If you specify an IAM certificate ID, you must also specify values for MinimumProtocolVersion /// and SSLSupportMethod. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_ViewerCertificate_IAMCertificateId")] public System.String ViewerCertificate_IAMCertificateId { get; set; } #endregion #region Parameter Logging_IncludeCookie /// /// /// Specifies whether you want CloudFront to include cookies in access logs, specify true /// for IncludeCookies. If you choose to include cookies in logs, CloudFront /// logs all cookies regardless of how you configure the cache behaviors for this distribution. /// If you don't want to include cookies when you create a distribution or if you want /// to disable include cookies for an existing distribution, specify false /// for IncludeCookies. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_Logging_IncludeCookies")] public System.Boolean? Logging_IncludeCookie { get; set; } #endregion #region Parameter DistributionConfig_IsIPV6Enabled /// /// /// If you want CloudFront to respond to IPv6 DNS requests with an IPv6 address for your /// distribution, specify true. If you specify false, CloudFront /// responds to IPv6 DNS requests with the DNS response code NOERROR and /// with no IP addresses. This allows viewers to submit a second request, for an IPv4 /// address for your distribution.In general, you should enable IPv6 if you have users on IPv6 networks who want to /// access your content. However, if you're using signed URLs or signed cookies to restrict /// access to your content, and if you're using a custom policy that includes the IpAddress /// parameter to restrict the IP addresses that can access your content, don't enable /// IPv6. If you want to restrict access to some content by IP address and not restrict /// access to other content (or restrict access but not by IP address), you can create /// two distributions. For more information, see Creating /// a Signed URL Using a Custom Policy in the Amazon CloudFront Developer Guide.If you're using an Route 53 Amazon Web Services Integration alias resource record /// set to route traffic to your CloudFront distribution, you need to create a second /// alias resource record set when both of the following are true:For more information, see Routing /// Traffic to an Amazon CloudFront Web Distribution by Using Your Domain Name in /// the Route 53 Amazon Web Services Integration Developer Guide.If you created a CNAME resource record set, either with Route 53 Amazon Web Services /// Integration or with another DNS service, you don't need to make any changes. A CNAME /// record will route traffic to your distribution regardless of the IP address format /// of the viewer request. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? DistributionConfig_IsIPV6Enabled { get; set; } #endregion #region Parameter Aliases_Item /// /// /// A complex type that contains the CNAME aliases, if any, that you want to associate /// with this distribution. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_Aliases_Items")] public System.String[] Aliases_Item { get; set; } #endregion #region Parameter CacheBehaviors_Item /// /// /// Optional: A complex type that contains cache behaviors for this distribution. If Quantity /// is 0, you can omit Items. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_CacheBehaviors_Items")] public Amazon.CloudFront.Model.CacheBehavior[] CacheBehaviors_Item { get; set; } #endregion #region Parameter CustomErrorResponses_Item /// /// /// A complex type that contains a CustomErrorResponse element for each HTTP /// status code for which you want to specify a custom error page and/or a caching duration. /// /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_CustomErrorResponses_Items")] public Amazon.CloudFront.Model.CustomErrorResponse[] CustomErrorResponses_Item { get; set; } #endregion #region Parameter CachedMethods_Item /// /// /// A complex type that contains the HTTP methods that you want CloudFront to cache responses /// to. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods_Items")] public System.String[] CachedMethods_Item { get; set; } #endregion #region Parameter AllowedMethods_Item /// /// /// A complex type that contains the HTTP methods that you want CloudFront to process /// and forward to your origin. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_AllowedMethods_Items")] public System.String[] AllowedMethods_Item { get; set; } #endregion #region Parameter WhitelistedNames_Item /// /// /// A list of cookie names. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames_Items")] public System.String[] WhitelistedNames_Item { get; set; } #endregion #region Parameter Headers_Item /// /// /// A list of HTTP header names. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_ForwardedValues_Headers_Items")] public System.String[] Headers_Item { get; set; } #endregion #region Parameter QueryStringCacheKeys_Item /// /// /// A list that contains the query string parameters that you want CloudFront to use as /// a basis for caching for a cache behavior. If Quantity is 0, you can omit /// Items. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys_Items")] public System.String[] QueryStringCacheKeys_Item { get; set; } #endregion #region Parameter FunctionAssociations_Item /// /// /// The CloudFront functions that are associated with a cache behavior in a CloudFront /// distribution. CloudFront functions must be published to the LIVE stage /// to associate them with a cache behavior. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_FunctionAssociations_Items")] public Amazon.CloudFront.Model.FunctionAssociation[] FunctionAssociations_Item { get; set; } #endregion #region Parameter LambdaFunctionAssociations_Item /// /// /// Optional: A complex type that contains LambdaFunctionAssociation /// items for this cache behavior. If Quantity is 0, you can /// omit Items. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations_Items")] public Amazon.CloudFront.Model.LambdaFunctionAssociation[] LambdaFunctionAssociations_Item { get; set; } #endregion #region Parameter TrustedKeyGroups_Item /// /// /// A list of key groups identifiers. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_TrustedKeyGroups_Items")] public System.String[] TrustedKeyGroups_Item { get; set; } #endregion #region Parameter TrustedSigners_Item /// /// /// A list of Amazon Web Services account identifiers. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_TrustedSigners_Items")] public System.String[] TrustedSigners_Item { get; set; } #endregion #region Parameter OriginGroups_Item /// /// /// The items (origin groups) in a distribution. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_OriginGroups_Items")] public Amazon.CloudFront.Model.OriginGroup[] OriginGroups_Item { get; set; } #endregion #region Parameter Origins_Item /// /// /// A list of origins. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowEmptyCollection] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] [Alias("DistributionConfig_Origins_Items")] public Amazon.CloudFront.Model.Origin[] Origins_Item { get; set; } #endregion #region Parameter GeoRestriction_Item /// /// /// A complex type that contains a Location element for each country in which /// you want CloudFront either to distribute your content (whitelist) or /// not distribute your content (blacklist).The Location element is a two-letter, uppercase country code for a country /// that you want to include in your blacklist or whitelist. /// Include one Location element for each country.CloudFront and MaxMind both use ISO 3166 country codes. /// For the current list of countries and the corresponding codes, see ISO 3166-1-alpha-2 /// code on the International Organization for Standardization website. You can /// also refer to the country list on the CloudFront console, which includes both country /// names and codes. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_Restrictions_GeoRestriction_Items")] public System.String[] GeoRestriction_Item { get; set; } #endregion #region Parameter ViewerCertificate_MinimumProtocolVersion /// /// /// If the distribution uses Aliases (alternate domain names or CNAMEs), /// specify the security policy that you want CloudFront to use for HTTPS connections /// with viewers. The security policy determines two settings:For more information, see Security /// Policy and Supported /// Protocols and Ciphers Between Viewers and CloudFront in the Amazon CloudFront /// Developer Guide.On the CloudFront console, this setting is called Security Policy.When you're using SNI only (you set SSLSupportMethod to sni-only), /// you must specify TLSv1 or higher.If the distribution uses the CloudFront domain name such as d111111abcdef8.cloudfront.net /// (you set CloudFrontDefaultCertificate to true), CloudFront /// automatically sets the security policy to TLSv1 regardless of the value /// that you set here. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_ViewerCertificate_MinimumProtocolVersion")] [AWSConstantClassSource("Amazon.CloudFront.MinimumProtocolVersion")] public Amazon.CloudFront.MinimumProtocolVersion ViewerCertificate_MinimumProtocolVersion { get; set; } #endregion #region Parameter DefaultCacheBehavior_OriginRequestPolicyId /// /// /// The unique identifier of the origin request policy that is attached to the default /// cache behavior. For more information, see Creating /// origin request policies or Using /// the managed origin request policies in the Amazon CloudFront Developer Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_OriginRequestPolicyId")] public System.String DefaultCacheBehavior_OriginRequestPolicyId { get; set; } #endregion #region Parameter Logging_Prefix /// /// /// An optional string that you want CloudFront to prefix to the access log filenames /// for this distribution, for example, myprefix/. If you want to enable /// logging, but you don't want to specify a prefix, you still must include an empty Prefix /// element in the Logging element. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_Logging_Prefix")] public System.String Logging_Prefix { get; set; } #endregion #region Parameter DistributionConfig_PriceClass /// /// /// The price class that corresponds with the maximum price that you want to pay for CloudFront /// service. If you specify PriceClass_All, CloudFront responds to requests /// for your objects from all CloudFront edge locations.If you specify a price class other than PriceClass_All, CloudFront serves /// your objects from the CloudFront edge location that has the lowest latency among the /// edge locations in your price class. Viewers who are in or near regions that are excluded /// from your specified price class may encounter slower performance.For more information about price classes, see Choosing /// the Price Class for a CloudFront Distribution in the Amazon CloudFront Developer /// Guide. For information about CloudFront pricing, including how price classes (such /// as Price Class 100) map to CloudFront regions, see Amazon /// CloudFront Pricing. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [AWSConstantClassSource("Amazon.CloudFront.PriceClass")] public Amazon.CloudFront.PriceClass DistributionConfig_PriceClass { get; set; } #endregion #region Parameter Aliases_Quantity /// /// /// The number of CNAME aliases, if any, that you want to associate with this distribution. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_Aliases_Quantity")] public System.Int32? Aliases_Quantity { get; set; } #endregion #region Parameter CacheBehaviors_Quantity /// /// /// The number of cache behaviors for this distribution. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_CacheBehaviors_Quantity")] public System.Int32? CacheBehaviors_Quantity { get; set; } #endregion #region Parameter CustomErrorResponses_Quantity /// /// /// The number of HTTP status codes for which you want to specify a custom error page /// and/or a caching duration. If Quantity is 0, you can omit /// Items. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_CustomErrorResponses_Quantity")] public System.Int32? CustomErrorResponses_Quantity { get; set; } #endregion #region Parameter CachedMethods_Quantity /// /// /// The number of HTTP methods for which you want CloudFront to cache responses. Valid /// values are 2 (for caching responses to GET and HEAD /// requests) and 3 (for caching responses to GET, HEAD, /// and OPTIONS requests). /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods_Quantity")] public System.Int32? CachedMethods_Quantity { get; set; } #endregion #region Parameter AllowedMethods_Quantity /// /// /// The number of HTTP methods that you want CloudFront to forward to your origin. Valid /// values are 2 (for GET and HEAD requests), 3 (for GET, /// HEAD, and OPTIONS requests) and 7 (for GET, HEAD, /// OPTIONS, PUT, PATCH, POST, and DELETE requests). /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_AllowedMethods_Quantity")] public System.Int32? AllowedMethods_Quantity { get; set; } #endregion #region Parameter WhitelistedNames_Quantity /// /// /// The number of cookie names in the Items list. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames_Quantity")] public System.Int32? WhitelistedNames_Quantity { get; set; } #endregion #region Parameter Headers_Quantity /// /// /// The number of header names in the Items list. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_ForwardedValues_Headers_Quantity")] public System.Int32? Headers_Quantity { get; set; } #endregion #region Parameter QueryStringCacheKeys_Quantity /// /// /// The number of whitelisted query string parameters for a cache behavior. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys_Quantity")] public System.Int32? QueryStringCacheKeys_Quantity { get; set; } #endregion #region Parameter FunctionAssociations_Quantity /// /// /// The number of CloudFront functions in the list. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_FunctionAssociations_Quantity")] public System.Int32? FunctionAssociations_Quantity { get; set; } #endregion #region Parameter LambdaFunctionAssociations_Quantity /// /// /// The number of Lambda@Edge function associations for this cache behavior. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations_Quantity")] public System.Int32? LambdaFunctionAssociations_Quantity { get; set; } #endregion #region Parameter TrustedKeyGroups_Quantity /// /// /// The number of key groups in the list. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_TrustedKeyGroups_Quantity")] public System.Int32? TrustedKeyGroups_Quantity { get; set; } #endregion #region Parameter TrustedSigners_Quantity /// /// /// The number of Amazon Web Services accounts in the list. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_TrustedSigners_Quantity")] public System.Int32? TrustedSigners_Quantity { get; set; } #endregion #region Parameter OriginGroups_Quantity /// /// /// The number of origin groups. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_OriginGroups_Quantity")] public System.Int32? OriginGroups_Quantity { get; set; } #endregion #region Parameter Origins_Quantity /// /// /// The number of origins for this distribution. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] [Alias("DistributionConfig_Origins_Quantity")] public System.Int32? Origins_Quantity { get; set; } #endregion #region Parameter GeoRestriction_Quantity /// /// /// When geo restriction is enabled, this is the number of countries in your /// whitelist or blacklist. Otherwise, when it is not enabled, /// Quantity is 0, and you can omit Items. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_Restrictions_GeoRestriction_Quantity")] public System.Int32? GeoRestriction_Quantity { get; set; } #endregion #region Parameter ForwardedValues_QueryString /// /// /// This field is deprecated. We recommend that you use a cache policy or an origin request /// policy instead of this field.If you want to include query strings in the cache key, use a cache policy. For more /// information, see Creating /// cache policies in the Amazon CloudFront Developer Guide.If you want to send query strings to the origin but not include them in the cache /// key, use an origin request policy. For more information, see Creating /// origin request policies in the Amazon CloudFront Developer Guide.Indicates whether you want CloudFront to forward query strings to the origin that /// is associated with this cache behavior and cache based on the query string parameters. /// CloudFront behavior depends on the value of QueryString and on the values /// that you specify for QueryStringCacheKeys, if any:If you specify true for QueryString and you don't specify any values /// for QueryStringCacheKeys, CloudFront forwards all query string parameters /// to the origin and caches based on all query string parameters. Depending on how many /// query string parameters and values you have, this can adversely affect performance /// because CloudFront must forward more requests to the origin.If you specify true for QueryString and you specify one or more values /// for QueryStringCacheKeys, CloudFront forwards all query string parameters /// to the origin, but it only caches based on the query string parameters that you specify.If you specify false for QueryString, CloudFront doesn't forward any /// query string parameters to the origin, and doesn't cache based on query string parameters.For more information, see Configuring /// CloudFront to Cache Based on Query String Parameters in the Amazon CloudFront /// Developer Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_ForwardedValues_QueryString")] public System.Boolean? ForwardedValues_QueryString { get; set; } #endregion #region Parameter DefaultCacheBehavior_RealtimeLogConfigArn /// /// /// The Amazon Resource Name (ARN) of the real-time log configuration that is attached /// to this cache behavior. For more information, see Real-time /// logs in the Amazon CloudFront Developer Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_RealtimeLogConfigArn")] public System.String DefaultCacheBehavior_RealtimeLogConfigArn { get; set; } #endregion #region Parameter DefaultCacheBehavior_ResponseHeadersPolicyId /// /// /// The identifier for a response headers policy. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_ResponseHeadersPolicyId")] public System.String DefaultCacheBehavior_ResponseHeadersPolicyId { get; set; } #endregion #region Parameter GeoRestriction_RestrictionType /// /// /// The method that you want to use to restrict distribution of your content by country: /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_Restrictions_GeoRestriction_RestrictionType")] [AWSConstantClassSource("Amazon.CloudFront.GeoRestrictionType")] public Amazon.CloudFront.GeoRestrictionType GeoRestriction_RestrictionType { get; set; } #endregion #region Parameter DefaultCacheBehavior_SmoothStreaming /// /// /// Indicates whether you want to distribute media files in the Microsoft Smooth Streaming /// format using the origin that is associated with this cache behavior. If so, specify /// true; if not, specify false. If you specify true /// for SmoothStreaming, you can still distribute other content using this /// cache behavior if the content matches the value of PathPattern. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_DefaultCacheBehavior_SmoothStreaming")] public System.Boolean? DefaultCacheBehavior_SmoothStreaming { get; set; } #endregion #region Parameter ViewerCertificate_SSLSupportMethod /// /// /// If the distribution uses Aliases (alternate domain names or CNAMEs), /// specify which viewers the distribution accepts HTTPS connections from.If the distribution uses the CloudFront domain name such as d111111abcdef8.cloudfront.net, /// don't set a value for this field. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("DistributionConfig_ViewerCertificate_SSLSupportMethod")] [AWSConstantClassSource("Amazon.CloudFront.SSLSupportMethod")] public Amazon.CloudFront.SSLSupportMethod ViewerCertificate_SSLSupportMethod { get; set; } #endregion #region Parameter DistributionConfig_Staging /// /// /// A Boolean that indicates whether this is a staging distribution. When this value is /// true, this is a staging distribution. When this value is false, /// this is not a staging distribution. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? DistributionConfig_Staging { get; set; } #endregion #region Parameter DefaultCacheBehavior_TargetOriginId /// /// /// The value of ID for the origin that you want CloudFront to route requests /// to when they use the default cache behavior. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowEmptyString] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] [Alias("DistributionConfig_DefaultCacheBehavior_TargetOriginId")] public System.String DefaultCacheBehavior_TargetOriginId { get; set; } #endregion #region Parameter DefaultCacheBehavior_ViewerProtocolPolicy /// /// /// The protocol that viewers can use to access the files in the origin specified by TargetOriginId /// when a request matches the path pattern in PathPattern. You can specify /// the following options:For more information about requiring the HTTPS protocol, see Requiring /// HTTPS Between Viewers and CloudFront in the Amazon CloudFront Developer Guide.The only way to guarantee that viewers retrieve an object that was fetched from the /// origin using HTTPS is never to use any other protocol to fetch the object. If you /// have recently changed from HTTP to HTTPS, we recommend that you clear your objects' /// cache because cached objects are protocol agnostic. That means that an edge location /// will return an object from the cache regardless of whether the current request protocol /// matches the protocol used previously. For more information, see Managing /// Cache Expiration in the Amazon CloudFront Developer Guide. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] [Alias("DistributionConfig_DefaultCacheBehavior_ViewerProtocolPolicy")] [AWSConstantClassSource("Amazon.CloudFront.ViewerProtocolPolicy")] public Amazon.CloudFront.ViewerProtocolPolicy DefaultCacheBehavior_ViewerProtocolPolicy { get; set; } #endregion #region Parameter DistributionConfig_WebACLId /// /// /// A unique identifier that specifies the WAF web ACL, if any, to associate with this /// distribution. To specify a web ACL created using the latest version of WAF, use the /// ACL ARN, for example arn:aws:wafv2:us-east-1:123456789012:global/webacl/ExampleWebACL/473e64fd-f30b-4765-81a0-62ad96dd167a. /// To specify a web ACL created using WAF Classic, use the ACL ID, for example 473e64fd-f30b-4765-81a0-62ad96dd167a.WAF is a web application firewall that lets you monitor the HTTP and HTTPS requests /// that are forwarded to CloudFront, and lets you control access to your content. Based /// on conditions that you specify, such as the IP addresses that requests originate from /// or the values of query strings, CloudFront responds to requests either with the requested /// content or with an HTTP 403 status code (Forbidden). You can also configure CloudFront /// to return a custom error page when a request is blocked. For more information about /// WAF, see the WAF /// Developer Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String DistributionConfig_WebACLId { get; set; } #endregion #region Parameter ViewerCertificate_Certificate /// /// /// This field is deprecated. Use one of the following fields instead: /// /// This parameter is deprecated. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [System.ObsoleteAttribute("This field has been deprecated. Use one of the following fields instead: ACMCertificateArn, IAMCertificateId or CloudFrontDefaultCertificate.")] [Alias("DistributionConfig_ViewerCertificate_Certificate")] public System.String ViewerCertificate_Certificate { get; set; } #endregion #region Parameter ViewerCertificate_CertificateSource /// /// /// This field is deprecated. Use one of the following fields instead: /// /// This parameter is deprecated. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [System.ObsoleteAttribute("This field has been deprecated. Use one of the following fields instead: ACMCertificateArn, IAMCertificateId or CloudFrontDefaultCertificate.")] [Alias("DistributionConfig_ViewerCertificate_CertificateSource")] [AWSConstantClassSource("Amazon.CloudFront.CertificateSource")] public Amazon.CloudFront.CertificateSource ViewerCertificate_CertificateSource { get; set; } #endregion #region Parameter DefaultCacheBehavior_DefaultTTL /// /// /// This field is deprecated. We recommend that you use the DefaultTTL field /// in a cache policy instead of this field. For more information, see Creating /// cache policies or Using /// the managed cache policies in the Amazon CloudFront Developer Guide.The default amount of time that you want objects to stay in CloudFront caches before /// CloudFront forwards another request to your origin to determine whether the object /// has been updated. The value that you specify applies only when your origin does not /// add HTTP headers such as Cache-Control max-age, Cache-Control s-maxage, /// and Expires to objects. For more information, see Managing /// How Long Content Stays in an Edge Cache (Expiration) in the Amazon CloudFront /// Developer Guide. /// /// This parameter is deprecated. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [System.ObsoleteAttribute("This field is deprecated. Use CachePolicy instead.")] [Alias("DistributionConfig_DefaultCacheBehavior_DefaultTTL")] public System.Int64? DefaultCacheBehavior_DefaultTTL { get; set; } #endregion #region Parameter DefaultCacheBehavior_MaxTTL /// /// /// This field is deprecated. We recommend that you use the MaxTTL field /// in a cache policy instead of this field. For more information, see Creating /// cache policies or Using /// the managed cache policies in the Amazon CloudFront Developer Guide.The maximum amount of time that you want objects to stay in CloudFront caches before /// CloudFront forwards another request to your origin to determine whether the object /// has been updated. The value that you specify applies only when your origin adds HTTP /// headers such as Cache-Control max-age, Cache-Control s-maxage, /// and Expires to objects. For more information, see Managing /// How Long Content Stays in an Edge Cache (Expiration) in the Amazon CloudFront /// Developer Guide. /// /// This parameter is deprecated. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [System.ObsoleteAttribute("This field is deprecated. Use CachePolicy instead.")] [Alias("DistributionConfig_DefaultCacheBehavior_MaxTTL")] public System.Int64? DefaultCacheBehavior_MaxTTL { get; set; } #endregion #region Parameter DefaultCacheBehavior_MinTTL /// /// /// This field is deprecated. We recommend that you use the MinTTL field /// in a cache policy instead of this field. For more information, see Creating /// cache policies or Using /// the managed cache policies in the Amazon CloudFront Developer Guide.The minimum amount of time that you want objects to stay in CloudFront caches before /// CloudFront forwards another request to your origin to determine whether the object /// has been updated. For more information, see Managing /// How Long Content Stays in an Edge Cache (Expiration) in the Amazon CloudFront /// Developer Guide.You must specify 0 for MinTTL if you configure CloudFront /// to forward all headers to your origin (under Headers, if you specify /// 1 for Quantity and * for Name). /// /// This parameter is deprecated. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [System.ObsoleteAttribute("This field is deprecated. Use CachePolicy instead.")] [Alias("DistributionConfig_DefaultCacheBehavior_MinTTL")] public System.Int64? DefaultCacheBehavior_MinTTL { get; set; } #endregion #region Parameter Select /// /// Use the -Select parameter to control the cmdlet output. The default value is '*'. /// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.CloudFront.Model.CreateDistributionResponse). /// Specifying the name of a property of type Amazon.CloudFront.Model.CreateDistributionResponse will result in that property being returned. /// Specifying -Select '^ParameterName' will result in the cmdlet returning the selected cmdlet parameter value. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public string Select { get; set; } = "*"; #endregion #region Parameter Force /// /// This parameter overrides confirmation prompts to force /// the cmdlet to continue its operation. This parameter should always /// be used with caution. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter Force { get; set; } #endregion protected override void ProcessRecord() { this._AWSSignerType = "v4"; base.ProcessRecord(); var resourceIdentifiersText = string.Empty; if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "New-CFDistribution (CreateDistribution)")) { return; } var context = new CmdletContext(); // allow for manipulation of parameters prior to loading into context PreExecutionContextLoad(context); if (ParameterWasBound(nameof(this.Select))) { context.Select = CreateSelectDelegate(Select) ?? throw new System.ArgumentException("Invalid value for -Select parameter.", nameof(this.Select)); } if (this.Aliases_Item != null) { context.Aliases_Item = new List(this.Aliases_Item); } context.Aliases_Quantity = this.Aliases_Quantity; if (this.CacheBehaviors_Item != null) { context.CacheBehaviors_Item = new List(this.CacheBehaviors_Item); } context.CacheBehaviors_Quantity = this.CacheBehaviors_Quantity; context.DistributionConfig_CallerReference = this.DistributionConfig_CallerReference; #if MODULAR if (this.DistributionConfig_CallerReference == null && ParameterWasBound(nameof(this.DistributionConfig_CallerReference))) { WriteWarning("You are passing $null as a value for parameter DistributionConfig_CallerReference which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.DistributionConfig_Comment = this.DistributionConfig_Comment; #if MODULAR if (this.DistributionConfig_Comment == null && ParameterWasBound(nameof(this.DistributionConfig_Comment))) { WriteWarning("You are passing $null as a value for parameter DistributionConfig_Comment which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.DistributionConfig_ContinuousDeploymentPolicyId = this.DistributionConfig_ContinuousDeploymentPolicyId; if (this.CustomErrorResponses_Item != null) { context.CustomErrorResponses_Item = new List(this.CustomErrorResponses_Item); } context.CustomErrorResponses_Quantity = this.CustomErrorResponses_Quantity; if (this.CachedMethods_Item != null) { context.CachedMethods_Item = new List(this.CachedMethods_Item); } context.CachedMethods_Quantity = this.CachedMethods_Quantity; if (this.AllowedMethods_Item != null) { context.AllowedMethods_Item = new List(this.AllowedMethods_Item); } context.AllowedMethods_Quantity = this.AllowedMethods_Quantity; context.DefaultCacheBehavior_CachePolicyId = this.DefaultCacheBehavior_CachePolicyId; context.DefaultCacheBehavior_Compress = this.DefaultCacheBehavior_Compress; #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute context.DefaultCacheBehavior_DefaultTTL = this.DefaultCacheBehavior_DefaultTTL; #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute context.DefaultCacheBehavior_FieldLevelEncryptionId = this.DefaultCacheBehavior_FieldLevelEncryptionId; context.Cookies_Forward = this.Cookies_Forward; if (this.WhitelistedNames_Item != null) { context.WhitelistedNames_Item = new List(this.WhitelistedNames_Item); } context.WhitelistedNames_Quantity = this.WhitelistedNames_Quantity; if (this.Headers_Item != null) { context.Headers_Item = new List(this.Headers_Item); } context.Headers_Quantity = this.Headers_Quantity; context.ForwardedValues_QueryString = this.ForwardedValues_QueryString; if (this.QueryStringCacheKeys_Item != null) { context.QueryStringCacheKeys_Item = new List(this.QueryStringCacheKeys_Item); } context.QueryStringCacheKeys_Quantity = this.QueryStringCacheKeys_Quantity; if (this.FunctionAssociations_Item != null) { context.FunctionAssociations_Item = new List(this.FunctionAssociations_Item); } context.FunctionAssociations_Quantity = this.FunctionAssociations_Quantity; if (this.LambdaFunctionAssociations_Item != null) { context.LambdaFunctionAssociations_Item = new List(this.LambdaFunctionAssociations_Item); } context.LambdaFunctionAssociations_Quantity = this.LambdaFunctionAssociations_Quantity; #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute context.DefaultCacheBehavior_MaxTTL = this.DefaultCacheBehavior_MaxTTL; #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute context.DefaultCacheBehavior_MinTTL = this.DefaultCacheBehavior_MinTTL; #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute context.DefaultCacheBehavior_OriginRequestPolicyId = this.DefaultCacheBehavior_OriginRequestPolicyId; context.DefaultCacheBehavior_RealtimeLogConfigArn = this.DefaultCacheBehavior_RealtimeLogConfigArn; context.DefaultCacheBehavior_ResponseHeadersPolicyId = this.DefaultCacheBehavior_ResponseHeadersPolicyId; context.DefaultCacheBehavior_SmoothStreaming = this.DefaultCacheBehavior_SmoothStreaming; context.DefaultCacheBehavior_TargetOriginId = this.DefaultCacheBehavior_TargetOriginId; #if MODULAR if (this.DefaultCacheBehavior_TargetOriginId == null && ParameterWasBound(nameof(this.DefaultCacheBehavior_TargetOriginId))) { WriteWarning("You are passing $null as a value for parameter DefaultCacheBehavior_TargetOriginId which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.TrustedKeyGroups_Enabled = this.TrustedKeyGroups_Enabled; if (this.TrustedKeyGroups_Item != null) { context.TrustedKeyGroups_Item = new List(this.TrustedKeyGroups_Item); } context.TrustedKeyGroups_Quantity = this.TrustedKeyGroups_Quantity; context.TrustedSigners_Enabled = this.TrustedSigners_Enabled; if (this.TrustedSigners_Item != null) { context.TrustedSigners_Item = new List(this.TrustedSigners_Item); } context.TrustedSigners_Quantity = this.TrustedSigners_Quantity; context.DefaultCacheBehavior_ViewerProtocolPolicy = this.DefaultCacheBehavior_ViewerProtocolPolicy; #if MODULAR if (this.DefaultCacheBehavior_ViewerProtocolPolicy == null && ParameterWasBound(nameof(this.DefaultCacheBehavior_ViewerProtocolPolicy))) { WriteWarning("You are passing $null as a value for parameter DefaultCacheBehavior_ViewerProtocolPolicy which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.DistributionConfig_DefaultRootObject = this.DistributionConfig_DefaultRootObject; context.DistributionConfig_Enabled = this.DistributionConfig_Enabled; #if MODULAR if (this.DistributionConfig_Enabled == null && ParameterWasBound(nameof(this.DistributionConfig_Enabled))) { WriteWarning("You are passing $null as a value for parameter DistributionConfig_Enabled which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.DistributionConfig_HttpVersion = this.DistributionConfig_HttpVersion; context.DistributionConfig_IsIPV6Enabled = this.DistributionConfig_IsIPV6Enabled; context.Logging_Bucket = this.Logging_Bucket; context.Logging_Enabled = this.Logging_Enabled; context.Logging_IncludeCookie = this.Logging_IncludeCookie; context.Logging_Prefix = this.Logging_Prefix; if (this.OriginGroups_Item != null) { context.OriginGroups_Item = new List(this.OriginGroups_Item); } context.OriginGroups_Quantity = this.OriginGroups_Quantity; if (this.Origins_Item != null) { context.Origins_Item = new List(this.Origins_Item); } #if MODULAR if (this.Origins_Item == null && ParameterWasBound(nameof(this.Origins_Item))) { WriteWarning("You are passing $null as a value for parameter Origins_Item which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.Origins_Quantity = this.Origins_Quantity; #if MODULAR if (this.Origins_Quantity == null && ParameterWasBound(nameof(this.Origins_Quantity))) { WriteWarning("You are passing $null as a value for parameter Origins_Quantity which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.DistributionConfig_PriceClass = this.DistributionConfig_PriceClass; if (this.GeoRestriction_Item != null) { context.GeoRestriction_Item = new List(this.GeoRestriction_Item); } context.GeoRestriction_Quantity = this.GeoRestriction_Quantity; context.GeoRestriction_RestrictionType = this.GeoRestriction_RestrictionType; context.DistributionConfig_Staging = this.DistributionConfig_Staging; context.ViewerCertificate_ACMCertificateArn = this.ViewerCertificate_ACMCertificateArn; #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute context.ViewerCertificate_Certificate = this.ViewerCertificate_Certificate; #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute context.ViewerCertificate_CertificateSource = this.ViewerCertificate_CertificateSource; #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute context.ViewerCertificate_CloudFrontDefaultCertificate = this.ViewerCertificate_CloudFrontDefaultCertificate; context.ViewerCertificate_IAMCertificateId = this.ViewerCertificate_IAMCertificateId; context.ViewerCertificate_MinimumProtocolVersion = this.ViewerCertificate_MinimumProtocolVersion; context.ViewerCertificate_SSLSupportMethod = this.ViewerCertificate_SSLSupportMethod; context.DistributionConfig_WebACLId = this.DistributionConfig_WebACLId; // allow further manipulation of loaded context prior to processing PostExecutionContextLoad(context); var output = Execute(context) as CmdletOutput; ProcessOutput(output); } #region IExecutor Members public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.CloudFront.Model.CreateDistributionRequest(); // populate DistributionConfig var requestDistributionConfigIsNull = true; request.DistributionConfig = new Amazon.CloudFront.Model.DistributionConfig(); System.String requestDistributionConfig_distributionConfig_CallerReference = null; if (cmdletContext.DistributionConfig_CallerReference != null) { requestDistributionConfig_distributionConfig_CallerReference = cmdletContext.DistributionConfig_CallerReference; } if (requestDistributionConfig_distributionConfig_CallerReference != null) { request.DistributionConfig.CallerReference = requestDistributionConfig_distributionConfig_CallerReference; requestDistributionConfigIsNull = false; } System.String requestDistributionConfig_distributionConfig_Comment = null; if (cmdletContext.DistributionConfig_Comment != null) { requestDistributionConfig_distributionConfig_Comment = cmdletContext.DistributionConfig_Comment; } if (requestDistributionConfig_distributionConfig_Comment != null) { request.DistributionConfig.Comment = requestDistributionConfig_distributionConfig_Comment; requestDistributionConfigIsNull = false; } System.String requestDistributionConfig_distributionConfig_ContinuousDeploymentPolicyId = null; if (cmdletContext.DistributionConfig_ContinuousDeploymentPolicyId != null) { requestDistributionConfig_distributionConfig_ContinuousDeploymentPolicyId = cmdletContext.DistributionConfig_ContinuousDeploymentPolicyId; } if (requestDistributionConfig_distributionConfig_ContinuousDeploymentPolicyId != null) { request.DistributionConfig.ContinuousDeploymentPolicyId = requestDistributionConfig_distributionConfig_ContinuousDeploymentPolicyId; requestDistributionConfigIsNull = false; } System.String requestDistributionConfig_distributionConfig_DefaultRootObject = null; if (cmdletContext.DistributionConfig_DefaultRootObject != null) { requestDistributionConfig_distributionConfig_DefaultRootObject = cmdletContext.DistributionConfig_DefaultRootObject; } if (requestDistributionConfig_distributionConfig_DefaultRootObject != null) { request.DistributionConfig.DefaultRootObject = requestDistributionConfig_distributionConfig_DefaultRootObject; requestDistributionConfigIsNull = false; } System.Boolean? requestDistributionConfig_distributionConfig_Enabled = null; if (cmdletContext.DistributionConfig_Enabled != null) { requestDistributionConfig_distributionConfig_Enabled = cmdletContext.DistributionConfig_Enabled.Value; } if (requestDistributionConfig_distributionConfig_Enabled != null) { request.DistributionConfig.Enabled = requestDistributionConfig_distributionConfig_Enabled.Value; requestDistributionConfigIsNull = false; } Amazon.CloudFront.HttpVersion requestDistributionConfig_distributionConfig_HttpVersion = null; if (cmdletContext.DistributionConfig_HttpVersion != null) { requestDistributionConfig_distributionConfig_HttpVersion = cmdletContext.DistributionConfig_HttpVersion; } if (requestDistributionConfig_distributionConfig_HttpVersion != null) { request.DistributionConfig.HttpVersion = requestDistributionConfig_distributionConfig_HttpVersion; requestDistributionConfigIsNull = false; } System.Boolean? requestDistributionConfig_distributionConfig_IsIPV6Enabled = null; if (cmdletContext.DistributionConfig_IsIPV6Enabled != null) { requestDistributionConfig_distributionConfig_IsIPV6Enabled = cmdletContext.DistributionConfig_IsIPV6Enabled.Value; } if (requestDistributionConfig_distributionConfig_IsIPV6Enabled != null) { request.DistributionConfig.IsIPV6Enabled = requestDistributionConfig_distributionConfig_IsIPV6Enabled.Value; requestDistributionConfigIsNull = false; } Amazon.CloudFront.PriceClass requestDistributionConfig_distributionConfig_PriceClass = null; if (cmdletContext.DistributionConfig_PriceClass != null) { requestDistributionConfig_distributionConfig_PriceClass = cmdletContext.DistributionConfig_PriceClass; } if (requestDistributionConfig_distributionConfig_PriceClass != null) { request.DistributionConfig.PriceClass = requestDistributionConfig_distributionConfig_PriceClass; requestDistributionConfigIsNull = false; } System.Boolean? requestDistributionConfig_distributionConfig_Staging = null; if (cmdletContext.DistributionConfig_Staging != null) { requestDistributionConfig_distributionConfig_Staging = cmdletContext.DistributionConfig_Staging.Value; } if (requestDistributionConfig_distributionConfig_Staging != null) { request.DistributionConfig.Staging = requestDistributionConfig_distributionConfig_Staging.Value; requestDistributionConfigIsNull = false; } System.String requestDistributionConfig_distributionConfig_WebACLId = null; if (cmdletContext.DistributionConfig_WebACLId != null) { requestDistributionConfig_distributionConfig_WebACLId = cmdletContext.DistributionConfig_WebACLId; } if (requestDistributionConfig_distributionConfig_WebACLId != null) { request.DistributionConfig.WebACLId = requestDistributionConfig_distributionConfig_WebACLId; requestDistributionConfigIsNull = false; } Amazon.CloudFront.Model.Restrictions requestDistributionConfig_distributionConfig_Restrictions = null; // populate Restrictions var requestDistributionConfig_distributionConfig_RestrictionsIsNull = true; requestDistributionConfig_distributionConfig_Restrictions = new Amazon.CloudFront.Model.Restrictions(); Amazon.CloudFront.Model.GeoRestriction requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction = null; // populate GeoRestriction var requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestrictionIsNull = true; requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction = new Amazon.CloudFront.Model.GeoRestriction(); List requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_Item = null; if (cmdletContext.GeoRestriction_Item != null) { requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_Item = cmdletContext.GeoRestriction_Item; } if (requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_Item != null) { requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction.Items = requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_Item; requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestrictionIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_Quantity = null; if (cmdletContext.GeoRestriction_Quantity != null) { requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_Quantity = cmdletContext.GeoRestriction_Quantity.Value; } if (requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_Quantity != null) { requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction.Quantity = requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_Quantity.Value; requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestrictionIsNull = false; } Amazon.CloudFront.GeoRestrictionType requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_RestrictionType = null; if (cmdletContext.GeoRestriction_RestrictionType != null) { requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_RestrictionType = cmdletContext.GeoRestriction_RestrictionType; } if (requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_RestrictionType != null) { requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction.RestrictionType = requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction_geoRestriction_RestrictionType; requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestrictionIsNull = false; } // determine if requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction should be set to null if (requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestrictionIsNull) { requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction = null; } if (requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction != null) { requestDistributionConfig_distributionConfig_Restrictions.GeoRestriction = requestDistributionConfig_distributionConfig_Restrictions_distributionConfig_Restrictions_GeoRestriction; requestDistributionConfig_distributionConfig_RestrictionsIsNull = false; } // determine if requestDistributionConfig_distributionConfig_Restrictions should be set to null if (requestDistributionConfig_distributionConfig_RestrictionsIsNull) { requestDistributionConfig_distributionConfig_Restrictions = null; } if (requestDistributionConfig_distributionConfig_Restrictions != null) { request.DistributionConfig.Restrictions = requestDistributionConfig_distributionConfig_Restrictions; requestDistributionConfigIsNull = false; } Amazon.CloudFront.Model.Aliases requestDistributionConfig_distributionConfig_Aliases = null; // populate Aliases var requestDistributionConfig_distributionConfig_AliasesIsNull = true; requestDistributionConfig_distributionConfig_Aliases = new Amazon.CloudFront.Model.Aliases(); List requestDistributionConfig_distributionConfig_Aliases_aliases_Item = null; if (cmdletContext.Aliases_Item != null) { requestDistributionConfig_distributionConfig_Aliases_aliases_Item = cmdletContext.Aliases_Item; } if (requestDistributionConfig_distributionConfig_Aliases_aliases_Item != null) { requestDistributionConfig_distributionConfig_Aliases.Items = requestDistributionConfig_distributionConfig_Aliases_aliases_Item; requestDistributionConfig_distributionConfig_AliasesIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_Aliases_aliases_Quantity = null; if (cmdletContext.Aliases_Quantity != null) { requestDistributionConfig_distributionConfig_Aliases_aliases_Quantity = cmdletContext.Aliases_Quantity.Value; } if (requestDistributionConfig_distributionConfig_Aliases_aliases_Quantity != null) { requestDistributionConfig_distributionConfig_Aliases.Quantity = requestDistributionConfig_distributionConfig_Aliases_aliases_Quantity.Value; requestDistributionConfig_distributionConfig_AliasesIsNull = false; } // determine if requestDistributionConfig_distributionConfig_Aliases should be set to null if (requestDistributionConfig_distributionConfig_AliasesIsNull) { requestDistributionConfig_distributionConfig_Aliases = null; } if (requestDistributionConfig_distributionConfig_Aliases != null) { request.DistributionConfig.Aliases = requestDistributionConfig_distributionConfig_Aliases; requestDistributionConfigIsNull = false; } Amazon.CloudFront.Model.CacheBehaviors requestDistributionConfig_distributionConfig_CacheBehaviors = null; // populate CacheBehaviors var requestDistributionConfig_distributionConfig_CacheBehaviorsIsNull = true; requestDistributionConfig_distributionConfig_CacheBehaviors = new Amazon.CloudFront.Model.CacheBehaviors(); List requestDistributionConfig_distributionConfig_CacheBehaviors_cacheBehaviors_Item = null; if (cmdletContext.CacheBehaviors_Item != null) { requestDistributionConfig_distributionConfig_CacheBehaviors_cacheBehaviors_Item = cmdletContext.CacheBehaviors_Item; } if (requestDistributionConfig_distributionConfig_CacheBehaviors_cacheBehaviors_Item != null) { requestDistributionConfig_distributionConfig_CacheBehaviors.Items = requestDistributionConfig_distributionConfig_CacheBehaviors_cacheBehaviors_Item; requestDistributionConfig_distributionConfig_CacheBehaviorsIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_CacheBehaviors_cacheBehaviors_Quantity = null; if (cmdletContext.CacheBehaviors_Quantity != null) { requestDistributionConfig_distributionConfig_CacheBehaviors_cacheBehaviors_Quantity = cmdletContext.CacheBehaviors_Quantity.Value; } if (requestDistributionConfig_distributionConfig_CacheBehaviors_cacheBehaviors_Quantity != null) { requestDistributionConfig_distributionConfig_CacheBehaviors.Quantity = requestDistributionConfig_distributionConfig_CacheBehaviors_cacheBehaviors_Quantity.Value; requestDistributionConfig_distributionConfig_CacheBehaviorsIsNull = false; } // determine if requestDistributionConfig_distributionConfig_CacheBehaviors should be set to null if (requestDistributionConfig_distributionConfig_CacheBehaviorsIsNull) { requestDistributionConfig_distributionConfig_CacheBehaviors = null; } if (requestDistributionConfig_distributionConfig_CacheBehaviors != null) { request.DistributionConfig.CacheBehaviors = requestDistributionConfig_distributionConfig_CacheBehaviors; requestDistributionConfigIsNull = false; } Amazon.CloudFront.Model.CustomErrorResponses requestDistributionConfig_distributionConfig_CustomErrorResponses = null; // populate CustomErrorResponses var requestDistributionConfig_distributionConfig_CustomErrorResponsesIsNull = true; requestDistributionConfig_distributionConfig_CustomErrorResponses = new Amazon.CloudFront.Model.CustomErrorResponses(); List requestDistributionConfig_distributionConfig_CustomErrorResponses_customErrorResponses_Item = null; if (cmdletContext.CustomErrorResponses_Item != null) { requestDistributionConfig_distributionConfig_CustomErrorResponses_customErrorResponses_Item = cmdletContext.CustomErrorResponses_Item; } if (requestDistributionConfig_distributionConfig_CustomErrorResponses_customErrorResponses_Item != null) { requestDistributionConfig_distributionConfig_CustomErrorResponses.Items = requestDistributionConfig_distributionConfig_CustomErrorResponses_customErrorResponses_Item; requestDistributionConfig_distributionConfig_CustomErrorResponsesIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_CustomErrorResponses_customErrorResponses_Quantity = null; if (cmdletContext.CustomErrorResponses_Quantity != null) { requestDistributionConfig_distributionConfig_CustomErrorResponses_customErrorResponses_Quantity = cmdletContext.CustomErrorResponses_Quantity.Value; } if (requestDistributionConfig_distributionConfig_CustomErrorResponses_customErrorResponses_Quantity != null) { requestDistributionConfig_distributionConfig_CustomErrorResponses.Quantity = requestDistributionConfig_distributionConfig_CustomErrorResponses_customErrorResponses_Quantity.Value; requestDistributionConfig_distributionConfig_CustomErrorResponsesIsNull = false; } // determine if requestDistributionConfig_distributionConfig_CustomErrorResponses should be set to null if (requestDistributionConfig_distributionConfig_CustomErrorResponsesIsNull) { requestDistributionConfig_distributionConfig_CustomErrorResponses = null; } if (requestDistributionConfig_distributionConfig_CustomErrorResponses != null) { request.DistributionConfig.CustomErrorResponses = requestDistributionConfig_distributionConfig_CustomErrorResponses; requestDistributionConfigIsNull = false; } Amazon.CloudFront.Model.OriginGroups requestDistributionConfig_distributionConfig_OriginGroups = null; // populate OriginGroups var requestDistributionConfig_distributionConfig_OriginGroupsIsNull = true; requestDistributionConfig_distributionConfig_OriginGroups = new Amazon.CloudFront.Model.OriginGroups(); List requestDistributionConfig_distributionConfig_OriginGroups_originGroups_Item = null; if (cmdletContext.OriginGroups_Item != null) { requestDistributionConfig_distributionConfig_OriginGroups_originGroups_Item = cmdletContext.OriginGroups_Item; } if (requestDistributionConfig_distributionConfig_OriginGroups_originGroups_Item != null) { requestDistributionConfig_distributionConfig_OriginGroups.Items = requestDistributionConfig_distributionConfig_OriginGroups_originGroups_Item; requestDistributionConfig_distributionConfig_OriginGroupsIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_OriginGroups_originGroups_Quantity = null; if (cmdletContext.OriginGroups_Quantity != null) { requestDistributionConfig_distributionConfig_OriginGroups_originGroups_Quantity = cmdletContext.OriginGroups_Quantity.Value; } if (requestDistributionConfig_distributionConfig_OriginGroups_originGroups_Quantity != null) { requestDistributionConfig_distributionConfig_OriginGroups.Quantity = requestDistributionConfig_distributionConfig_OriginGroups_originGroups_Quantity.Value; requestDistributionConfig_distributionConfig_OriginGroupsIsNull = false; } // determine if requestDistributionConfig_distributionConfig_OriginGroups should be set to null if (requestDistributionConfig_distributionConfig_OriginGroupsIsNull) { requestDistributionConfig_distributionConfig_OriginGroups = null; } if (requestDistributionConfig_distributionConfig_OriginGroups != null) { request.DistributionConfig.OriginGroups = requestDistributionConfig_distributionConfig_OriginGroups; requestDistributionConfigIsNull = false; } Amazon.CloudFront.Model.Origins requestDistributionConfig_distributionConfig_Origins = null; // populate Origins var requestDistributionConfig_distributionConfig_OriginsIsNull = true; requestDistributionConfig_distributionConfig_Origins = new Amazon.CloudFront.Model.Origins(); List requestDistributionConfig_distributionConfig_Origins_origins_Item = null; if (cmdletContext.Origins_Item != null) { requestDistributionConfig_distributionConfig_Origins_origins_Item = cmdletContext.Origins_Item; } if (requestDistributionConfig_distributionConfig_Origins_origins_Item != null) { requestDistributionConfig_distributionConfig_Origins.Items = requestDistributionConfig_distributionConfig_Origins_origins_Item; requestDistributionConfig_distributionConfig_OriginsIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_Origins_origins_Quantity = null; if (cmdletContext.Origins_Quantity != null) { requestDistributionConfig_distributionConfig_Origins_origins_Quantity = cmdletContext.Origins_Quantity.Value; } if (requestDistributionConfig_distributionConfig_Origins_origins_Quantity != null) { requestDistributionConfig_distributionConfig_Origins.Quantity = requestDistributionConfig_distributionConfig_Origins_origins_Quantity.Value; requestDistributionConfig_distributionConfig_OriginsIsNull = false; } // determine if requestDistributionConfig_distributionConfig_Origins should be set to null if (requestDistributionConfig_distributionConfig_OriginsIsNull) { requestDistributionConfig_distributionConfig_Origins = null; } if (requestDistributionConfig_distributionConfig_Origins != null) { request.DistributionConfig.Origins = requestDistributionConfig_distributionConfig_Origins; requestDistributionConfigIsNull = false; } Amazon.CloudFront.Model.LoggingConfig requestDistributionConfig_distributionConfig_Logging = null; // populate Logging var requestDistributionConfig_distributionConfig_LoggingIsNull = true; requestDistributionConfig_distributionConfig_Logging = new Amazon.CloudFront.Model.LoggingConfig(); System.String requestDistributionConfig_distributionConfig_Logging_logging_Bucket = null; if (cmdletContext.Logging_Bucket != null) { requestDistributionConfig_distributionConfig_Logging_logging_Bucket = cmdletContext.Logging_Bucket; } if (requestDistributionConfig_distributionConfig_Logging_logging_Bucket != null) { requestDistributionConfig_distributionConfig_Logging.Bucket = requestDistributionConfig_distributionConfig_Logging_logging_Bucket; requestDistributionConfig_distributionConfig_LoggingIsNull = false; } System.Boolean? requestDistributionConfig_distributionConfig_Logging_logging_Enabled = null; if (cmdletContext.Logging_Enabled != null) { requestDistributionConfig_distributionConfig_Logging_logging_Enabled = cmdletContext.Logging_Enabled.Value; } if (requestDistributionConfig_distributionConfig_Logging_logging_Enabled != null) { requestDistributionConfig_distributionConfig_Logging.Enabled = requestDistributionConfig_distributionConfig_Logging_logging_Enabled.Value; requestDistributionConfig_distributionConfig_LoggingIsNull = false; } System.Boolean? requestDistributionConfig_distributionConfig_Logging_logging_IncludeCookie = null; if (cmdletContext.Logging_IncludeCookie != null) { requestDistributionConfig_distributionConfig_Logging_logging_IncludeCookie = cmdletContext.Logging_IncludeCookie.Value; } if (requestDistributionConfig_distributionConfig_Logging_logging_IncludeCookie != null) { requestDistributionConfig_distributionConfig_Logging.IncludeCookies = requestDistributionConfig_distributionConfig_Logging_logging_IncludeCookie.Value; requestDistributionConfig_distributionConfig_LoggingIsNull = false; } System.String requestDistributionConfig_distributionConfig_Logging_logging_Prefix = null; if (cmdletContext.Logging_Prefix != null) { requestDistributionConfig_distributionConfig_Logging_logging_Prefix = cmdletContext.Logging_Prefix; } if (requestDistributionConfig_distributionConfig_Logging_logging_Prefix != null) { requestDistributionConfig_distributionConfig_Logging.Prefix = requestDistributionConfig_distributionConfig_Logging_logging_Prefix; requestDistributionConfig_distributionConfig_LoggingIsNull = false; } // determine if requestDistributionConfig_distributionConfig_Logging should be set to null if (requestDistributionConfig_distributionConfig_LoggingIsNull) { requestDistributionConfig_distributionConfig_Logging = null; } if (requestDistributionConfig_distributionConfig_Logging != null) { request.DistributionConfig.Logging = requestDistributionConfig_distributionConfig_Logging; requestDistributionConfigIsNull = false; } Amazon.CloudFront.Model.ViewerCertificate requestDistributionConfig_distributionConfig_ViewerCertificate = null; // populate ViewerCertificate var requestDistributionConfig_distributionConfig_ViewerCertificateIsNull = true; requestDistributionConfig_distributionConfig_ViewerCertificate = new Amazon.CloudFront.Model.ViewerCertificate(); System.String requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_ACMCertificateArn = null; if (cmdletContext.ViewerCertificate_ACMCertificateArn != null) { requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_ACMCertificateArn = cmdletContext.ViewerCertificate_ACMCertificateArn; } if (requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_ACMCertificateArn != null) { requestDistributionConfig_distributionConfig_ViewerCertificate.ACMCertificateArn = requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_ACMCertificateArn; requestDistributionConfig_distributionConfig_ViewerCertificateIsNull = false; } #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute System.String requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_Certificate = null; if (cmdletContext.ViewerCertificate_Certificate != null) { requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_Certificate = cmdletContext.ViewerCertificate_Certificate; } if (requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_Certificate != null) { requestDistributionConfig_distributionConfig_ViewerCertificate.Certificate = requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_Certificate; requestDistributionConfig_distributionConfig_ViewerCertificateIsNull = false; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute Amazon.CloudFront.CertificateSource requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_CertificateSource = null; if (cmdletContext.ViewerCertificate_CertificateSource != null) { requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_CertificateSource = cmdletContext.ViewerCertificate_CertificateSource; } if (requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_CertificateSource != null) { requestDistributionConfig_distributionConfig_ViewerCertificate.CertificateSource = requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_CertificateSource; requestDistributionConfig_distributionConfig_ViewerCertificateIsNull = false; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute System.Boolean? requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_CloudFrontDefaultCertificate = null; if (cmdletContext.ViewerCertificate_CloudFrontDefaultCertificate != null) { requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_CloudFrontDefaultCertificate = cmdletContext.ViewerCertificate_CloudFrontDefaultCertificate.Value; } if (requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_CloudFrontDefaultCertificate != null) { requestDistributionConfig_distributionConfig_ViewerCertificate.CloudFrontDefaultCertificate = requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_CloudFrontDefaultCertificate.Value; requestDistributionConfig_distributionConfig_ViewerCertificateIsNull = false; } System.String requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_IAMCertificateId = null; if (cmdletContext.ViewerCertificate_IAMCertificateId != null) { requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_IAMCertificateId = cmdletContext.ViewerCertificate_IAMCertificateId; } if (requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_IAMCertificateId != null) { requestDistributionConfig_distributionConfig_ViewerCertificate.IAMCertificateId = requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_IAMCertificateId; requestDistributionConfig_distributionConfig_ViewerCertificateIsNull = false; } Amazon.CloudFront.MinimumProtocolVersion requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_MinimumProtocolVersion = null; if (cmdletContext.ViewerCertificate_MinimumProtocolVersion != null) { requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_MinimumProtocolVersion = cmdletContext.ViewerCertificate_MinimumProtocolVersion; } if (requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_MinimumProtocolVersion != null) { requestDistributionConfig_distributionConfig_ViewerCertificate.MinimumProtocolVersion = requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_MinimumProtocolVersion; requestDistributionConfig_distributionConfig_ViewerCertificateIsNull = false; } Amazon.CloudFront.SSLSupportMethod requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_SSLSupportMethod = null; if (cmdletContext.ViewerCertificate_SSLSupportMethod != null) { requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_SSLSupportMethod = cmdletContext.ViewerCertificate_SSLSupportMethod; } if (requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_SSLSupportMethod != null) { requestDistributionConfig_distributionConfig_ViewerCertificate.SSLSupportMethod = requestDistributionConfig_distributionConfig_ViewerCertificate_viewerCertificate_SSLSupportMethod; requestDistributionConfig_distributionConfig_ViewerCertificateIsNull = false; } // determine if requestDistributionConfig_distributionConfig_ViewerCertificate should be set to null if (requestDistributionConfig_distributionConfig_ViewerCertificateIsNull) { requestDistributionConfig_distributionConfig_ViewerCertificate = null; } if (requestDistributionConfig_distributionConfig_ViewerCertificate != null) { request.DistributionConfig.ViewerCertificate = requestDistributionConfig_distributionConfig_ViewerCertificate; requestDistributionConfigIsNull = false; } Amazon.CloudFront.Model.DefaultCacheBehavior requestDistributionConfig_distributionConfig_DefaultCacheBehavior = null; // populate DefaultCacheBehavior var requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior = new Amazon.CloudFront.Model.DefaultCacheBehavior(); System.String requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_CachePolicyId = null; if (cmdletContext.DefaultCacheBehavior_CachePolicyId != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_CachePolicyId = cmdletContext.DefaultCacheBehavior_CachePolicyId; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_CachePolicyId != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.CachePolicyId = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_CachePolicyId; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } System.Boolean? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_Compress = null; if (cmdletContext.DefaultCacheBehavior_Compress != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_Compress = cmdletContext.DefaultCacheBehavior_Compress.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_Compress != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.Compress = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_Compress.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute System.Int64? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_DefaultTTL = null; if (cmdletContext.DefaultCacheBehavior_DefaultTTL != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_DefaultTTL = cmdletContext.DefaultCacheBehavior_DefaultTTL.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_DefaultTTL != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.DefaultTTL = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_DefaultTTL.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute System.String requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_FieldLevelEncryptionId = null; if (cmdletContext.DefaultCacheBehavior_FieldLevelEncryptionId != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_FieldLevelEncryptionId = cmdletContext.DefaultCacheBehavior_FieldLevelEncryptionId; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_FieldLevelEncryptionId != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.FieldLevelEncryptionId = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_FieldLevelEncryptionId; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute System.Int64? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_MaxTTL = null; if (cmdletContext.DefaultCacheBehavior_MaxTTL != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_MaxTTL = cmdletContext.DefaultCacheBehavior_MaxTTL.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_MaxTTL != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.MaxTTL = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_MaxTTL.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute System.Int64? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_MinTTL = null; if (cmdletContext.DefaultCacheBehavior_MinTTL != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_MinTTL = cmdletContext.DefaultCacheBehavior_MinTTL.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_MinTTL != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.MinTTL = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_MinTTL.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute System.String requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_OriginRequestPolicyId = null; if (cmdletContext.DefaultCacheBehavior_OriginRequestPolicyId != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_OriginRequestPolicyId = cmdletContext.DefaultCacheBehavior_OriginRequestPolicyId; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_OriginRequestPolicyId != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.OriginRequestPolicyId = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_OriginRequestPolicyId; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } System.String requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_RealtimeLogConfigArn = null; if (cmdletContext.DefaultCacheBehavior_RealtimeLogConfigArn != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_RealtimeLogConfigArn = cmdletContext.DefaultCacheBehavior_RealtimeLogConfigArn; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_RealtimeLogConfigArn != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.RealtimeLogConfigArn = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_RealtimeLogConfigArn; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } System.String requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_ResponseHeadersPolicyId = null; if (cmdletContext.DefaultCacheBehavior_ResponseHeadersPolicyId != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_ResponseHeadersPolicyId = cmdletContext.DefaultCacheBehavior_ResponseHeadersPolicyId; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_ResponseHeadersPolicyId != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.ResponseHeadersPolicyId = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_ResponseHeadersPolicyId; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } System.Boolean? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_SmoothStreaming = null; if (cmdletContext.DefaultCacheBehavior_SmoothStreaming != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_SmoothStreaming = cmdletContext.DefaultCacheBehavior_SmoothStreaming.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_SmoothStreaming != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.SmoothStreaming = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_SmoothStreaming.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } System.String requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_TargetOriginId = null; if (cmdletContext.DefaultCacheBehavior_TargetOriginId != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_TargetOriginId = cmdletContext.DefaultCacheBehavior_TargetOriginId; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_TargetOriginId != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.TargetOriginId = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_TargetOriginId; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } Amazon.CloudFront.ViewerProtocolPolicy requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_ViewerProtocolPolicy = null; if (cmdletContext.DefaultCacheBehavior_ViewerProtocolPolicy != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_ViewerProtocolPolicy = cmdletContext.DefaultCacheBehavior_ViewerProtocolPolicy; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_ViewerProtocolPolicy != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.ViewerProtocolPolicy = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_defaultCacheBehavior_ViewerProtocolPolicy; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } Amazon.CloudFront.Model.FunctionAssociations requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations = null; // populate FunctionAssociations var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociationsIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations = new Amazon.CloudFront.Model.FunctionAssociations(); List requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations_functionAssociations_Item = null; if (cmdletContext.FunctionAssociations_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations_functionAssociations_Item = cmdletContext.FunctionAssociations_Item; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations_functionAssociations_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations.Items = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations_functionAssociations_Item; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociationsIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations_functionAssociations_Quantity = null; if (cmdletContext.FunctionAssociations_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations_functionAssociations_Quantity = cmdletContext.FunctionAssociations_Quantity.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations_functionAssociations_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations.Quantity = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations_functionAssociations_Quantity.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociationsIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociationsIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.FunctionAssociations = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_FunctionAssociations; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } Amazon.CloudFront.Model.LambdaFunctionAssociations requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations = null; // populate LambdaFunctionAssociations var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociationsIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations = new Amazon.CloudFront.Model.LambdaFunctionAssociations(); List requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations_lambdaFunctionAssociations_Item = null; if (cmdletContext.LambdaFunctionAssociations_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations_lambdaFunctionAssociations_Item = cmdletContext.LambdaFunctionAssociations_Item; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations_lambdaFunctionAssociations_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations.Items = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations_lambdaFunctionAssociations_Item; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociationsIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations_lambdaFunctionAssociations_Quantity = null; if (cmdletContext.LambdaFunctionAssociations_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations_lambdaFunctionAssociations_Quantity = cmdletContext.LambdaFunctionAssociations_Quantity.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations_lambdaFunctionAssociations_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations.Quantity = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations_lambdaFunctionAssociations_Quantity.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociationsIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociationsIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.LambdaFunctionAssociations = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_LambdaFunctionAssociations; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } Amazon.CloudFront.Model.AllowedMethods requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods = null; // populate AllowedMethods var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethodsIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods = new Amazon.CloudFront.Model.AllowedMethods(); List requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_allowedMethods_Item = null; if (cmdletContext.AllowedMethods_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_allowedMethods_Item = cmdletContext.AllowedMethods_Item; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_allowedMethods_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods.Items = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_allowedMethods_Item; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethodsIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_allowedMethods_Quantity = null; if (cmdletContext.AllowedMethods_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_allowedMethods_Quantity = cmdletContext.AllowedMethods_Quantity.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_allowedMethods_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods.Quantity = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_allowedMethods_Quantity.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethodsIsNull = false; } Amazon.CloudFront.Model.CachedMethods requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods = null; // populate CachedMethods var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethodsIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods = new Amazon.CloudFront.Model.CachedMethods(); List requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods_cachedMethods_Item = null; if (cmdletContext.CachedMethods_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods_cachedMethods_Item = cmdletContext.CachedMethods_Item; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods_cachedMethods_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods.Items = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods_cachedMethods_Item; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethodsIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods_cachedMethods_Quantity = null; if (cmdletContext.CachedMethods_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods_cachedMethods_Quantity = cmdletContext.CachedMethods_Quantity.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods_cachedMethods_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods.Quantity = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods_cachedMethods_Quantity.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethodsIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethodsIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods.CachedMethods = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods_distributionConfig_DefaultCacheBehavior_AllowedMethods_CachedMethods; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethodsIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethodsIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.AllowedMethods = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_AllowedMethods; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } Amazon.CloudFront.Model.TrustedKeyGroups requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups = null; // populate TrustedKeyGroups var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroupsIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups = new Amazon.CloudFront.Model.TrustedKeyGroups(); System.Boolean? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Enabled = null; if (cmdletContext.TrustedKeyGroups_Enabled != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Enabled = cmdletContext.TrustedKeyGroups_Enabled.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Enabled != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups.Enabled = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Enabled.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroupsIsNull = false; } List requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Item = null; if (cmdletContext.TrustedKeyGroups_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Item = cmdletContext.TrustedKeyGroups_Item; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups.Items = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Item; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroupsIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Quantity = null; if (cmdletContext.TrustedKeyGroups_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Quantity = cmdletContext.TrustedKeyGroups_Quantity.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups.Quantity = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups_trustedKeyGroups_Quantity.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroupsIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroupsIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.TrustedKeyGroups = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedKeyGroups; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } Amazon.CloudFront.Model.TrustedSigners requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners = null; // populate TrustedSigners var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSignersIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners = new Amazon.CloudFront.Model.TrustedSigners(); System.Boolean? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Enabled = null; if (cmdletContext.TrustedSigners_Enabled != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Enabled = cmdletContext.TrustedSigners_Enabled.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Enabled != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners.Enabled = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Enabled.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSignersIsNull = false; } List requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Item = null; if (cmdletContext.TrustedSigners_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Item = cmdletContext.TrustedSigners_Item; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners.Items = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Item; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSignersIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Quantity = null; if (cmdletContext.TrustedSigners_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Quantity = cmdletContext.TrustedSigners_Quantity.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners.Quantity = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners_trustedSigners_Quantity.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSignersIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSignersIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.TrustedSigners = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_TrustedSigners; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute Amazon.CloudFront.Model.ForwardedValues requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues = null; // populate ForwardedValues var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValuesIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues = new Amazon.CloudFront.Model.ForwardedValues(); System.Boolean? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_forwardedValues_QueryString = null; if (cmdletContext.ForwardedValues_QueryString != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_forwardedValues_QueryString = cmdletContext.ForwardedValues_QueryString.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_forwardedValues_QueryString != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues.QueryString = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_forwardedValues_QueryString.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValuesIsNull = false; } Amazon.CloudFront.Model.CookiePreference requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies = null; // populate Cookies var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_CookiesIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies = new Amazon.CloudFront.Model.CookiePreference(); Amazon.CloudFront.ItemSelection requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_cookies_Forward = null; if (cmdletContext.Cookies_Forward != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_cookies_Forward = cmdletContext.Cookies_Forward; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_cookies_Forward != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies.Forward = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_cookies_Forward; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_CookiesIsNull = false; } Amazon.CloudFront.Model.CookieNames requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames = null; // populate WhitelistedNames var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNamesIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames = new Amazon.CloudFront.Model.CookieNames(); List requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames_whitelistedNames_Item = null; if (cmdletContext.WhitelistedNames_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames_whitelistedNames_Item = cmdletContext.WhitelistedNames_Item; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames_whitelistedNames_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames.Items = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames_whitelistedNames_Item; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNamesIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames_whitelistedNames_Quantity = null; if (cmdletContext.WhitelistedNames_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames_whitelistedNames_Quantity = cmdletContext.WhitelistedNames_Quantity.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames_whitelistedNames_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames.Quantity = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames_whitelistedNames_Quantity.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNamesIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNamesIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies.WhitelistedNames = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies_WhitelistedNames; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_CookiesIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_CookiesIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues.Cookies = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Cookies; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValuesIsNull = false; } Amazon.CloudFront.Model.Headers requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers = null; // populate Headers var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_HeadersIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers = new Amazon.CloudFront.Model.Headers(); List requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers_headers_Item = null; if (cmdletContext.Headers_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers_headers_Item = cmdletContext.Headers_Item; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers_headers_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers.Items = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers_headers_Item; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_HeadersIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers_headers_Quantity = null; if (cmdletContext.Headers_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers_headers_Quantity = cmdletContext.Headers_Quantity.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers_headers_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers.Quantity = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers_headers_Quantity.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_HeadersIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_HeadersIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues.Headers = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_Headers; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValuesIsNull = false; } Amazon.CloudFront.Model.QueryStringCacheKeys requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys = null; // populate QueryStringCacheKeys var requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeysIsNull = true; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys = new Amazon.CloudFront.Model.QueryStringCacheKeys(); List requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys_queryStringCacheKeys_Item = null; if (cmdletContext.QueryStringCacheKeys_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys_queryStringCacheKeys_Item = cmdletContext.QueryStringCacheKeys_Item; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys_queryStringCacheKeys_Item != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys.Items = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys_queryStringCacheKeys_Item; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeysIsNull = false; } System.Int32? requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys_queryStringCacheKeys_Quantity = null; if (cmdletContext.QueryStringCacheKeys_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys_queryStringCacheKeys_Quantity = cmdletContext.QueryStringCacheKeys_Quantity.Value; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys_queryStringCacheKeys_Quantity != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys.Quantity = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys_queryStringCacheKeys_Quantity.Value; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeysIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeysIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues.QueryStringCacheKeys = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues_distributionConfig_DefaultCacheBehavior_ForwardedValues_QueryStringCacheKeys; requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValuesIsNull = false; } // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValuesIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues != null) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior.ForwardedValues = requestDistributionConfig_distributionConfig_DefaultCacheBehavior_distributionConfig_DefaultCacheBehavior_ForwardedValues; requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull = false; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute // determine if requestDistributionConfig_distributionConfig_DefaultCacheBehavior should be set to null if (requestDistributionConfig_distributionConfig_DefaultCacheBehaviorIsNull) { requestDistributionConfig_distributionConfig_DefaultCacheBehavior = null; } if (requestDistributionConfig_distributionConfig_DefaultCacheBehavior != null) { request.DistributionConfig.DefaultCacheBehavior = requestDistributionConfig_distributionConfig_DefaultCacheBehavior; requestDistributionConfigIsNull = false; } // determine if request.DistributionConfig should be set to null if (requestDistributionConfigIsNull) { request.DistributionConfig = null; } CmdletOutput output; // issue call var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint); try { var response = CallAWSServiceOperation(client, request); object pipelineOutput = null; pipelineOutput = cmdletContext.Select(response, this); output = new CmdletOutput { PipelineOutput = pipelineOutput, ServiceResponse = response }; } catch (Exception e) { output = new CmdletOutput { ErrorResponse = e }; } return output; } public ExecutorContext CreateContext() { return new CmdletContext(); } #endregion #region AWS Service Operation Call private Amazon.CloudFront.Model.CreateDistributionResponse CallAWSServiceOperation(IAmazonCloudFront client, Amazon.CloudFront.Model.CreateDistributionRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon CloudFront", "CreateDistribution"); try { #if DESKTOP return client.CreateDistribution(request); #elif CORECLR return client.CreateDistributionAsync(request).GetAwaiter().GetResult(); #else #error "Unknown build edition" #endif } catch (AmazonServiceException exc) { var webException = exc.InnerException as System.Net.WebException; if (webException != null) { throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException); } throw; } } #endregion internal partial class CmdletContext : ExecutorContext { public List Aliases_Item { get; set; } public System.Int32? Aliases_Quantity { get; set; } public List CacheBehaviors_Item { get; set; } public System.Int32? CacheBehaviors_Quantity { get; set; } public System.String DistributionConfig_CallerReference { get; set; } public System.String DistributionConfig_Comment { get; set; } public System.String DistributionConfig_ContinuousDeploymentPolicyId { get; set; } public List CustomErrorResponses_Item { get; set; } public System.Int32? CustomErrorResponses_Quantity { get; set; } public List CachedMethods_Item { get; set; } public System.Int32? CachedMethods_Quantity { get; set; } public List AllowedMethods_Item { get; set; } public System.Int32? AllowedMethods_Quantity { get; set; } public System.String DefaultCacheBehavior_CachePolicyId { get; set; } public System.Boolean? DefaultCacheBehavior_Compress { get; set; } [System.ObsoleteAttribute] public System.Int64? DefaultCacheBehavior_DefaultTTL { get; set; } public System.String DefaultCacheBehavior_FieldLevelEncryptionId { get; set; } public Amazon.CloudFront.ItemSelection Cookies_Forward { get; set; } public List WhitelistedNames_Item { get; set; } public System.Int32? WhitelistedNames_Quantity { get; set; } public List Headers_Item { get; set; } public System.Int32? Headers_Quantity { get; set; } public System.Boolean? ForwardedValues_QueryString { get; set; } public List QueryStringCacheKeys_Item { get; set; } public System.Int32? QueryStringCacheKeys_Quantity { get; set; } public List FunctionAssociations_Item { get; set; } public System.Int32? FunctionAssociations_Quantity { get; set; } public List LambdaFunctionAssociations_Item { get; set; } public System.Int32? LambdaFunctionAssociations_Quantity { get; set; } [System.ObsoleteAttribute] public System.Int64? DefaultCacheBehavior_MaxTTL { get; set; } [System.ObsoleteAttribute] public System.Int64? DefaultCacheBehavior_MinTTL { get; set; } public System.String DefaultCacheBehavior_OriginRequestPolicyId { get; set; } public System.String DefaultCacheBehavior_RealtimeLogConfigArn { get; set; } public System.String DefaultCacheBehavior_ResponseHeadersPolicyId { get; set; } public System.Boolean? DefaultCacheBehavior_SmoothStreaming { get; set; } public System.String DefaultCacheBehavior_TargetOriginId { get; set; } public System.Boolean? TrustedKeyGroups_Enabled { get; set; } public List TrustedKeyGroups_Item { get; set; } public System.Int32? TrustedKeyGroups_Quantity { get; set; } public System.Boolean? TrustedSigners_Enabled { get; set; } public List TrustedSigners_Item { get; set; } public System.Int32? TrustedSigners_Quantity { get; set; } public Amazon.CloudFront.ViewerProtocolPolicy DefaultCacheBehavior_ViewerProtocolPolicy { get; set; } public System.String DistributionConfig_DefaultRootObject { get; set; } public System.Boolean? DistributionConfig_Enabled { get; set; } public Amazon.CloudFront.HttpVersion DistributionConfig_HttpVersion { get; set; } public System.Boolean? DistributionConfig_IsIPV6Enabled { get; set; } public System.String Logging_Bucket { get; set; } public System.Boolean? Logging_Enabled { get; set; } public System.Boolean? Logging_IncludeCookie { get; set; } public System.String Logging_Prefix { get; set; } public List OriginGroups_Item { get; set; } public System.Int32? OriginGroups_Quantity { get; set; } public List Origins_Item { get; set; } public System.Int32? Origins_Quantity { get; set; } public Amazon.CloudFront.PriceClass DistributionConfig_PriceClass { get; set; } public List GeoRestriction_Item { get; set; } public System.Int32? GeoRestriction_Quantity { get; set; } public Amazon.CloudFront.GeoRestrictionType GeoRestriction_RestrictionType { get; set; } public System.Boolean? DistributionConfig_Staging { get; set; } public System.String ViewerCertificate_ACMCertificateArn { get; set; } [System.ObsoleteAttribute] public System.String ViewerCertificate_Certificate { get; set; } [System.ObsoleteAttribute] public Amazon.CloudFront.CertificateSource ViewerCertificate_CertificateSource { get; set; } public System.Boolean? ViewerCertificate_CloudFrontDefaultCertificate { get; set; } public System.String ViewerCertificate_IAMCertificateId { get; set; } public Amazon.CloudFront.MinimumProtocolVersion ViewerCertificate_MinimumProtocolVersion { get; set; } public Amazon.CloudFront.SSLSupportMethod ViewerCertificate_SSLSupportMethod { get; set; } public System.String DistributionConfig_WebACLId { get; set; } public System.Func Select { get; set; } = (response, cmdlet) => response; } } }