// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Pulumi.Serialization;
using Pulumi;

namespace PiersKarsenbarg.Nutanix
{
    public static class GetNetworkSecurityRule
    {
        /// <summary>
        /// Describes a Network security rule
        /// 
        /// &gt; NOTE: The use of network_security_rule is only applicable in AHV clusters and requires Microsegmentation to be enabled. This feature is a function of the Flow product and requires a Flow license. For more information on Flow and Microsegmentation please visit https://www.nutanix.com/products/flow
        /// 
        /// {{% examples %}}
        /// ## Example Usage
        /// {{% example %}}
        /// ### Isolate Development VMs From Production VMs And Get Its Information)
        /// 
        /// ```csharp
        /// using Pulumi;
        /// using Nutanix = PiersKarsenbarg.Nutanix;
        /// using Nutanix = Pulumi.Nutanix;
        /// 
        /// class MyStack : Stack
        /// {
        ///     public MyStack()
        ///     {
        ///         var isolation = new Nutanix.NetworkSecurityRule("isolation", new Nutanix.NetworkSecurityRuleArgs
        ///         {
        ///             Description = "Isolation Rule Example",
        ///             IsolationRuleAction = "APPLY",
        ///             IsolationRuleFirstEntityFilterKindLists = 
        ///             {
        ///                 "vm",
        ///             },
        ///             IsolationRuleFirstEntityFilterParams = 
        ///             {
        ///                 new Nutanix.Inputs.NetworkSecurityRuleIsolationRuleFirstEntityFilterParamArgs
        ///                 {
        ///                     Name = "Environment",
        ///                     Values = 
        ///                     {
        ///                         "Dev",
        ///                     },
        ///                 },
        ///             },
        ///             IsolationRuleFirstEntityFilterType = "CATEGORIES_MATCH_ALL",
        ///             IsolationRuleSecondEntityFilterKindLists = 
        ///             {
        ///                 "vm",
        ///             },
        ///             IsolationRuleSecondEntityFilterParams = 
        ///             {
        ///                 new Nutanix.Inputs.NetworkSecurityRuleIsolationRuleSecondEntityFilterParamArgs
        ///                 {
        ///                     Name = "Environment",
        ///                     Values = 
        ///                     {
        ///                         "Production",
        ///                     },
        ///                 },
        ///             },
        ///             IsolationRuleSecondEntityFilterType = "CATEGORIES_MATCH_ALL",
        ///         });
        ///         var test = Nutanix.GetNetworkSecurityRule.Invoke(new Nutanix.GetNetworkSecurityRuleInvokeArgs
        ///         {
        ///             NetworkSecurityRuleId = isolation.Id,
        ///         });
        ///     }
        /// 
        /// }
        /// ```
        /// {{% /example %}}
        /// {{% /examples %}}
        /// </summary>
        public static Task<GetNetworkSecurityRuleResult> InvokeAsync(GetNetworkSecurityRuleArgs args, InvokeOptions? options = null)
            => Pulumi.Deployment.Instance.InvokeAsync<GetNetworkSecurityRuleResult>("nutanix:index/getNetworkSecurityRule:getNetworkSecurityRule", args ?? new GetNetworkSecurityRuleArgs(), options.WithDefaults());

