// *** 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 Pulumiverse.Fortios
{
    /// <summary>
    /// Configure BGP.
    /// 
    /// &gt; The provider supports the definition of Neighbor in Router Bgp `fortios.RouterBgp`, and also allows the definition of separate Neighbor resources `fortios.RouterbgpNeighbor`, but do not use a `fortios.RouterBgp` with in-line Neighbor in conjunction with any `fortios.RouterbgpNeighbor` resources, otherwise conflicts and overwrite will occur.
    /// 
    /// &gt; The provider supports the definition of Network in Router Bgp `fortios.RouterBgp`, and also allows the definition of separate Network resources `fortios.RouterbgpNetwork`, but do not use a `fortios.RouterBgp` with in-line Network in conjunction with any `fortios.RouterbgpNetwork` resources, otherwise conflicts and overwrite will occur.
    /// 
    /// &gt; The provider supports the definition of Network6 in Router Bgp `fortios.RouterBgp`, and also allows the definition of separate Network6 resources `fortios.RouterbgpNetwork6`, but do not use a `fortios.RouterBgp` with in-line Network6 in conjunction with any `fortios.RouterbgpNetwork6` resources, otherwise conflicts and overwrite will occur.
    /// 
    /// ## Example Usage
    /// 
    /// ```csharp
    /// using System.Collections.Generic;
    /// using System.Linq;
    /// using Pulumi;
    /// using Fortios = Pulumiverse.Fortios;
    /// 
    /// return await Deployment.RunAsync(() =&gt; 
    /// {
    ///     var trname = new Fortios.RouterBgp("trname", new()
    ///     {
    ///         AdditionalPathSelect = 2,
    ///         AdditionalPathSelect6 = 2,
    ///         AlwaysCompareMed = "disable",
    ///         As = 0,
    ///         ClientToClientReflection = "enable",
    ///         ClusterId = "0.0.0.0",
    ///         Dampening = "disable",
    ///         DampeningMaxSuppressTime = 60,
    ///         DampeningReachabilityHalfLife = 15,
    ///         DampeningReuse = 750,
    ///         DampeningSuppress = 2000,
    ///         DampeningUnreachabilityHalfLife = 15,
    ///         DefaultLocalPreference = 100,
    ///         DeterministicMed = "disable",
    ///         DistanceExternal = 20,
    ///         DistanceInternal = 200,
    ///         DistanceLocal = 200,
    ///         GracefulRestartTime = 120,
    ///         GracefulStalepathTime = 360,
    ///         GracefulUpdateDelay = 120,
    ///         HoldtimeTimer = 180,
    ///         IbgpMultipath = "disable",
    ///         IgnoreOptionalCapability = "enable",
    ///         KeepaliveTimer = 60,
    ///         LogNeighbourChanges = "enable",
    ///         NetworkImportCheck = "enable",
    ///         Redistributes = new[]
    ///         {
    ///             new Fortios.Inputs.RouterBgpRedistributeArgs
    ///             {
    ///                 Name = "connected",
    ///                 Status = "disable",
    ///             },
    ///             new Fortios.Inputs.RouterBgpRedistributeArgs
    ///             {
    ///                 Name = "rip",
    ///                 Status = "disable",
    ///             },
    ///             new Fortios.Inputs.RouterBgpRedistributeArgs
    ///             {
    ///                 Name = "ospf",
    ///                 Status = "disable",
    ///             },
    ///             new Fortios.Inputs.RouterBgpRedistributeArgs
    ///             {
    ///                 Name = "static",
    ///                 Status = "disable",
    ///             },
    ///             new Fortios.Inputs.RouterBgpRedistributeArgs
    ///             {
    ///                 Name = "isis",
    ///                 Status = "disable",
    ///             },
    ///         },
    ///         Redistribute6s = new[]
    ///         {
    ///             new Fortios.Inputs.RouterBgpRedistribute6Args
    ///             {
    ///                 Name = "connected",
    ///                 Status = "disable",
    ///             },
    ///             new Fortios.Inputs.RouterBgpRedistribute6Args
    ///             {
    ///                 Name = "rip",
    ///                 Status = "disable",
    ///             },
    ///             new Fortios.Inputs.RouterBgpRedistribute6Args
    ///             {
    ///                 Name = "ospf",
    ///                 Status = "disable",
    ///             },
    ///             new Fortios.Inputs.RouterBgpRedistribute6Args
    ///             {
    ///                 Name = "static",
    ///                 Status = "disable",
    ///             },
    ///             new Fortios.Inputs.RouterBgpRedistribute6Args
    ///             {
    ///                 Name = "isis",
    ///                 Status = "disable",
    ///             },
    ///         },
    ///         ScanTime = 60,
    ///         Synchronization = "disable",
    ///     });
    /// 
    /// });
    /// ```
    /// 
    /// ## Import
    /// 
    /// Router Bgp can be imported using any of these accepted formats
    /// 
    /// ```sh
    ///  $ pulumi import fortios:index/routerBgp:RouterBgp labelname RouterBgp
    /// ```
    /// 
    ///  If you do not want to import arguments of block$ export "FORTIOS_IMPORT_TABLE"="false"
    /// 
    /// ```sh
    ///  $ pulumi import fortios:index/routerBgp:RouterBgp labelname RouterBgp
    /// ```
    /// 
    ///  $ unset "FORTIOS_IMPORT_TABLE"
    /// </summary>
    [FortiosResourceType("fortios:index/routerBgp:RouterBgp")]
    public partial class RouterBgp : global::Pulumi.CustomResource
    {
        /// <summary>
        /// Enable/disable selection of BGP IPv4 additional paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("additionalPath")]
        public Output<string> AdditionalPath { get; private set; } = null!;

        /// <summary>
        /// Enable/disable selection of BGP IPv6 additional paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("additionalPath6")]
        public Output<string> AdditionalPath6 { get; private set; } = null!;

        /// <summary>
        /// Number of additional paths to be selected for each IPv4 NLRI.
        /// </summary>
        [Output("additionalPathSelect")]
        public Output<int> AdditionalPathSelect { get; private set; } = null!;

        /// <summary>
        /// Number of additional paths to be selected for each IPv6 NLRI.
        /// </summary>
        [Output("additionalPathSelect6")]
        public Output<int> AdditionalPathSelect6 { get; private set; } = null!;

        /// <summary>
        /// Number of additional paths to be selected for each VPNv4 NLRI.
        /// </summary>
        [Output("additionalPathSelectVpnv4")]
        public Output<int> AdditionalPathSelectVpnv4 { get; private set; } = null!;

        /// <summary>
        /// Enable/disable selection of BGP VPNv4 additional paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("additionalPathVpnv4")]
        public Output<string> AdditionalPathVpnv4 { get; private set; } = null!;

        /// <summary>
        /// Administrative distance modifications. The structure of `admin_distance` block is documented below.
        /// </summary>
        [Output("adminDistances")]
        public Output<ImmutableArray<Outputs.RouterBgpAdminDistance>> AdminDistances { get; private set; } = null!;

        /// <summary>
        /// BGP IPv6 aggregate address table. The structure of `aggregate_address6` block is documented below.
        /// </summary>
        [Output("aggregateAddress6s")]
        public Output<ImmutableArray<Outputs.RouterBgpAggregateAddress6>> AggregateAddress6s { get; private set; } = null!;

        /// <summary>
        /// BGP aggregate address table. The structure of `aggregate_address` block is documented below.
        /// </summary>
        [Output("aggregateAddresses")]
        public Output<ImmutableArray<Outputs.RouterBgpAggregateAddress>> AggregateAddresses { get; private set; } = null!;

        /// <summary>
        /// Enable/disable always compare MED. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("alwaysCompareMed")]
        public Output<string> AlwaysCompareMed { get; private set; } = null!;

        /// <summary>
        /// Router AS number, valid from 1 to 4294967295, 0 to disable BGP.
        /// </summary>
        [Output("as")]
        public Output<int> As { get; private set; } = null!;

        /// <summary>
        /// Enable/disable ignore AS path. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("bestpathAsPathIgnore")]
        public Output<string> BestpathAsPathIgnore { get; private set; } = null!;

        /// <summary>
        /// Enable/disable compare federation AS path length. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("bestpathCmpConfedAspath")]
        public Output<string> BestpathCmpConfedAspath { get; private set; } = null!;

        /// <summary>
        /// Enable/disable compare router ID for identical EBGP paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("bestpathCmpRouterid")]
        public Output<string> BestpathCmpRouterid { get; private set; } = null!;

        /// <summary>
        /// Enable/disable compare MED among confederation paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("bestpathMedConfed")]
        public Output<string> BestpathMedConfed { get; private set; } = null!;

        /// <summary>
        /// Enable/disable treat missing MED as least preferred. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("bestpathMedMissingAsWorst")]
        public Output<string> BestpathMedMissingAsWorst { get; private set; } = null!;

        /// <summary>
        /// Enable/disable client-to-client route reflection. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("clientToClientReflection")]
        public Output<string> ClientToClientReflection { get; private set; } = null!;

        /// <summary>
        /// Route reflector cluster ID.
        /// </summary>
        [Output("clusterId")]
        public Output<string> ClusterId { get; private set; } = null!;

        /// <summary>
        /// Confederation identifier.
        /// </summary>
        [Output("confederationIdentifier")]
        public Output<int> ConfederationIdentifier { get; private set; } = null!;

        /// <summary>
        /// Confederation peers. The structure of `confederation_peers` block is documented below.
        /// </summary>
        [Output("confederationPeers")]
        public Output<ImmutableArray<Outputs.RouterBgpConfederationPeer>> ConfederationPeers { get; private set; } = null!;

        /// <summary>
        /// Enable/disable route-flap dampening. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("dampening")]
        public Output<string> Dampening { get; private set; } = null!;

        /// <summary>
        /// Maximum minutes a route can be suppressed.
        /// </summary>
        [Output("dampeningMaxSuppressTime")]
        public Output<int> DampeningMaxSuppressTime { get; private set; } = null!;

        /// <summary>
        /// Reachability half-life time for penalty (min).
        /// </summary>
        [Output("dampeningReachabilityHalfLife")]
        public Output<int> DampeningReachabilityHalfLife { get; private set; } = null!;

        /// <summary>
        /// Threshold to reuse routes.
        /// </summary>
        [Output("dampeningReuse")]
        public Output<int> DampeningReuse { get; private set; } = null!;

        /// <summary>
        /// Criteria for dampening.
        /// </summary>
        [Output("dampeningRouteMap")]
        public Output<string> DampeningRouteMap { get; private set; } = null!;

        /// <summary>
        /// Threshold to suppress routes.
        /// </summary>
        [Output("dampeningSuppress")]
        public Output<int> DampeningSuppress { get; private set; } = null!;

        /// <summary>
        /// Unreachability half-life time for penalty (min).
        /// </summary>
        [Output("dampeningUnreachabilityHalfLife")]
        public Output<int> DampeningUnreachabilityHalfLife { get; private set; } = null!;

        /// <summary>
        /// Default local preference.
        /// </summary>
        [Output("defaultLocalPreference")]
        public Output<int> DefaultLocalPreference { get; private set; } = null!;

        /// <summary>
        /// Enable/disable enforce deterministic comparison of MED. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("deterministicMed")]
        public Output<string> DeterministicMed { get; private set; } = null!;

        /// <summary>
        /// Distance for routes external to the AS.
        /// </summary>
        [Output("distanceExternal")]
        public Output<int> DistanceExternal { get; private set; } = null!;

        /// <summary>
        /// Distance for routes internal to the AS.
        /// </summary>
        [Output("distanceInternal")]
        public Output<int> DistanceInternal { get; private set; } = null!;

        /// <summary>
        /// Distance for routes local to the AS.
        /// </summary>
        [Output("distanceLocal")]
        public Output<int> DistanceLocal { get; private set; } = null!;

        /// <summary>
        /// Sort sub-tables, please do not set this parameter when configuring static sub-tables. Options: [ false, true, natural, alphabetical ]. false: Default value, do not sort tables; true/natural: sort tables in natural order. For example: [ a10, a2 ] -&gt; [ a2, a10 ]; alphabetical: sort tables in alphabetical order. For example: [ a10, a2 ] -&gt; [ a10, a2 ].
        /// </summary>
        [Output("dynamicSortSubtable")]
        public Output<string?> DynamicSortSubtable { get; private set; } = null!;

        /// <summary>
        /// Enable/disable EBGP multi-path. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("ebgpMultipath")]
        public Output<string> EbgpMultipath { get; private set; } = null!;

        /// <summary>
        /// Enable/disable enforce first AS for EBGP routes. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("enforceFirstAs")]
        public Output<string> EnforceFirstAs { get; private set; } = null!;

        /// <summary>
        /// Enable/disable reset peer BGP session if link goes down. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("fastExternalFailover")]
        public Output<string> FastExternalFailover { get; private set; } = null!;

        /// <summary>
        /// Enable/disable to exit graceful restart on timer only. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("gracefulEndOnTimer")]
        public Output<string> GracefulEndOnTimer { get; private set; } = null!;

        /// <summary>
        /// Enable/disable BGP graceful restart capabilities. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("gracefulRestart")]
        public Output<string> GracefulRestart { get; private set; } = null!;

        /// <summary>
        /// Time needed for neighbors to restart (sec).
        /// </summary>
        [Output("gracefulRestartTime")]
        public Output<int> GracefulRestartTime { get; private set; } = null!;

        /// <summary>
        /// Time to hold stale paths of restarting neighbor (sec).
        /// </summary>
        [Output("gracefulStalepathTime")]
        public Output<int> GracefulStalepathTime { get; private set; } = null!;

        /// <summary>
        /// Route advertisement/selection delay after restart (sec).
        /// </summary>
        [Output("gracefulUpdateDelay")]
        public Output<int> GracefulUpdateDelay { get; private set; } = null!;

        /// <summary>
        /// Number of seconds to mark peer as dead.
        /// </summary>
        [Output("holdtimeTimer")]
        public Output<int> HoldtimeTimer { get; private set; } = null!;

        /// <summary>
        /// Enable/disable IBGP multi-path. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("ibgpMultipath")]
        public Output<string> IbgpMultipath { get; private set; } = null!;

        /// <summary>
        /// Don't send unknown optional capability notification message Valid values: `enable`, `disable`.
        /// </summary>
        [Output("ignoreOptionalCapability")]
        public Output<string> IgnoreOptionalCapability { get; private set; } = null!;

        /// <summary>
        /// Frequency to send keep alive requests.
        /// </summary>
        [Output("keepaliveTimer")]
        public Output<int> KeepaliveTimer { get; private set; } = null!;

        /// <summary>
        /// Enable logging of BGP neighbour's changes Valid values: `enable`, `disable`.
        /// </summary>
        [Output("logNeighbourChanges")]
        public Output<string> LogNeighbourChanges { get; private set; } = null!;

        /// <summary>
        /// Enable/disable use of recursive distance to select multipath. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("multipathRecursiveDistance")]
        public Output<string> MultipathRecursiveDistance { get; private set; } = null!;

        /// <summary>
        /// BGP neighbor group table. The structure of `neighbor_group` block is documented below.
        /// </summary>
        [Output("neighborGroups")]
        public Output<ImmutableArray<Outputs.RouterBgpNeighborGroup>> NeighborGroups { get; private set; } = null!;

        /// <summary>
        /// BGP IPv6 neighbor range table. The structure of `neighbor_range6` block is documented below.
        /// </summary>
        [Output("neighborRange6s")]
        public Output<ImmutableArray<Outputs.RouterBgpNeighborRange6>> NeighborRange6s { get; private set; } = null!;

        /// <summary>
        /// BGP neighbor range table. The structure of `neighbor_range` block is documented below.
        /// </summary>
        [Output("neighborRanges")]
        public Output<ImmutableArray<Outputs.RouterBgpNeighborRange>> NeighborRanges { get; private set; } = null!;

        /// <summary>
        /// BGP neighbor table. The structure of `neighbor` block is documented below.
        /// </summary>
        [Output("neighbors")]
        public Output<ImmutableArray<Outputs.RouterBgpNeighbor>> Neighbors { get; private set; } = null!;

        /// <summary>
        /// BGP IPv6 network table. The structure of `network6` block is documented below.
        /// </summary>
        [Output("network6s")]
        public Output<ImmutableArray<Outputs.RouterBgpNetwork6>> Network6s { get; private set; } = null!;

        /// <summary>
        /// Enable/disable ensure BGP network route exists in IGP. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("networkImportCheck")]
        public Output<string> NetworkImportCheck { get; private set; } = null!;

        /// <summary>
        /// BGP network table. The structure of `network` block is documented below.
        /// </summary>
        [Output("networks")]
        public Output<ImmutableArray<Outputs.RouterBgpNetwork>> Networks { get; private set; } = null!;

        /// <summary>
        /// Enable/disable priority inheritance for recursive resolution. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("recursiveInheritPriority")]
        public Output<string> RecursiveInheritPriority { get; private set; } = null!;

        /// <summary>
        /// Enable/disable recursive resolution of next-hop using BGP route. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("recursiveNextHop")]
        public Output<string> RecursiveNextHop { get; private set; } = null!;

        /// <summary>
        /// BGP IPv6 redistribute table. The structure of `redistribute6` block is documented below.
        /// </summary>
        [Output("redistribute6s")]
        public Output<ImmutableArray<Outputs.RouterBgpRedistribute6>> Redistribute6s { get; private set; } = null!;

        /// <summary>
        /// BGP IPv4 redistribute table. The structure of `redistribute` block is documented below.
        /// </summary>
        [Output("redistributes")]
        public Output<ImmutableArray<Outputs.RouterBgpRedistribute>> Redistributes { get; private set; } = null!;

        /// <summary>
        /// Router ID.
        /// </summary>
        [Output("routerId")]
        public Output<string> RouterId { get; private set; } = null!;

        /// <summary>
        /// Background scanner interval (sec), 0 to disable it.
        /// </summary>
        [Output("scanTime")]
        public Output<int> ScanTime { get; private set; } = null!;

        /// <summary>
        /// Enable/disable only advertise routes from iBGP if routes present in an IGP. Valid values: `enable`, `disable`.
        /// </summary>
        [Output("synchronization")]
        public Output<string> Synchronization { get; private set; } = null!;

        /// <summary>
        /// Configure tag-match mode. Resolves BGP routes with other routes containing the same tag. Valid values: `disable`, `preferred`, `merge`.
        /// </summary>
        [Output("tagResolveMode")]
        public Output<string> TagResolveMode { get; private set; } = null!;

        /// <summary>
        /// Specifies the vdom to which the resource will be applied when the FortiGate unit is running in VDOM mode. Only one vdom can be specified. If you want to inherit the vdom configuration of the provider, please do not set this parameter.
        /// </summary>
        [Output("vdomparam")]
        public Output<string?> Vdomparam { get; private set; } = null!;

        /// <summary>
        /// BGP IPv6 VRF leaking table. The structure of `vrf6` block is documented below.
        /// </summary>
        [Output("vrf6s")]
        public Output<ImmutableArray<Outputs.RouterBgpVrf6>> Vrf6s { get; private set; } = null!;

        /// <summary>
        /// BGP IPv6 VRF leaking table. The structure of `vrf_leak6` block is documented below.
        /// </summary>
        [Output("vrfLeak6s")]
        public Output<ImmutableArray<Outputs.RouterBgpVrfLeak6>> VrfLeak6s { get; private set; } = null!;

        /// <summary>
        /// BGP VRF leaking table. The structure of `vrf_leak` block is documented below.
        /// </summary>
        [Output("vrfLeaks")]
        public Output<ImmutableArray<Outputs.RouterBgpVrfLeak>> VrfLeaks { get; private set; } = null!;

        /// <summary>
        /// BGP VRF leaking table. The structure of `vrf` block is documented below.
        /// </summary>
        [Output("vrves")]
        public Output<ImmutableArray<Outputs.RouterBgpVrf>> Vrves { get; private set; } = null!;


        /// <summary>
        /// Create a RouterBgp resource with the given unique name, arguments, and options.
        /// </summary>
        ///
        /// <param name="name">The unique name of the resource</param>
        /// <param name="args">The arguments used to populate this resource's properties</param>
        /// <param name="options">A bag of options that control this resource's behavior</param>
        public RouterBgp(string name, RouterBgpArgs args, CustomResourceOptions? options = null)
            : base("fortios:index/routerBgp:RouterBgp", name, args ?? new RouterBgpArgs(), MakeResourceOptions(options, ""))
        {
        }

        private RouterBgp(string name, Input<string> id, RouterBgpState? state = null, CustomResourceOptions? options = null)
            : base("fortios:index/routerBgp:RouterBgp", name, state, MakeResourceOptions(options, id))
        {
        }

        private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input<string>? id)
        {
            var defaultOptions = new CustomResourceOptions
            {
                Version = Utilities.Version,
                PluginDownloadURL = "github://api.github.com/pulumiverse/pulumi-fortios",
            };
            var merged = CustomResourceOptions.Merge(defaultOptions, options);
            // Override the ID if one was specified for consistency with other language SDKs.
            merged.Id = id ?? merged.Id;
            return merged;
        }
        /// <summary>
        /// Get an existing RouterBgp resource's state with the given name, ID, and optional extra
        /// properties used to qualify the lookup.
        /// </summary>
        ///
        /// <param name="name">The unique name of the resulting resource.</param>
        /// <param name="id">The unique provider ID of the resource to lookup.</param>
        /// <param name="state">Any extra arguments used during the lookup.</param>
        /// <param name="options">A bag of options that control this resource's behavior</param>
        public static RouterBgp Get(string name, Input<string> id, RouterBgpState? state = null, CustomResourceOptions? options = null)
        {
            return new RouterBgp(name, id, state, options);
        }
    }

    public sealed class RouterBgpArgs : global::Pulumi.ResourceArgs
    {
        /// <summary>
        /// Enable/disable selection of BGP IPv4 additional paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("additionalPath")]
        public Input<string>? AdditionalPath { get; set; }

        /// <summary>
        /// Enable/disable selection of BGP IPv6 additional paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("additionalPath6")]
        public Input<string>? AdditionalPath6 { get; set; }

        /// <summary>
        /// Number of additional paths to be selected for each IPv4 NLRI.
        /// </summary>
        [Input("additionalPathSelect")]
        public Input<int>? AdditionalPathSelect { get; set; }

        /// <summary>
        /// Number of additional paths to be selected for each IPv6 NLRI.
        /// </summary>
        [Input("additionalPathSelect6")]
        public Input<int>? AdditionalPathSelect6 { get; set; }

        /// <summary>
        /// Number of additional paths to be selected for each VPNv4 NLRI.
        /// </summary>
        [Input("additionalPathSelectVpnv4")]
        public Input<int>? AdditionalPathSelectVpnv4 { get; set; }

        /// <summary>
        /// Enable/disable selection of BGP VPNv4 additional paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("additionalPathVpnv4")]
        public Input<string>? AdditionalPathVpnv4 { get; set; }

        [Input("adminDistances")]
        private InputList<Inputs.RouterBgpAdminDistanceArgs>? _adminDistances;

        /// <summary>
        /// Administrative distance modifications. The structure of `admin_distance` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpAdminDistanceArgs> AdminDistances
        {
            get => _adminDistances ?? (_adminDistances = new InputList<Inputs.RouterBgpAdminDistanceArgs>());
            set => _adminDistances = value;
        }

        [Input("aggregateAddress6s")]
        private InputList<Inputs.RouterBgpAggregateAddress6Args>? _aggregateAddress6s;

        /// <summary>
        /// BGP IPv6 aggregate address table. The structure of `aggregate_address6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpAggregateAddress6Args> AggregateAddress6s
        {
            get => _aggregateAddress6s ?? (_aggregateAddress6s = new InputList<Inputs.RouterBgpAggregateAddress6Args>());
            set => _aggregateAddress6s = value;
        }

        [Input("aggregateAddresses")]
        private InputList<Inputs.RouterBgpAggregateAddressArgs>? _aggregateAddresses;

        /// <summary>
        /// BGP aggregate address table. The structure of `aggregate_address` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpAggregateAddressArgs> AggregateAddresses
        {
            get => _aggregateAddresses ?? (_aggregateAddresses = new InputList<Inputs.RouterBgpAggregateAddressArgs>());
            set => _aggregateAddresses = value;
        }

        /// <summary>
        /// Enable/disable always compare MED. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("alwaysCompareMed")]
        public Input<string>? AlwaysCompareMed { get; set; }

        /// <summary>
        /// Router AS number, valid from 1 to 4294967295, 0 to disable BGP.
        /// </summary>
        [Input("as", required: true)]
        public Input<int> As { get; set; } = null!;

        /// <summary>
        /// Enable/disable ignore AS path. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bestpathAsPathIgnore")]
        public Input<string>? BestpathAsPathIgnore { get; set; }

        /// <summary>
        /// Enable/disable compare federation AS path length. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bestpathCmpConfedAspath")]
        public Input<string>? BestpathCmpConfedAspath { get; set; }

        /// <summary>
        /// Enable/disable compare router ID for identical EBGP paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bestpathCmpRouterid")]
        public Input<string>? BestpathCmpRouterid { get; set; }

        /// <summary>
        /// Enable/disable compare MED among confederation paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bestpathMedConfed")]
        public Input<string>? BestpathMedConfed { get; set; }

        /// <summary>
        /// Enable/disable treat missing MED as least preferred. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bestpathMedMissingAsWorst")]
        public Input<string>? BestpathMedMissingAsWorst { get; set; }

        /// <summary>
        /// Enable/disable client-to-client route reflection. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("clientToClientReflection")]
        public Input<string>? ClientToClientReflection { get; set; }

        /// <summary>
        /// Route reflector cluster ID.
        /// </summary>
        [Input("clusterId")]
        public Input<string>? ClusterId { get; set; }

        /// <summary>
        /// Confederation identifier.
        /// </summary>
        [Input("confederationIdentifier")]
        public Input<int>? ConfederationIdentifier { get; set; }

        [Input("confederationPeers")]
        private InputList<Inputs.RouterBgpConfederationPeerArgs>? _confederationPeers;

        /// <summary>
        /// Confederation peers. The structure of `confederation_peers` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpConfederationPeerArgs> ConfederationPeers
        {
            get => _confederationPeers ?? (_confederationPeers = new InputList<Inputs.RouterBgpConfederationPeerArgs>());
            set => _confederationPeers = value;
        }

        /// <summary>
        /// Enable/disable route-flap dampening. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("dampening")]
        public Input<string>? Dampening { get; set; }

        /// <summary>
        /// Maximum minutes a route can be suppressed.
        /// </summary>
        [Input("dampeningMaxSuppressTime")]
        public Input<int>? DampeningMaxSuppressTime { get; set; }

        /// <summary>
        /// Reachability half-life time for penalty (min).
        /// </summary>
        [Input("dampeningReachabilityHalfLife")]
        public Input<int>? DampeningReachabilityHalfLife { get; set; }

        /// <summary>
        /// Threshold to reuse routes.
        /// </summary>
        [Input("dampeningReuse")]
        public Input<int>? DampeningReuse { get; set; }

        /// <summary>
        /// Criteria for dampening.
        /// </summary>
        [Input("dampeningRouteMap")]
        public Input<string>? DampeningRouteMap { get; set; }

        /// <summary>
        /// Threshold to suppress routes.
        /// </summary>
        [Input("dampeningSuppress")]
        public Input<int>? DampeningSuppress { get; set; }

        /// <summary>
        /// Unreachability half-life time for penalty (min).
        /// </summary>
        [Input("dampeningUnreachabilityHalfLife")]
        public Input<int>? DampeningUnreachabilityHalfLife { get; set; }

        /// <summary>
        /// Default local preference.
        /// </summary>
        [Input("defaultLocalPreference")]
        public Input<int>? DefaultLocalPreference { get; set; }

        /// <summary>
        /// Enable/disable enforce deterministic comparison of MED. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("deterministicMed")]
        public Input<string>? DeterministicMed { get; set; }

        /// <summary>
        /// Distance for routes external to the AS.
        /// </summary>
        [Input("distanceExternal")]
        public Input<int>? DistanceExternal { get; set; }

        /// <summary>
        /// Distance for routes internal to the AS.
        /// </summary>
        [Input("distanceInternal")]
        public Input<int>? DistanceInternal { get; set; }

        /// <summary>
        /// Distance for routes local to the AS.
        /// </summary>
        [Input("distanceLocal")]
        public Input<int>? DistanceLocal { get; set; }

        /// <summary>
        /// Sort sub-tables, please do not set this parameter when configuring static sub-tables. Options: [ false, true, natural, alphabetical ]. false: Default value, do not sort tables; true/natural: sort tables in natural order. For example: [ a10, a2 ] -&gt; [ a2, a10 ]; alphabetical: sort tables in alphabetical order. For example: [ a10, a2 ] -&gt; [ a10, a2 ].
        /// </summary>
        [Input("dynamicSortSubtable")]
        public Input<string>? DynamicSortSubtable { get; set; }

        /// <summary>
        /// Enable/disable EBGP multi-path. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("ebgpMultipath")]
        public Input<string>? EbgpMultipath { get; set; }

        /// <summary>
        /// Enable/disable enforce first AS for EBGP routes. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("enforceFirstAs")]
        public Input<string>? EnforceFirstAs { get; set; }

        /// <summary>
        /// Enable/disable reset peer BGP session if link goes down. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("fastExternalFailover")]
        public Input<string>? FastExternalFailover { get; set; }

        /// <summary>
        /// Enable/disable to exit graceful restart on timer only. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("gracefulEndOnTimer")]
        public Input<string>? GracefulEndOnTimer { get; set; }

        /// <summary>
        /// Enable/disable BGP graceful restart capabilities. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("gracefulRestart")]
        public Input<string>? GracefulRestart { get; set; }

        /// <summary>
        /// Time needed for neighbors to restart (sec).
        /// </summary>
        [Input("gracefulRestartTime")]
        public Input<int>? GracefulRestartTime { get; set; }

        /// <summary>
        /// Time to hold stale paths of restarting neighbor (sec).
        /// </summary>
        [Input("gracefulStalepathTime")]
        public Input<int>? GracefulStalepathTime { get; set; }

        /// <summary>
        /// Route advertisement/selection delay after restart (sec).
        /// </summary>
        [Input("gracefulUpdateDelay")]
        public Input<int>? GracefulUpdateDelay { get; set; }

        /// <summary>
        /// Number of seconds to mark peer as dead.
        /// </summary>
        [Input("holdtimeTimer")]
        public Input<int>? HoldtimeTimer { get; set; }

        /// <summary>
        /// Enable/disable IBGP multi-path. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("ibgpMultipath")]
        public Input<string>? IbgpMultipath { get; set; }

        /// <summary>
        /// Don't send unknown optional capability notification message Valid values: `enable`, `disable`.
        /// </summary>
        [Input("ignoreOptionalCapability")]
        public Input<string>? IgnoreOptionalCapability { get; set; }

        /// <summary>
        /// Frequency to send keep alive requests.
        /// </summary>
        [Input("keepaliveTimer")]
        public Input<int>? KeepaliveTimer { get; set; }

        /// <summary>
        /// Enable logging of BGP neighbour's changes Valid values: `enable`, `disable`.
        /// </summary>
        [Input("logNeighbourChanges")]
        public Input<string>? LogNeighbourChanges { get; set; }

        /// <summary>
        /// Enable/disable use of recursive distance to select multipath. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("multipathRecursiveDistance")]
        public Input<string>? MultipathRecursiveDistance { get; set; }

        [Input("neighborGroups")]
        private InputList<Inputs.RouterBgpNeighborGroupArgs>? _neighborGroups;

        /// <summary>
        /// BGP neighbor group table. The structure of `neighbor_group` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNeighborGroupArgs> NeighborGroups
        {
            get => _neighborGroups ?? (_neighborGroups = new InputList<Inputs.RouterBgpNeighborGroupArgs>());
            set => _neighborGroups = value;
        }

        [Input("neighborRange6s")]
        private InputList<Inputs.RouterBgpNeighborRange6Args>? _neighborRange6s;

        /// <summary>
        /// BGP IPv6 neighbor range table. The structure of `neighbor_range6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNeighborRange6Args> NeighborRange6s
        {
            get => _neighborRange6s ?? (_neighborRange6s = new InputList<Inputs.RouterBgpNeighborRange6Args>());
            set => _neighborRange6s = value;
        }

        [Input("neighborRanges")]
        private InputList<Inputs.RouterBgpNeighborRangeArgs>? _neighborRanges;

        /// <summary>
        /// BGP neighbor range table. The structure of `neighbor_range` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNeighborRangeArgs> NeighborRanges
        {
            get => _neighborRanges ?? (_neighborRanges = new InputList<Inputs.RouterBgpNeighborRangeArgs>());
            set => _neighborRanges = value;
        }

        [Input("neighbors")]
        private InputList<Inputs.RouterBgpNeighborArgs>? _neighbors;

        /// <summary>
        /// BGP neighbor table. The structure of `neighbor` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNeighborArgs> Neighbors
        {
            get => _neighbors ?? (_neighbors = new InputList<Inputs.RouterBgpNeighborArgs>());
            set => _neighbors = value;
        }

        [Input("network6s")]
        private InputList<Inputs.RouterBgpNetwork6Args>? _network6s;

        /// <summary>
        /// BGP IPv6 network table. The structure of `network6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNetwork6Args> Network6s
        {
            get => _network6s ?? (_network6s = new InputList<Inputs.RouterBgpNetwork6Args>());
            set => _network6s = value;
        }

        /// <summary>
        /// Enable/disable ensure BGP network route exists in IGP. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("networkImportCheck")]
        public Input<string>? NetworkImportCheck { get; set; }

        [Input("networks")]
        private InputList<Inputs.RouterBgpNetworkArgs>? _networks;

        /// <summary>
        /// BGP network table. The structure of `network` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNetworkArgs> Networks
        {
            get => _networks ?? (_networks = new InputList<Inputs.RouterBgpNetworkArgs>());
            set => _networks = value;
        }

        /// <summary>
        /// Enable/disable priority inheritance for recursive resolution. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("recursiveInheritPriority")]
        public Input<string>? RecursiveInheritPriority { get; set; }

        /// <summary>
        /// Enable/disable recursive resolution of next-hop using BGP route. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("recursiveNextHop")]
        public Input<string>? RecursiveNextHop { get; set; }

        [Input("redistribute6s")]
        private InputList<Inputs.RouterBgpRedistribute6Args>? _redistribute6s;

        /// <summary>
        /// BGP IPv6 redistribute table. The structure of `redistribute6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpRedistribute6Args> Redistribute6s
        {
            get => _redistribute6s ?? (_redistribute6s = new InputList<Inputs.RouterBgpRedistribute6Args>());
            set => _redistribute6s = value;
        }

        [Input("redistributes")]
        private InputList<Inputs.RouterBgpRedistributeArgs>? _redistributes;

        /// <summary>
        /// BGP IPv4 redistribute table. The structure of `redistribute` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpRedistributeArgs> Redistributes
        {
            get => _redistributes ?? (_redistributes = new InputList<Inputs.RouterBgpRedistributeArgs>());
            set => _redistributes = value;
        }

        /// <summary>
        /// Router ID.
        /// </summary>
        [Input("routerId")]
        public Input<string>? RouterId { get; set; }

        /// <summary>
        /// Background scanner interval (sec), 0 to disable it.
        /// </summary>
        [Input("scanTime")]
        public Input<int>? ScanTime { get; set; }

        /// <summary>
        /// Enable/disable only advertise routes from iBGP if routes present in an IGP. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("synchronization")]
        public Input<string>? Synchronization { get; set; }

        /// <summary>
        /// Configure tag-match mode. Resolves BGP routes with other routes containing the same tag. Valid values: `disable`, `preferred`, `merge`.
        /// </summary>
        [Input("tagResolveMode")]
        public Input<string>? TagResolveMode { get; set; }

        /// <summary>
        /// Specifies the vdom to which the resource will be applied when the FortiGate unit is running in VDOM mode. Only one vdom can be specified. If you want to inherit the vdom configuration of the provider, please do not set this parameter.
        /// </summary>
        [Input("vdomparam")]
        public Input<string>? Vdomparam { get; set; }

        [Input("vrf6s")]
        private InputList<Inputs.RouterBgpVrf6Args>? _vrf6s;

        /// <summary>
        /// BGP IPv6 VRF leaking table. The structure of `vrf6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpVrf6Args> Vrf6s
        {
            get => _vrf6s ?? (_vrf6s = new InputList<Inputs.RouterBgpVrf6Args>());
            set => _vrf6s = value;
        }

        [Input("vrfLeak6s")]
        private InputList<Inputs.RouterBgpVrfLeak6Args>? _vrfLeak6s;

        /// <summary>
        /// BGP IPv6 VRF leaking table. The structure of `vrf_leak6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpVrfLeak6Args> VrfLeak6s
        {
            get => _vrfLeak6s ?? (_vrfLeak6s = new InputList<Inputs.RouterBgpVrfLeak6Args>());
            set => _vrfLeak6s = value;
        }

        [Input("vrfLeaks")]
        private InputList<Inputs.RouterBgpVrfLeakArgs>? _vrfLeaks;

        /// <summary>
        /// BGP VRF leaking table. The structure of `vrf_leak` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpVrfLeakArgs> VrfLeaks
        {
            get => _vrfLeaks ?? (_vrfLeaks = new InputList<Inputs.RouterBgpVrfLeakArgs>());
            set => _vrfLeaks = value;
        }

        [Input("vrves")]
        private InputList<Inputs.RouterBgpVrfArgs>? _vrves;

        /// <summary>
        /// BGP VRF leaking table. The structure of `vrf` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpVrfArgs> Vrves
        {
            get => _vrves ?? (_vrves = new InputList<Inputs.RouterBgpVrfArgs>());
            set => _vrves = value;
        }

        public RouterBgpArgs()
        {
        }
        public static new RouterBgpArgs Empty => new RouterBgpArgs();
    }

    public sealed class RouterBgpState : global::Pulumi.ResourceArgs
    {
        /// <summary>
        /// Enable/disable selection of BGP IPv4 additional paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("additionalPath")]
        public Input<string>? AdditionalPath { get; set; }

        /// <summary>
        /// Enable/disable selection of BGP IPv6 additional paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("additionalPath6")]
        public Input<string>? AdditionalPath6 { get; set; }

        /// <summary>
        /// Number of additional paths to be selected for each IPv4 NLRI.
        /// </summary>
        [Input("additionalPathSelect")]
        public Input<int>? AdditionalPathSelect { get; set; }

        /// <summary>
        /// Number of additional paths to be selected for each IPv6 NLRI.
        /// </summary>
        [Input("additionalPathSelect6")]
        public Input<int>? AdditionalPathSelect6 { get; set; }

        /// <summary>
        /// Number of additional paths to be selected for each VPNv4 NLRI.
        /// </summary>
        [Input("additionalPathSelectVpnv4")]
        public Input<int>? AdditionalPathSelectVpnv4 { get; set; }

        /// <summary>
        /// Enable/disable selection of BGP VPNv4 additional paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("additionalPathVpnv4")]
        public Input<string>? AdditionalPathVpnv4 { get; set; }

        [Input("adminDistances")]
        private InputList<Inputs.RouterBgpAdminDistanceGetArgs>? _adminDistances;

        /// <summary>
        /// Administrative distance modifications. The structure of `admin_distance` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpAdminDistanceGetArgs> AdminDistances
        {
            get => _adminDistances ?? (_adminDistances = new InputList<Inputs.RouterBgpAdminDistanceGetArgs>());
            set => _adminDistances = value;
        }

        [Input("aggregateAddress6s")]
        private InputList<Inputs.RouterBgpAggregateAddress6GetArgs>? _aggregateAddress6s;

        /// <summary>
        /// BGP IPv6 aggregate address table. The structure of `aggregate_address6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpAggregateAddress6GetArgs> AggregateAddress6s
        {
            get => _aggregateAddress6s ?? (_aggregateAddress6s = new InputList<Inputs.RouterBgpAggregateAddress6GetArgs>());
            set => _aggregateAddress6s = value;
        }

        [Input("aggregateAddresses")]
        private InputList<Inputs.RouterBgpAggregateAddressGetArgs>? _aggregateAddresses;

        /// <summary>
        /// BGP aggregate address table. The structure of `aggregate_address` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpAggregateAddressGetArgs> AggregateAddresses
        {
            get => _aggregateAddresses ?? (_aggregateAddresses = new InputList<Inputs.RouterBgpAggregateAddressGetArgs>());
            set => _aggregateAddresses = value;
        }

        /// <summary>
        /// Enable/disable always compare MED. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("alwaysCompareMed")]
        public Input<string>? AlwaysCompareMed { get; set; }

        /// <summary>
        /// Router AS number, valid from 1 to 4294967295, 0 to disable BGP.
        /// </summary>
        [Input("as")]
        public Input<int>? As { get; set; }

        /// <summary>
        /// Enable/disable ignore AS path. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bestpathAsPathIgnore")]
        public Input<string>? BestpathAsPathIgnore { get; set; }

        /// <summary>
        /// Enable/disable compare federation AS path length. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bestpathCmpConfedAspath")]
        public Input<string>? BestpathCmpConfedAspath { get; set; }

        /// <summary>
        /// Enable/disable compare router ID for identical EBGP paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bestpathCmpRouterid")]
        public Input<string>? BestpathCmpRouterid { get; set; }

        /// <summary>
        /// Enable/disable compare MED among confederation paths. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bestpathMedConfed")]
        public Input<string>? BestpathMedConfed { get; set; }

        /// <summary>
        /// Enable/disable treat missing MED as least preferred. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bestpathMedMissingAsWorst")]
        public Input<string>? BestpathMedMissingAsWorst { get; set; }

        /// <summary>
        /// Enable/disable client-to-client route reflection. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("clientToClientReflection")]
        public Input<string>? ClientToClientReflection { get; set; }

        /// <summary>
        /// Route reflector cluster ID.
        /// </summary>
        [Input("clusterId")]
        public Input<string>? ClusterId { get; set; }

        /// <summary>
        /// Confederation identifier.
        /// </summary>
        [Input("confederationIdentifier")]
        public Input<int>? ConfederationIdentifier { get; set; }

        [Input("confederationPeers")]
        private InputList<Inputs.RouterBgpConfederationPeerGetArgs>? _confederationPeers;

        /// <summary>
        /// Confederation peers. The structure of `confederation_peers` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpConfederationPeerGetArgs> ConfederationPeers
        {
            get => _confederationPeers ?? (_confederationPeers = new InputList<Inputs.RouterBgpConfederationPeerGetArgs>());
            set => _confederationPeers = value;
        }

        /// <summary>
        /// Enable/disable route-flap dampening. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("dampening")]
        public Input<string>? Dampening { get; set; }

        /// <summary>
        /// Maximum minutes a route can be suppressed.
        /// </summary>
        [Input("dampeningMaxSuppressTime")]
        public Input<int>? DampeningMaxSuppressTime { get; set; }

        /// <summary>
        /// Reachability half-life time for penalty (min).
        /// </summary>
        [Input("dampeningReachabilityHalfLife")]
        public Input<int>? DampeningReachabilityHalfLife { get; set; }

        /// <summary>
        /// Threshold to reuse routes.
        /// </summary>
        [Input("dampeningReuse")]
        public Input<int>? DampeningReuse { get; set; }

        /// <summary>
        /// Criteria for dampening.
        /// </summary>
        [Input("dampeningRouteMap")]
        public Input<string>? DampeningRouteMap { get; set; }

        /// <summary>
        /// Threshold to suppress routes.
        /// </summary>
        [Input("dampeningSuppress")]
        public Input<int>? DampeningSuppress { get; set; }

        /// <summary>
        /// Unreachability half-life time for penalty (min).
        /// </summary>
        [Input("dampeningUnreachabilityHalfLife")]
        public Input<int>? DampeningUnreachabilityHalfLife { get; set; }

        /// <summary>
        /// Default local preference.
        /// </summary>
        [Input("defaultLocalPreference")]
        public Input<int>? DefaultLocalPreference { get; set; }

        /// <summary>
        /// Enable/disable enforce deterministic comparison of MED. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("deterministicMed")]
        public Input<string>? DeterministicMed { get; set; }

        /// <summary>
        /// Distance for routes external to the AS.
        /// </summary>
        [Input("distanceExternal")]
        public Input<int>? DistanceExternal { get; set; }

        /// <summary>
        /// Distance for routes internal to the AS.
        /// </summary>
        [Input("distanceInternal")]
        public Input<int>? DistanceInternal { get; set; }

        /// <summary>
        /// Distance for routes local to the AS.
        /// </summary>
        [Input("distanceLocal")]
        public Input<int>? DistanceLocal { get; set; }

        /// <summary>
        /// Sort sub-tables, please do not set this parameter when configuring static sub-tables. Options: [ false, true, natural, alphabetical ]. false: Default value, do not sort tables; true/natural: sort tables in natural order. For example: [ a10, a2 ] -&gt; [ a2, a10 ]; alphabetical: sort tables in alphabetical order. For example: [ a10, a2 ] -&gt; [ a10, a2 ].
        /// </summary>
        [Input("dynamicSortSubtable")]
        public Input<string>? DynamicSortSubtable { get; set; }

        /// <summary>
        /// Enable/disable EBGP multi-path. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("ebgpMultipath")]
        public Input<string>? EbgpMultipath { get; set; }

        /// <summary>
        /// Enable/disable enforce first AS for EBGP routes. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("enforceFirstAs")]
        public Input<string>? EnforceFirstAs { get; set; }

        /// <summary>
        /// Enable/disable reset peer BGP session if link goes down. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("fastExternalFailover")]
        public Input<string>? FastExternalFailover { get; set; }

        /// <summary>
        /// Enable/disable to exit graceful restart on timer only. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("gracefulEndOnTimer")]
        public Input<string>? GracefulEndOnTimer { get; set; }

        /// <summary>
        /// Enable/disable BGP graceful restart capabilities. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("gracefulRestart")]
        public Input<string>? GracefulRestart { get; set; }

        /// <summary>
        /// Time needed for neighbors to restart (sec).
        /// </summary>
        [Input("gracefulRestartTime")]
        public Input<int>? GracefulRestartTime { get; set; }

        /// <summary>
        /// Time to hold stale paths of restarting neighbor (sec).
        /// </summary>
        [Input("gracefulStalepathTime")]
        public Input<int>? GracefulStalepathTime { get; set; }

        /// <summary>
        /// Route advertisement/selection delay after restart (sec).
        /// </summary>
        [Input("gracefulUpdateDelay")]
        public Input<int>? GracefulUpdateDelay { get; set; }

        /// <summary>
        /// Number of seconds to mark peer as dead.
        /// </summary>
        [Input("holdtimeTimer")]
        public Input<int>? HoldtimeTimer { get; set; }

        /// <summary>
        /// Enable/disable IBGP multi-path. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("ibgpMultipath")]
        public Input<string>? IbgpMultipath { get; set; }

        /// <summary>
        /// Don't send unknown optional capability notification message Valid values: `enable`, `disable`.
        /// </summary>
        [Input("ignoreOptionalCapability")]
        public Input<string>? IgnoreOptionalCapability { get; set; }

        /// <summary>
        /// Frequency to send keep alive requests.
        /// </summary>
        [Input("keepaliveTimer")]
        public Input<int>? KeepaliveTimer { get; set; }

        /// <summary>
        /// Enable logging of BGP neighbour's changes Valid values: `enable`, `disable`.
        /// </summary>
        [Input("logNeighbourChanges")]
        public Input<string>? LogNeighbourChanges { get; set; }

        /// <summary>
        /// Enable/disable use of recursive distance to select multipath. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("multipathRecursiveDistance")]
        public Input<string>? MultipathRecursiveDistance { get; set; }

        [Input("neighborGroups")]
        private InputList<Inputs.RouterBgpNeighborGroupGetArgs>? _neighborGroups;

        /// <summary>
        /// BGP neighbor group table. The structure of `neighbor_group` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNeighborGroupGetArgs> NeighborGroups
        {
            get => _neighborGroups ?? (_neighborGroups = new InputList<Inputs.RouterBgpNeighborGroupGetArgs>());
            set => _neighborGroups = value;
        }

        [Input("neighborRange6s")]
        private InputList<Inputs.RouterBgpNeighborRange6GetArgs>? _neighborRange6s;

        /// <summary>
        /// BGP IPv6 neighbor range table. The structure of `neighbor_range6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNeighborRange6GetArgs> NeighborRange6s
        {
            get => _neighborRange6s ?? (_neighborRange6s = new InputList<Inputs.RouterBgpNeighborRange6GetArgs>());
            set => _neighborRange6s = value;
        }

        [Input("neighborRanges")]
        private InputList<Inputs.RouterBgpNeighborRangeGetArgs>? _neighborRanges;

        /// <summary>
        /// BGP neighbor range table. The structure of `neighbor_range` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNeighborRangeGetArgs> NeighborRanges
        {
            get => _neighborRanges ?? (_neighborRanges = new InputList<Inputs.RouterBgpNeighborRangeGetArgs>());
            set => _neighborRanges = value;
        }

        [Input("neighbors")]
        private InputList<Inputs.RouterBgpNeighborGetArgs>? _neighbors;

        /// <summary>
        /// BGP neighbor table. The structure of `neighbor` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNeighborGetArgs> Neighbors
        {
            get => _neighbors ?? (_neighbors = new InputList<Inputs.RouterBgpNeighborGetArgs>());
            set => _neighbors = value;
        }

        [Input("network6s")]
        private InputList<Inputs.RouterBgpNetwork6GetArgs>? _network6s;

        /// <summary>
        /// BGP IPv6 network table. The structure of `network6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNetwork6GetArgs> Network6s
        {
            get => _network6s ?? (_network6s = new InputList<Inputs.RouterBgpNetwork6GetArgs>());
            set => _network6s = value;
        }

        /// <summary>
        /// Enable/disable ensure BGP network route exists in IGP. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("networkImportCheck")]
        public Input<string>? NetworkImportCheck { get; set; }

        [Input("networks")]
        private InputList<Inputs.RouterBgpNetworkGetArgs>? _networks;

        /// <summary>
        /// BGP network table. The structure of `network` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpNetworkGetArgs> Networks
        {
            get => _networks ?? (_networks = new InputList<Inputs.RouterBgpNetworkGetArgs>());
            set => _networks = value;
        }

        /// <summary>
        /// Enable/disable priority inheritance for recursive resolution. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("recursiveInheritPriority")]
        public Input<string>? RecursiveInheritPriority { get; set; }

        /// <summary>
        /// Enable/disable recursive resolution of next-hop using BGP route. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("recursiveNextHop")]
        public Input<string>? RecursiveNextHop { get; set; }

        [Input("redistribute6s")]
        private InputList<Inputs.RouterBgpRedistribute6GetArgs>? _redistribute6s;

        /// <summary>
        /// BGP IPv6 redistribute table. The structure of `redistribute6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpRedistribute6GetArgs> Redistribute6s
        {
            get => _redistribute6s ?? (_redistribute6s = new InputList<Inputs.RouterBgpRedistribute6GetArgs>());
            set => _redistribute6s = value;
        }

        [Input("redistributes")]
        private InputList<Inputs.RouterBgpRedistributeGetArgs>? _redistributes;

        /// <summary>
        /// BGP IPv4 redistribute table. The structure of `redistribute` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpRedistributeGetArgs> Redistributes
        {
            get => _redistributes ?? (_redistributes = new InputList<Inputs.RouterBgpRedistributeGetArgs>());
            set => _redistributes = value;
        }

        /// <summary>
        /// Router ID.
        /// </summary>
        [Input("routerId")]
        public Input<string>? RouterId { get; set; }

        /// <summary>
        /// Background scanner interval (sec), 0 to disable it.
        /// </summary>
        [Input("scanTime")]
        public Input<int>? ScanTime { get; set; }

        /// <summary>
        /// Enable/disable only advertise routes from iBGP if routes present in an IGP. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("synchronization")]
        public Input<string>? Synchronization { get; set; }

        /// <summary>
        /// Configure tag-match mode. Resolves BGP routes with other routes containing the same tag. Valid values: `disable`, `preferred`, `merge`.
        /// </summary>
        [Input("tagResolveMode")]
        public Input<string>? TagResolveMode { get; set; }

        /// <summary>
        /// Specifies the vdom to which the resource will be applied when the FortiGate unit is running in VDOM mode. Only one vdom can be specified. If you want to inherit the vdom configuration of the provider, please do not set this parameter.
        /// </summary>
        [Input("vdomparam")]
        public Input<string>? Vdomparam { get; set; }

        [Input("vrf6s")]
        private InputList<Inputs.RouterBgpVrf6GetArgs>? _vrf6s;

        /// <summary>
        /// BGP IPv6 VRF leaking table. The structure of `vrf6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpVrf6GetArgs> Vrf6s
        {
            get => _vrf6s ?? (_vrf6s = new InputList<Inputs.RouterBgpVrf6GetArgs>());
            set => _vrf6s = value;
        }

        [Input("vrfLeak6s")]
        private InputList<Inputs.RouterBgpVrfLeak6GetArgs>? _vrfLeak6s;

        /// <summary>
        /// BGP IPv6 VRF leaking table. The structure of `vrf_leak6` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpVrfLeak6GetArgs> VrfLeak6s
        {
            get => _vrfLeak6s ?? (_vrfLeak6s = new InputList<Inputs.RouterBgpVrfLeak6GetArgs>());
            set => _vrfLeak6s = value;
        }

        [Input("vrfLeaks")]
        private InputList<Inputs.RouterBgpVrfLeakGetArgs>? _vrfLeaks;

        /// <summary>
        /// BGP VRF leaking table. The structure of `vrf_leak` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpVrfLeakGetArgs> VrfLeaks
        {
            get => _vrfLeaks ?? (_vrfLeaks = new InputList<Inputs.RouterBgpVrfLeakGetArgs>());
            set => _vrfLeaks = value;
        }

        [Input("vrves")]
        private InputList<Inputs.RouterBgpVrfGetArgs>? _vrves;

        /// <summary>
        /// BGP VRF leaking table. The structure of `vrf` block is documented below.
        /// </summary>
        public InputList<Inputs.RouterBgpVrfGetArgs> Vrves
        {
            get => _vrves ?? (_vrves = new InputList<Inputs.RouterBgpVrfGetArgs>());
            set => _vrves = value;
        }

        public RouterBgpState()
        {
        }
        public static new RouterBgpState Empty => new RouterBgpState();
    }
}
