<filename>sdk/dotnet/Inputs/SwitchcontrollerManagedswitchPortArgs.cs// *** 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.Inputs
{

    public sealed class SwitchcontrollerManagedswitchPortArgs : global::Pulumi.ResourceArgs
    {
        /// <summary>
        /// Access mode of the port.
        /// </summary>
        [Input("accessMode")]
        public Input<string>? AccessMode { get; set; }

        /// <summary>
        /// LACP member select mode. Valid values: `bandwidth`, `count`.
        /// </summary>
        [Input("aggregatorMode")]
        public Input<string>? AggregatorMode { get; set; }

        [Input("allowedVlans")]
        private InputList<Inputs.SwitchcontrollerManagedswitchPortAllowedVlanArgs>? _allowedVlans;

        /// <summary>
        /// Configure switch port tagged vlans The structure of `allowed_vlans` block is documented below.
        /// </summary>
        public InputList<Inputs.SwitchcontrollerManagedswitchPortAllowedVlanArgs> AllowedVlans
        {
            get => _allowedVlans ?? (_allowedVlans = new InputList<Inputs.SwitchcontrollerManagedswitchPortAllowedVlanArgs>());
            set => _allowedVlans = value;
        }

        /// <summary>
        /// Enable/disable all defined vlans on this port. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("allowedVlansAll")]
        public Input<string>? AllowedVlansAll { get; set; }

        /// <summary>
        /// Trusted or untrusted dynamic ARP inspection. Valid values: `untrusted`, `trusted`.
        /// </summary>
        [Input("arpInspectionTrust")]
        public Input<string>? ArpInspectionTrust { get; set; }

        /// <summary>
        /// Enable/disable Link Aggregation Group (LAG) bundling for non-FortiLink interfaces. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("bundle")]
        public Input<string>? Bundle { get; set; }

        /// <summary>
        /// Description for port.
        /// </summary>
        [Input("description")]
        public Input<string>? Description { get; set; }

        /// <summary>
        /// Enable/disable allowance of DHCP with option-82 on untrusted interface. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("dhcpSnoopOption82Trust")]
        public Input<string>? DhcpSnoopOption82Trust { get; set; }

        /// <summary>
        /// Trusted or untrusted DHCP-snooping interface. Valid values: `untrusted`, `trusted`.
        /// </summary>
        [Input("dhcpSnooping")]
        public Input<string>? DhcpSnooping { get; set; }

        /// <summary>
        /// Configure discard mode for port. Valid values: `none`, `all-untagged`, `all-tagged`.
        /// </summary>
        [Input("discardMode")]
        public Input<string>? DiscardMode { get; set; }

        /// <summary>
        /// Enable/disable this interface as an edge port, bridging connections between workstations and/or computers. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("edgePort")]
        public Input<string>? EdgePort { get; set; }

        [Input("exportTags")]
        private InputList<Inputs.SwitchcontrollerManagedswitchPortExportTagArgs>? _exportTags;

        /// <summary>
        /// Switch controller export tag name. The structure of `export_tags` block is documented below.
        /// </summary>
        public InputList<Inputs.SwitchcontrollerManagedswitchPortExportTagArgs> ExportTags
        {
            get => _exportTags ?? (_exportTags = new InputList<Inputs.SwitchcontrollerManagedswitchPortExportTagArgs>());
            set => _exportTags = value;
        }

        /// <summary>
        /// Export managed-switch port to a tenant VDOM.
        /// </summary>
        [Input("exportTo")]
        public Input<string>? ExportTo { get; set; }

        /// <summary>
        /// Switch controller export port to pool-list.
        /// </summary>
        [Input("exportToPool")]
        public Input<string>? ExportToPool { get; set; }

        /// <summary>
        /// Switch controller export port to pool-list.
        /// </summary>
        [Input("exportToPoolFlag")]
        public Input<int>? ExportToPoolFlag { get; set; }

        /// <summary>
        /// FEC capable.
        /// </summary>
        [Input("fecCapable")]
        public Input<int>? FecCapable { get; set; }

        /// <summary>
        /// State of forward error correction. Valid values: `disabled`, `cl74`, `cl91`.
        /// </summary>
        [Input("fecState")]
        public Input<string>? FecState { get; set; }

        /// <summary>
        /// FGT peer device name.
        /// </summary>
        [Input("fgtPeerDeviceName")]
        public Input<string>? FgtPeerDeviceName { get; set; }

        /// <summary>
        /// FGT peer port name.
        /// </summary>
        [Input("fgtPeerPortName")]
        public Input<string>? FgtPeerPortName { get; set; }

        /// <summary>
        /// Fiber-port.
        /// </summary>
        [Input("fiberPort")]
        public Input<int>? FiberPort { get; set; }

        /// <summary>
        /// Port properties flags.
        /// </summary>
        [Input("flags")]
        public Input<int>? Flags { get; set; }

        /// <summary>
        /// Period over which flap events are calculated (seconds).
        /// </summary>
        [Input("flapDuration")]
        public Input<int>? FlapDuration { get; set; }

        /// <summary>
        /// Number of stage change events needed within flap-duration.
        /// </summary>
        [Input("flapRate")]
        public Input<int>? FlapRate { get; set; }

        /// <summary>
        /// Flap guard disabling protection (min).
        /// </summary>
        [Input("flapTimeout")]
        public Input<int>? FlapTimeout { get; set; }

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

        /// <summary>
        /// Flow control direction. Valid values: `disable`, `tx`, `rx`, `both`.
        /// </summary>
        [Input("flowControl")]
        public Input<string>? FlowControl { get; set; }

        /// <summary>
        /// FortiLink uplink port.
        /// </summary>
        [Input("fortilinkPort")]
        public Input<int>? FortilinkPort { get; set; }

        /// <summary>
        /// Set IGMP snooping mode for the physical port interface. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("igmpSnooping")]
        public Input<string>? IgmpSnooping { get; set; }

        /// <summary>
        /// Enable/disable flooding of IGMP reports to this interface when igmp-snooping enabled. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("igmpSnoopingFloodReports")]
        public Input<string>? IgmpSnoopingFloodReports { get; set; }

        /// <summary>
        /// Enable/disable flooding of IGMP reports to this interface when igmp-snooping enabled. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("igmpsFloodReports")]
        public Input<string>? IgmpsFloodReports { get; set; }

        /// <summary>
        /// Enable/disable flooding of IGMP snooping traffic to this interface. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("igmpsFloodTraffic")]
        public Input<string>? IgmpsFloodTraffic { get; set; }

        [Input("interfaceTags")]
        private InputList<Inputs.SwitchcontrollerManagedswitchPortInterfaceTagArgs>? _interfaceTags;

        /// <summary>
        /// Tag(s) associated with the interface for various features including virtual port pool, dynamic port policy. The structure of `interface_tags` block is documented below.
        /// </summary>
        public InputList<Inputs.SwitchcontrollerManagedswitchPortInterfaceTagArgs> InterfaceTags
        {
            get => _interfaceTags ?? (_interfaceTags = new InputList<Inputs.SwitchcontrollerManagedswitchPortInterfaceTagArgs>());
            set => _interfaceTags = value;
        }

        /// <summary>
        /// Enable/disable IP source guard. Valid values: `disable`, `enable`.
        /// </summary>
        [Input("ipSourceGuard")]
        public Input<string>? IpSourceGuard { get; set; }

        /// <summary>
        /// ISL local trunk name.
        /// </summary>
        [Input("islLocalTrunkName")]
        public Input<string>? IslLocalTrunkName { get; set; }

        /// <summary>
        /// ISL peer device name.
        /// </summary>
        [Input("islPeerDeviceName")]
        public Input<string>? IslPeerDeviceName { get; set; }

        /// <summary>
        /// ISL peer port name.
        /// </summary>
        [Input("islPeerPortName")]
        public Input<string>? IslPeerPortName { get; set; }

        /// <summary>
        /// end Link Aggregation Control Protocol (LACP) messages every 30 seconds (slow) or every second (fast). Valid values: `slow`, `fast`.
        /// </summary>
        [Input("lacpSpeed")]
        public Input<string>? LacpSpeed { get; set; }

        /// <summary>
        /// Limit the number of dynamic MAC addresses on this Port (1 - 128, 0 = no limit, default).
        /// </summary>
        [Input("learningLimit")]
        public Input<int>? LearningLimit { get; set; }

        /// <summary>
        /// LLDP port TLV profile.
        /// </summary>
        [Input("lldpProfile")]
        public Input<string>? LldpProfile { get; set; }

        /// <summary>
        /// LLDP transmit and receive status. Valid values: `disable`, `rx-only`, `tx-only`, `tx-rx`.
        /// </summary>
        [Input("lldpStatus")]
        public Input<string>? LldpStatus { get; set; }

        /// <summary>
        /// Enable/disable loop-guard on this interface, an STP optimization used to prevent network loops. Valid values: `enabled`, `disabled`.
        /// </summary>
        [Input("loopGuard")]
        public Input<string>? LoopGuard { get; set; }

        /// <summary>
        /// Loop-guard timeout (0 - 120 min, default = 45).
        /// </summary>
        [Input("loopGuardTimeout")]
        public Input<int>? LoopGuardTimeout { get; set; }

        /// <summary>
        /// Port/Trunk MAC.
        /// </summary>
        [Input("macAddr")]
        public Input<string>? MacAddr { get; set; }

        /// <summary>
        /// Matched interface tags in the dynamic port policy.
        /// </summary>
        [Input("matchedDppIntfTags")]
        public Input<string>? MatchedDppIntfTags { get; set; }

        /// <summary>
        /// Matched child policy in the dynamic port policy.
        /// </summary>
        [Input("matchedDppPolicy")]
        public Input<string>? MatchedDppPolicy { get; set; }

        /// <summary>
        /// Maximum size of LAG bundle (1 - 24, default = 24)
        /// </summary>
        [Input("maxBundle")]
        public Input<int>? MaxBundle { get; set; }

        /// <summary>
        /// Enable/disable flooding of IGMP snooping traffic to this interface. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("mcastSnoopingFloodTraffic")]
        public Input<string>? McastSnoopingFloodTraffic { get; set; }

        /// <summary>
        /// Enable/disable multi-chassis link aggregation (MCLAG). Valid values: `enable`, `disable`.
        /// </summary>
        [Input("mclag")]
        public Input<string>? Mclag { get; set; }

        /// <summary>
        /// MCLAG-ICL port.
        /// </summary>
        [Input("mclagIclPort")]
        public Input<int>? MclagIclPort { get; set; }

        /// <summary>
        /// Media type.
        /// </summary>
        [Input("mediaType")]
        public Input<string>? MediaType { get; set; }

        /// <summary>
        /// Port behavior after it withdraws because of loss of control packets. Valid values: `forward`, `block`.
        /// </summary>
        [Input("memberWithdrawalBehavior")]
        public Input<string>? MemberWithdrawalBehavior { get; set; }

        [Input("members")]
        private InputList<Inputs.SwitchcontrollerManagedswitchPortMemberArgs>? _members;

        /// <summary>
        /// Aggregated LAG bundle interfaces. The structure of `members` block is documented below.
        /// </summary>
        public InputList<Inputs.SwitchcontrollerManagedswitchPortMemberArgs> Members
        {
            get => _members ?? (_members = new InputList<Inputs.SwitchcontrollerManagedswitchPortMemberArgs>());
            set => _members = value;
        }

        /// <summary>
        /// Minimum size of LAG bundle (1 - 24, default = 1)
        /// </summary>
        [Input("minBundle")]
        public Input<int>? MinBundle { get; set; }

        /// <summary>
        /// LACP mode: ignore and do not send control messages, or negotiate 802.3ad aggregation passively or actively. Valid values: `static`, `lacp-passive`, `lacp-active`.
        /// </summary>
        [Input("mode")]
        public Input<string>? Mode { get; set; }

        /// <summary>
        /// General peer to peer tunnel port.
        /// </summary>
        [Input("p2pPort")]
        public Input<int>? P2pPort { get; set; }

        /// <summary>
        /// Packet sampling rate (0 - 99999 p/sec).
        /// </summary>
        [Input("packetSampleRate")]
        public Input<int>? PacketSampleRate { get; set; }

        /// <summary>
        /// Enable/disable packet sampling on this interface. Valid values: `enabled`, `disabled`.
        /// </summary>
        [Input("packetSampler")]
        public Input<string>? PacketSampler { get; set; }

        /// <summary>
        /// Configure ingress pause metering rate, in kbps (default = 0, disabled).
        /// </summary>
        [Input("pauseMeter")]
        public Input<int>? PauseMeter { get; set; }

        /// <summary>
        /// Resume threshold for resuming traffic on ingress port. Valid values: `75%`, `50%`, `25%`.
        /// </summary>
        [Input("pauseMeterResume")]
        public Input<string>? PauseMeterResume { get; set; }

        /// <summary>
        /// PoE capable.
        /// </summary>
        [Input("poeCapable")]
        public Input<int>? PoeCapable { get; set; }

        /// <summary>
        /// PoE maximum power.
        /// </summary>
        [Input("poeMaxPower")]
        public Input<string>? PoeMaxPower { get; set; }

        /// <summary>
        /// Enable/disable PoE pre-standard detection. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("poePreStandardDetection")]
        public Input<string>? PoePreStandardDetection { get; set; }

        /// <summary>
        /// PoE standard supported.
        /// </summary>
        [Input("poeStandard")]
        public Input<string>? PoeStandard { get; set; }

        /// <summary>
        /// Enable/disable PoE status. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("poeStatus")]
        public Input<string>? PoeStatus { get; set; }

        /// <summary>
        /// Switch port name.
        /// </summary>
        [Input("portName")]
        public Input<string>? PortName { get; set; }

        /// <summary>
        /// Port number.
        /// </summary>
        [Input("portNumber")]
        public Input<int>? PortNumber { get; set; }

        /// <summary>
        /// Switch port name.
        /// </summary>
        [Input("portOwner")]
        public Input<string>? PortOwner { get; set; }

        /// <summary>
        /// Switch controller dynamic port policy from available options.
        /// </summary>
        [Input("portPolicy")]
        public Input<string>? PortPolicy { get; set; }

        /// <summary>
        /// Port prefix type.
        /// </summary>
        [Input("portPrefixType")]
        public Input<int>? PortPrefixType { get; set; }

        /// <summary>
        /// Switch controller authentication policy to apply to this managed switch from available options.
        /// </summary>
        [Input("portSecurityPolicy")]
        public Input<string>? PortSecurityPolicy { get; set; }

        /// <summary>
        /// Algorithm for aggregate port selection. Valid values: `src-mac`, `dst-mac`, `src-dst-mac`, `src-ip`, `dst-ip`, `src-dst-ip`.
        /// </summary>
        [Input("portSelectionCriteria")]
        public Input<string>? PortSelectionCriteria { get; set; }

        /// <summary>
        /// PTP policy configuration.
        /// </summary>
        [Input("ptpPolicy")]
        public Input<string>? PtpPolicy { get; set; }

        /// <summary>
        /// Switch controller QoS policy from available options.
        /// </summary>
        [Input("qosPolicy")]
        public Input<string>? QosPolicy { get; set; }

        /// <summary>
        /// Enable/disable inter-operability with rapid PVST on this interface. Valid values: `disabled`, `enabled`.
        /// </summary>
        [Input("rpvstPort")]
        public Input<string>? RpvstPort { get; set; }

        /// <summary>
        /// sFlow sample direction. Valid values: `tx`, `rx`, `both`.
        /// </summary>
        [Input("sampleDirection")]
        public Input<string>? SampleDirection { get; set; }

        /// <summary>
        /// sFlow sampler counter polling interval (1 - 255 sec).
        /// </summary>
        [Input("sflowCounterInterval")]
        public Input<int>? SflowCounterInterval { get; set; }

        /// <summary>
        /// sFlow sampler sample rate (0 - 99999 p/sec).
        /// </summary>
        [Input("sflowSampleRate")]
        public Input<int>? SflowSampleRate { get; set; }

        /// <summary>
        /// Enable/disable sFlow protocol on this interface. Valid values: `enabled`, `disabled`.
        /// </summary>
        [Input("sflowSampler")]
        public Input<string>? SflowSampler { get; set; }

        /// <summary>
        /// Switch port speed; default and available settings depend on hardware.
        /// </summary>
        [Input("speed")]
        public Input<string>? Speed { get; set; }

        /// <summary>
        /// Switch port speed mask.
        /// </summary>
        [Input("speedMask")]
        public Input<int>? SpeedMask { get; set; }

        /// <summary>
        /// Stacking port.
        /// </summary>
        [Input("stackingPort")]
        public Input<int>? StackingPort { get; set; }

        /// <summary>
        /// Switch port admin status: up or down. Valid values: `up`, `down`.
        /// </summary>
        [Input("status")]
        public Input<string>? Status { get; set; }

        /// <summary>
        /// Enable or disable sticky-mac on the interface. Valid values: `enable`, `disable`.
        /// </summary>
        [Input("stickyMac")]
        public Input<string>? StickyMac { get; set; }

        /// <summary>
        /// Switch controller storm control policy from available options.
        /// </summary>
        [Input("stormControlPolicy")]
        public Input<string>? StormControlPolicy { get; set; }

        /// <summary>
        /// Enable/disable STP BPDU guard on this interface. Valid values: `enabled`, `disabled`.
        /// </summary>
        [Input("stpBpduGuard")]
        public Input<string>? StpBpduGuard { get; set; }

        /// <summary>
        /// BPDU Guard disabling protection (0 - 120 min).
        /// </summary>
        [Input("stpBpduGuardTimeout")]
        public Input<int>? StpBpduGuardTimeout { get; set; }

        /// <summary>
        /// Enable/disable STP root guard on this interface. Valid values: `enabled`, `disabled`.
        /// </summary>
        [Input("stpRootGuard")]
        public Input<string>? StpRootGuard { get; set; }

        /// <summary>
        /// Enable/disable Spanning Tree Protocol (STP) on this interface. Valid values: `enabled`, `disabled`.
        /// </summary>
        [Input("stpState")]
        public Input<string>? StpState { get; set; }

        /// <summary>
        /// Switch id.
        /// </summary>
        [Input("switchId")]
        public Input<string>? SwitchId { get; set; }

        /// <summary>
        /// Interface type: physical or trunk port. Valid values: `physical`, `trunk`.
        /// </summary>
        [Input("type")]
        public Input<string>? Type { get; set; }

        [Input("untaggedVlans")]
        private InputList<Inputs.SwitchcontrollerManagedswitchPortUntaggedVlanArgs>? _untaggedVlans;

        /// <summary>
        /// Configure switch port untagged vlans The structure of `untagged_vlans` block is documented below.
        /// </summary>
        public InputList<Inputs.SwitchcontrollerManagedswitchPortUntaggedVlanArgs> UntaggedVlans
        {
            get => _untaggedVlans ?? (_untaggedVlans = new InputList<Inputs.SwitchcontrollerManagedswitchPortUntaggedVlanArgs>());
            set => _untaggedVlans = value;
        }

        /// <summary>
        /// Virtualized switch port.
        /// </summary>
        [Input("virtualPort")]
        public Input<int>? VirtualPort { get; set; }

        /// <summary>
        /// Assign switch ports to a VLAN.
        /// </summary>
        [Input("vlan")]
        public Input<string>? Vlan { get; set; }

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