        /// <summary>
        /// Describes a Network security rule
        /// 
        /// &gt; NOTE: The use of network_security_rule is only applicable in AHV clusters and requires Microsegmentation to be enabled. This feature is a function of the Flow product and requires a Flow license. For more information on Flow and Microsegmentation please visit https://www.nutanix.com/products/flow
        /// 
        /// {{% examples %}}
        /// ## Example Usage
        /// {{% example %}}
        /// ### Isolate Development VMs From Production VMs And Get Its Information)
        /// 
        /// ```csharp
        /// using Pulumi;
        /// using Nutanix = PiersKarsenbarg.Nutanix;
        /// using Nutanix = Pulumi.Nutanix;
        /// 
        /// class MyStack : Stack
        /// {
        ///     public MyStack()
        ///     {
        ///         var isolation = new Nutanix.NetworkSecurityRule("isolation", new Nutanix.NetworkSecurityRuleArgs
        ///         {
        ///             Description = "Isolation Rule Example",
        ///             IsolationRuleAction = "APPLY",
        ///             IsolationRuleFirstEntityFilterKindLists = 
        ///             {
        ///                 "vm",
        ///             },
        ///             IsolationRuleFirstEntityFilterParams = 
        ///             {
        ///                 new Nutanix.Inputs.NetworkSecurityRuleIsolationRuleFirstEntityFilterParamArgs
        ///                 {
        ///                     Name = "Environment",
        ///                     Values = 
        ///                     {
        ///                         "Dev",
        ///                     },
        ///                 },
        ///             },
        ///             IsolationRuleFirstEntityFilterType = "CATEGORIES_MATCH_ALL",
        ///             IsolationRuleSecondEntityFilterKindLists = 
        ///             {
        ///                 "vm",
        ///             },
        ///             IsolationRuleSecondEntityFilterParams = 
        ///             {
        ///                 new Nutanix.Inputs.NetworkSecurityRuleIsolationRuleSecondEntityFilterParamArgs
        ///                 {
        ///                     Name = "Environment",
        ///                     Values = 
        ///                     {
        ///                         "Production",
        ///                     },
        ///                 },
        ///             },
        ///             IsolationRuleSecondEntityFilterType = "CATEGORIES_MATCH_ALL",
        ///         });
        ///         var test = Nutanix.GetNetworkSecurityRule.Invoke(new Nutanix.GetNetworkSecurityRuleInvokeArgs
        ///         {
        ///             NetworkSecurityRuleId = isolation.Id,
        ///         });
        ///     }
        /// 
        /// }
        /// ```
        /// {{% /example %}}
        /// {{% /examples %}}
        /// </summary>
        public static Output<GetNetworkSecurityRuleResult> Invoke(GetNetworkSecurityRuleInvokeArgs args, InvokeOptions? options = null)
            => Pulumi.Deployment.Instance.Invoke<GetNetworkSecurityRuleResult>("nutanix:index/getNetworkSecurityRule:getNetworkSecurityRule", args ?? new GetNetworkSecurityRuleInvokeArgs(), options.WithDefaults());
    }


    public sealed class GetNetworkSecurityRuleArgs : Pulumi.InvokeArgs
    {
        [Input("categories")]
        private List<Inputs.GetNetworkSecurityRuleCategoryArgs>? _categories;
        public List<Inputs.GetNetworkSecurityRuleCategoryArgs> Categories
        {
            get => _categories ?? (_categories = new List<Inputs.GetNetworkSecurityRuleCategoryArgs>());
            set => _categories = value;
        }

        /// <summary>
        /// (Required) The ID for the rule you want to retrieve.
        /// * `name`: - The name for the network_security_rule.
        /// * `categories`: Categories for the network_security_rule.
        /// * `project_reference`: The reference to a project.
        /// * `owner_reference`: The reference to a user.
        /// * `api_version`
        /// * `description`: A description for network_security_rule.
        /// * `quarantine_rule_action`: These rules are used for quarantining suspected VMs. Target group is a required attribute. Empty inbound_allow_list will not allow anything into target group. Empty outbound_allow_list will allow everything from target group.
        /// * `quarantine_rule_outbound_allow_list`:
        /// * `quarantine_rule_target_group_default_internal_policy`: - Default policy for communication within target group.
        /// * `quarantine_rule_target_group_peer_specification_type`: - Way to identify the object for which rule is applied.
        /// * `quarantine_rule_target_group_filter_kind_list`: - List of kinds associated with this filter.
        /// * `quarantine_rule_target_group_filter_type`: - The type of the filter being used.
        /// * `quarantine_rule_target_group_filter_params`: - A list of category key and list of values.
        /// * `quarantine_rule_inbound_allow_list`:
        /// * `app_rule_action`: - These rules govern what flows are allowed. Target group is a required attribute. Empty inbound_allow_list will not anything into target group. Empty outbound_allow_list will allow everything from target group.
        /// * `app_rule_outbound_allow_list`:
        /// * `app_rule_target_group_default_internal_policy`: - Default policy for communication within target group.
        /// * `app_rule_target_group_peer_specification_type`: - Way to identify the object for which rule is applied.
        /// * `app_rule_target_group_filter_kind_list`: - List of kinds associated with this filter.
        /// * `app_rule_target_group_filter_type`: - The type of the filter being used.
        /// * `app_rule_target_group_filter_params`: - A list of category key and list of values.
        /// * `app_rule_inbound_allow_list`: The set of categories that matching VMs need to have.
        /// * `ad_rule_action`: - These rules govern what flows are allowed. Target group is a required attribute. Empty inbound_allow_list will not anything into target group. Empty outbound_allow_list will allow everything from target group.
        /// * `ad_rule_outbound_allow_list`:
        /// * `ad_rule_target_group_default_internal_policy`: - Default policy for communication within target group.
        /// * `ad_rule_target_group_peer_specification_type`: - Way to identify the object for which rule is applied.
        /// * `ad_rule_target_group_filter_kind_list`: - List of kinds associated with this filter.
        /// * `ad_rule_target_group_filter_type`: - The type of the filter being used.
        /// * `ad_rule_target_group_filter_params`: - A list of category key and list of values.
        /// * `ad_rule_inbound_allow_list`: The set of categories that matching VMs need to have.
        /// * `isolation_rule_action`: - These rules are used for environmental isolation.
        /// * `app_rule_inbound_allow_list`:
        /// * `isolation_rule_first_entity_filter_kind_list`: - List of kinds associated with this filter.
        /// * `isolation_rule_first_entity_filter_type`: - The type of the filter being used.
        /// * `isolation_rule_first_entity_filter_params`: - A list of category key and list of values.
        /// * `isolation_rule_second_entity_filter_kind_list`: - List of kinds associated with this filter.
        /// * `isolation_rule_second_entity_filter_type`: - The type of the filter being used.
        /// * `isolation_rule_second_entity_filter_params`: - A list of category key and list of values.
        /// </summary>
        [Input("networkSecurityRuleId", required: true)]
        public string NetworkSecurityRuleId { get; set; } = null!;

        public GetNetworkSecurityRuleArgs()
        {
        }
    }

    public sealed class GetNetworkSecurityRuleInvokeArgs : Pulumi.InvokeArgs
    {
        [Input("categories")]
        private InputList<Inputs.GetNetworkSecurityRuleCategoryInputArgs>? _categories;
        public InputList<Inputs.GetNetworkSecurityRuleCategoryInputArgs> Categories
        {
            get => _categories ?? (_categories = new InputList<Inputs.GetNetworkSecurityRuleCategoryInputArgs>());
            set => _categories = value;
        }

        /// <summary>
        /// (Required) The ID for the rule you want to retrieve.
        /// * `name`: - The name for the network_security_rule.
        /// * `categories`: Categories for the network_security_rule.
        /// * `project_reference`: The reference to a project.
        /// * `owner_reference`: The reference to a user.
        /// * `api_version`
        /// * `description`: A description for network_security_rule.
        /// * `quarantine_rule_action`: These rules are used for quarantining suspected VMs. Target group is a required attribute. Empty inbound_allow_list will not allow anything into target group. Empty outbound_allow_list will allow everything from target group.
        /// * `quarantine_rule_outbound_allow_list`:
        /// * `quarantine_rule_target_group_default_internal_policy`: - Default policy for communication within target group.
        /// * `quarantine_rule_target_group_peer_specification_type`: - Way to identify the object for which rule is applied.
        /// * `quarantine_rule_target_group_filter_kind_list`: - List of kinds associated with this filter.
        /// * `quarantine_rule_target_group_filter_type`: - The type of the filter being used.
        /// * `quarantine_rule_target_group_filter_params`: - A list of category key and list of values.
        /// * `quarantine_rule_inbound_allow_list`:
        /// * `app_rule_action`: - These rules govern what flows are allowed. Target group is a required attribute. Empty inbound_allow_list will not anything into target group. Empty outbound_allow_list will allow everything from target group.
        /// * `app_rule_outbound_allow_list`:
        /// * `app_rule_target_group_default_internal_policy`: - Default policy for communication within target group.
        /// * `app_rule_target_group_peer_specification_type`: - Way to identify the object for which rule is applied.
        /// * `app_rule_target_group_filter_kind_list`: - List of kinds associated with this filter.
        /// * `app_rule_target_group_filter_type`: - The type of the filter being used.
        /// * `app_rule_target_group_filter_params`: - A list of category key and list of values.
        /// * `app_rule_inbound_allow_list`: The set of categories that matching VMs need to have.
        /// * `ad_rule_action`: - These rules govern what flows are allowed. Target group is a required attribute. Empty inbound_allow_list will not anything into target group. Empty outbound_allow_list will allow everything from target group.
        /// * `ad_rule_outbound_allow_list`:
        /// * `ad_rule_target_group_default_internal_policy`: - Default policy for communication within target group.
        /// * `ad_rule_target_group_peer_specification_type`: - Way to identify the object for which rule is applied.
        /// * `ad_rule_target_group_filter_kind_list`: - List of kinds associated with this filter.
        /// * `ad_rule_target_group_filter_type`: - The type of the filter being used.
        /// * `ad_rule_target_group_filter_params`: - A list of category key and list of values.
        /// * `ad_rule_inbound_allow_list`: The set of categories that matching VMs need to have.
        /// * `isolation_rule_action`: - These rules are used for environmental isolation.
        /// * `app_rule_inbound_allow_list`:
        /// * `isolation_rule_first_entity_filter_kind_list`: - List of kinds associated with this filter.
        /// * `isolation_rule_first_entity_filter_type`: - The type of the filter being used.
        /// * `isolation_rule_first_entity_filter_params`: - A list of category key and list of values.
        /// * `isolation_rule_second_entity_filter_kind_list`: - List of kinds associated with this filter.
        /// * `isolation_rule_second_entity_filter_type`: - The type of the filter being used.
        /// * `isolation_rule_second_entity_filter_params`: - A list of category key and list of values.
        /// </summary>
        [Input("networkSecurityRuleId", required: true)]
        public Input<string> NetworkSecurityRuleId { get; set; } = null!;

        public GetNetworkSecurityRuleInvokeArgs()
        {
        }
    }


    [OutputType]
    public sealed class GetNetworkSecurityRuleResult
    {
        public readonly string AdRuleAction;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleAdRuleInboundAllowListResult> AdRuleInboundAllowLists;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleAdRuleOutboundAllowListResult> AdRuleOutboundAllowLists;
        public readonly string AdRuleTargetGroupDefaultInternalPolicy;
        public readonly ImmutableArray<string> AdRuleTargetGroupFilterKindLists;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleAdRuleTargetGroupFilterParamResult> AdRuleTargetGroupFilterParams;
        public readonly string AdRuleTargetGroupFilterType;
        public readonly string AdRuleTargetGroupPeerSpecificationType;
        public readonly bool AllowIpv6Traffic;
        public readonly string ApiVersion;
        public readonly string AppRuleAction;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleAppRuleInboundAllowListResult> AppRuleInboundAllowLists;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleAppRuleOutboundAllowListResult> AppRuleOutboundAllowLists;
        public readonly string AppRuleTargetGroupDefaultInternalPolicy;
        public readonly ImmutableArray<string> AppRuleTargetGroupFilterKindLists;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleAppRuleTargetGroupFilterParamResult> AppRuleTargetGroupFilterParams;
        public readonly string AppRuleTargetGroupFilterType;
        public readonly string AppRuleTargetGroupPeerSpecificationType;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleCategoryResult> Categories;
        public readonly string Description;
        /// <summary>
        /// The provider-assigned unique ID for this managed resource.
        /// </summary>
        public readonly string Id;
        public readonly bool IsPolicyHitlogEnabled;
        public readonly string IsolationRuleAction;
        public readonly ImmutableArray<string> IsolationRuleFirstEntityFilterKindLists;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleIsolationRuleFirstEntityFilterParamResult> IsolationRuleFirstEntityFilterParams;
        public readonly string IsolationRuleFirstEntityFilterType;
        public readonly ImmutableArray<string> IsolationRuleSecondEntityFilterKindLists;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleIsolationRuleSecondEntityFilterParamResult> IsolationRuleSecondEntityFilterParams;
        public readonly string IsolationRuleSecondEntityFilterType;
        public readonly ImmutableDictionary<string, string> Metadata;
        public readonly string Name;
        /// <summary>
        /// (Required) The ID for the rule you want to retrieve.
        /// * `name`: - The name for the network_security_rule.
        /// * `categories`: Categories for the network_security_rule.
        /// * `project_reference`: The reference to a project.
        /// * `owner_reference`: The reference to a user.
        /// * `api_version`
        /// * `description`: A description for network_security_rule.
        /// * `quarantine_rule_action`: These rules are used for quarantining suspected VMs. Target group is a required attribute. Empty inbound_allow_list will not allow anything into target group. Empty outbound_allow_list will allow everything from target group.
        /// * `quarantine_rule_outbound_allow_list`:
        /// * `quarantine_rule_target_group_default_internal_policy`: - Default policy for communication within target group.
        /// * `quarantine_rule_target_group_peer_specification_type`: - Way to identify the object for which rule is applied.
        /// * `quarantine_rule_target_group_filter_kind_list`: - List of kinds associated with this filter.
        /// * `quarantine_rule_target_group_filter_type`: - The type of the filter being used.
        /// * `quarantine_rule_target_group_filter_params`: - A list of category key and list of values.
        /// * `quarantine_rule_inbound_allow_list`:
        /// * `app_rule_action`: - These rules govern what flows are allowed. Target group is a required attribute. Empty inbound_allow_list will not anything into target group. Empty outbound_allow_list will allow everything from target group.
        /// * `app_rule_outbound_allow_list`:
        /// * `app_rule_target_group_default_internal_policy`: - Default policy for communication within target group.
        /// * `app_rule_target_group_peer_specification_type`: - Way to identify the object for which rule is applied.
        /// * `app_rule_target_group_filter_kind_list`: - List of kinds associated with this filter.
        /// * `app_rule_target_group_filter_type`: - The type of the filter being used.
        /// * `app_rule_target_group_filter_params`: - A list of category key and list of values.
        /// * `app_rule_inbound_allow_list`: The set of categories that matching VMs need to have.
        /// * `ad_rule_action`: - These rules govern what flows are allowed. Target group is a required attribute. Empty inbound_allow_list will not anything into target group. Empty outbound_allow_list will allow everything from target group.
        /// * `ad_rule_outbound_allow_list`:
        /// * `ad_rule_target_group_default_internal_policy`: - Default policy for communication within target group.
        /// * `ad_rule_target_group_peer_specification_type`: - Way to identify the object for which rule is applied.
        /// * `ad_rule_target_group_filter_kind_list`: - List of kinds associated with this filter.
        /// * `ad_rule_target_group_filter_type`: - The type of the filter being used.
        /// * `ad_rule_target_group_filter_params`: - A list of category key and list of values.
        /// * `ad_rule_inbound_allow_list`: The set of categories that matching VMs need to have.
        /// * `isolation_rule_action`: - These rules are used for environmental isolation.
        /// * `app_rule_inbound_allow_list`:
        /// * `isolation_rule_first_entity_filter_kind_list`: - List of kinds associated with this filter.
        /// * `isolation_rule_first_entity_filter_type`: - The type of the filter being used.
        /// * `isolation_rule_first_entity_filter_params`: - A list of category key and list of values.
        /// * `isolation_rule_second_entity_filter_kind_list`: - List of kinds associated with this filter.
        /// * `isolation_rule_second_entity_filter_type`: - The type of the filter being used.
        /// * `isolation_rule_second_entity_filter_params`: - A list of category key and list of values.
        /// </summary>
        public readonly string NetworkSecurityRuleId;
        public readonly ImmutableDictionary<string, string> OwnerReference;
        public readonly ImmutableDictionary<string, string> ProjectReference;
        public readonly string QuarantineRuleAction;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleQuarantineRuleInboundAllowListResult> QuarantineRuleInboundAllowLists;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleQuarantineRuleOutboundAllowListResult> QuarantineRuleOutboundAllowLists;
        public readonly string QuarantineRuleTargetGroupDefaultInternalPolicy;
        public readonly ImmutableArray<string> QuarantineRuleTargetGroupFilterKindLists;
        public readonly ImmutableArray<Outputs.GetNetworkSecurityRuleQuarantineRuleTargetGroupFilterParamResult> QuarantineRuleTargetGroupFilterParams;
        public readonly string QuarantineRuleTargetGroupFilterType;
        public readonly string QuarantineRuleTargetGroupPeerSpecificationType;

        [OutputConstructor]
        private GetNetworkSecurityRuleResult(
            string adRuleAction,

            ImmutableArray<Outputs.GetNetworkSecurityRuleAdRuleInboundAllowListResult> adRuleInboundAllowLists,

            ImmutableArray<Outputs.GetNetworkSecurityRuleAdRuleOutboundAllowListResult> adRuleOutboundAllowLists,

            string adRuleTargetGroupDefaultInternalPolicy,

            ImmutableArray<string> adRuleTargetGroupFilterKindLists,

            ImmutableArray<Outputs.GetNetworkSecurityRuleAdRuleTargetGroupFilterParamResult> adRuleTargetGroupFilterParams,

            string adRuleTargetGroupFilterType,

            string adRuleTargetGroupPeerSpecificationType,

            bool allowIpv6Traffic,

            string apiVersion,

            string appRuleAction,

            ImmutableArray<Outputs.GetNetworkSecurityRuleAppRuleInboundAllowListResult> appRuleInboundAllowLists,

            ImmutableArray<Outputs.GetNetworkSecurityRuleAppRuleOutboundAllowListResult> appRuleOutboundAllowLists,

            string appRuleTargetGroupDefaultInternalPolicy,

            ImmutableArray<string> appRuleTargetGroupFilterKindLists,

            ImmutableArray<Outputs.GetNetworkSecurityRuleAppRuleTargetGroupFilterParamResult> appRuleTargetGroupFilterParams,

            string appRuleTargetGroupFilterType,

            string appRuleTargetGroupPeerSpecificationType,

            ImmutableArray<Outputs.GetNetworkSecurityRuleCategoryResult> categories,

            string description,

            string id,

            bool isPolicyHitlogEnabled,

            string isolationRuleAction,

            ImmutableArray<string> isolationRuleFirstEntityFilterKindLists,

            ImmutableArray<Outputs.GetNetworkSecurityRuleIsolationRuleFirstEntityFilterParamResult> isolationRuleFirstEntityFilterParams,

            string isolationRuleFirstEntityFilterType,

            ImmutableArray<string> isolationRuleSecondEntityFilterKindLists,

            ImmutableArray<Outputs.GetNetworkSecurityRuleIsolationRuleSecondEntityFilterParamResult> isolationRuleSecondEntityFilterParams,

            string isolationRuleSecondEntityFilterType,

            ImmutableDictionary<string, string> metadata,

            string name,

            string networkSecurityRuleId,

            ImmutableDictionary<string, string> ownerReference,

            ImmutableDictionary<string, string> projectReference,

            string quarantineRuleAction,

            ImmutableArray<Outputs.GetNetworkSecurityRuleQuarantineRuleInboundAllowListResult> quarantineRuleInboundAllowLists,

            ImmutableArray<Outputs.GetNetworkSecurityRuleQuarantineRuleOutboundAllowListResult> quarantineRuleOutboundAllowLists,

            string quarantineRuleTargetGroupDefaultInternalPolicy,

            ImmutableArray<string> quarantineRuleTargetGroupFilterKindLists,

            ImmutableArray<Outputs.GetNetworkSecurityRuleQuarantineRuleTargetGroupFilterParamResult> quarantineRuleTargetGroupFilterParams,

            string quarantineRuleTargetGroupFilterType,

            string quarantineRuleTargetGroupPeerSpecificationType)
        {
            AdRuleAction = adRuleAction;
            AdRuleInboundAllowLists = adRuleInboundAllowLists;
            AdRuleOutboundAllowLists = adRuleOutboundAllowLists;
            AdRuleTargetGroupDefaultInternalPolicy = adRuleTargetGroupDefaultInternalPolicy;
            AdRuleTargetGroupFilterKindLists = adRuleTargetGroupFilterKindLists;
            AdRuleTargetGroupFilterParams = adRuleTargetGroupFilterParams;
            AdRuleTargetGroupFilterType = adRuleTargetGroupFilterType;
            AdRuleTargetGroupPeerSpecificationType = adRuleTargetGroupPeerSpecificationType;
            AllowIpv6Traffic = allowIpv6Traffic;
            ApiVersion = apiVersion;
            AppRuleAction = appRuleAction;
            AppRuleInboundAllowLists = appRuleInboundAllowLists;
            AppRuleOutboundAllowLists = appRuleOutboundAllowLists;
            AppRuleTargetGroupDefaultInternalPolicy = appRuleTargetGroupDefaultInternalPolicy;
            AppRuleTargetGroupFilterKindLists = appRuleTargetGroupFilterKindLists;
            AppRuleTargetGroupFilterParams = appRuleTargetGroupFilterParams;
            AppRuleTargetGroupFilterType = appRuleTargetGroupFilterType;
            AppRuleTargetGroupPeerSpecificationType = appRuleTargetGroupPeerSpecificationType;
            Categories = categories;
            Description = description;
            Id = id;
            IsPolicyHitlogEnabled = isPolicyHitlogEnabled;
            IsolationRuleAction = isolationRuleAction;
            IsolationRuleFirstEntityFilterKindLists = isolationRuleFirstEntityFilterKindLists;
            IsolationRuleFirstEntityFilterParams = isolationRuleFirstEntityFilterParams;
            IsolationRuleFirstEntityFilterType = isolationRuleFirstEntityFilterType;
            IsolationRuleSecondEntityFilterKindLists = isolationRuleSecondEntityFilterKindLists;
            IsolationRuleSecondEntityFilterParams = isolationRuleSecondEntityFilterParams;
            IsolationRuleSecondEntityFilterType = isolationRuleSecondEntityFilterType;
            Metadata = metadata;
            Name = name;
            NetworkSecurityRuleId = networkSecurityRuleId;
            OwnerReference = ownerReference;
            ProjectReference = projectReference;
            QuarantineRuleAction = quarantineRuleAction;
            QuarantineRuleInboundAllowLists = quarantineRuleInboundAllowLists;
            QuarantineRuleOutboundAllowLists = quarantineRuleOutboundAllowLists;
            QuarantineRuleTargetGroupDefaultInternalPolicy = quarantineRuleTargetGroupDefaultInternalPolicy;
            QuarantineRuleTargetGroupFilterKindLists = quarantineRuleTargetGroupFilterKindLists;
            QuarantineRuleTargetGroupFilterParams = quarantineRuleTargetGroupFilterParams;
            QuarantineRuleTargetGroupFilterType = quarantineRuleTargetGroupFilterType;
            QuarantineRuleTargetGroupPeerSpecificationType = quarantineRuleTargetGroupPeerSpecificationType;
        }
    }
}
