pulumi-juniper-mist 0.7.0a1763768337__py3-none-any.whl → 0.7.1__py3-none-any.whl

pulumi_juniper_mist/device/_inputs.py

@@ -175,8 +175,12 @@ __all__ = [
     'GatewayServicePolicyEwfArgsDict',
     'GatewayServicePolicyIdpArgs',
     'GatewayServicePolicyIdpArgsDict',
+    'GatewayServicePolicySkyatpArgs',
+    'GatewayServicePolicySkyatpArgsDict',
     'GatewayServicePolicySslProxyArgs',
     'GatewayServicePolicySslProxyArgsDict',
+    'GatewayServicePolicySyslogArgs',
+    'GatewayServicePolicySyslogArgsDict',
     'GatewayTunnelConfigsArgs',
     'GatewayTunnelConfigsArgsDict',
     'GatewayTunnelConfigsAutoProvisionArgs',
@@ -3061,14 +3065,14 @@ if not MYPY:
         """
         Antenna gain for 6G - for models with external antenna only
         """
-        ant_mode: NotRequired[pulumi.Input[_builtins.str]]
-        """
-        Antenna Mode for AP which supports selectable antennas. enum: `external`, `internal`
-        """
         antenna_mode: NotRequired[pulumi.Input[_builtins.str]]
         """
         enum: `1x1`, `2x2`, `3x3`, `4x4`, `default`
         """
+        antenna_select: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Antenna Mode for AP which supports selectable antennas. enum: `external`, `internal`
+        """
         band24: NotRequired[pulumi.Input['ApRadioConfigBand24ArgsDict']]
         """
         Radio Band AP settings
@@ -3097,6 +3101,10 @@ if not MYPY:
         """
         To make an outdoor operate indoor. For an outdoor-ap, some channels are disallowed by default, this allows the user to use it as an indoor-ap
         """
+        rrm_managed: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        Enable RRM to manage all radio settings (ignores all band_xxx configs)
+        """
         scanning_enabled: NotRequired[pulumi.Input[_builtins.bool]]
         """
         Whether scanning radio is enabled
@@ -3111,8 +3119,8 @@ class ApRadioConfigArgs:
                  ant_gain24: Optional[pulumi.Input[_builtins.int]] = None,
                  ant_gain5: Optional[pulumi.Input[_builtins.int]] = None,
                  ant_gain6: Optional[pulumi.Input[_builtins.int]] = None,
-                 ant_mode: Optional[pulumi.Input[_builtins.str]] = None,
                  antenna_mode: Optional[pulumi.Input[_builtins.str]] = None,
+                 antenna_select: Optional[pulumi.Input[_builtins.str]] = None,
                  band24: Optional[pulumi.Input['ApRadioConfigBand24Args']] = None,
                  band24_usage: Optional[pulumi.Input[_builtins.str]] = None,
                  band5: Optional[pulumi.Input['ApRadioConfigBand5Args']] = None,
@@ -3120,13 +3128,14 @@ class ApRadioConfigArgs:
                  band6: Optional[pulumi.Input['ApRadioConfigBand6Args']] = None,
                  full_automatic_rrm: Optional[pulumi.Input[_builtins.bool]] = None,
                  indoor_use: Optional[pulumi.Input[_builtins.bool]] = None,
+                 rrm_managed: Optional[pulumi.Input[_builtins.bool]] = None,
                  scanning_enabled: Optional[pulumi.Input[_builtins.bool]] = None):
         """
         :param pulumi.Input[_builtins.int] ant_gain24: Antenna gain for 2.4G - for models with external antenna only
         :param pulumi.Input[_builtins.int] ant_gain5: Antenna gain for 5G - for models with external antenna only
         :param pulumi.Input[_builtins.int] ant_gain6: Antenna gain for 6G - for models with external antenna only
-        :param pulumi.Input[_builtins.str] ant_mode: Antenna Mode for AP which supports selectable antennas. enum: `external`, `internal`
         :param pulumi.Input[_builtins.str] antenna_mode: enum: `1x1`, `2x2`, `3x3`, `4x4`, `default`
+        :param pulumi.Input[_builtins.str] antenna_select: Antenna Mode for AP which supports selectable antennas. enum: `external`, `internal`
         :param pulumi.Input['ApRadioConfigBand24Args'] band24: Radio Band AP settings
         :param pulumi.Input[_builtins.str] band24_usage: enum: `24`, `5`, `6`, `auto`
         :param pulumi.Input['ApRadioConfigBand5Args'] band5: Radio Band AP settings
@@ -3134,6 +3143,7 @@ class ApRadioConfigArgs:
         :param pulumi.Input['ApRadioConfigBand6Args'] band6: Radio Band AP settings
         :param pulumi.Input[_builtins.bool] full_automatic_rrm: Let RRM control everything, only the `channels` and `ant_gain` will be honored (i.e. disabled/bandwidth/power/band_24_usage are all controlled by RRM)
         :param pulumi.Input[_builtins.bool] indoor_use: To make an outdoor operate indoor. For an outdoor-ap, some channels are disallowed by default, this allows the user to use it as an indoor-ap
+        :param pulumi.Input[_builtins.bool] rrm_managed: Enable RRM to manage all radio settings (ignores all band_xxx configs)
         :param pulumi.Input[_builtins.bool] scanning_enabled: Whether scanning radio is enabled
         """
         if allow_rrm_disable is not None:
@@ -3144,10 +3154,10 @@ class ApRadioConfigArgs:
             pulumi.set(__self__, "ant_gain5", ant_gain5)
         if ant_gain6 is not None:
             pulumi.set(__self__, "ant_gain6", ant_gain6)
-        if ant_mode is not None:
-            pulumi.set(__self__, "ant_mode", ant_mode)
         if antenna_mode is not None:
             pulumi.set(__self__, "antenna_mode", antenna_mode)
+        if antenna_select is not None:
+            pulumi.set(__self__, "antenna_select", antenna_select)
         if band24 is not None:
             pulumi.set(__self__, "band24", band24)
         if band24_usage is not None:
@@ -3162,6 +3172,8 @@ class ApRadioConfigArgs:
             pulumi.set(__self__, "full_automatic_rrm", full_automatic_rrm)
         if indoor_use is not None:
             pulumi.set(__self__, "indoor_use", indoor_use)
+        if rrm_managed is not None:
+            pulumi.set(__self__, "rrm_managed", rrm_managed)
         if scanning_enabled is not None:
             pulumi.set(__self__, "scanning_enabled", scanning_enabled)
 
@@ -3210,18 +3222,6 @@ class ApRadioConfigArgs:
     def ant_gain6(self, value: Optional[pulumi.Input[_builtins.int]]):
         pulumi.set(self, "ant_gain6", value)
 
-    @_builtins.property
-    @pulumi.getter(name="antMode")
-    def ant_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
-        """
-        Antenna Mode for AP which supports selectable antennas. enum: `external`, `internal`
-        """
-        return pulumi.get(self, "ant_mode")
-
-    @ant_mode.setter
-    def ant_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "ant_mode", value)
-
     @_builtins.property
     @pulumi.getter(name="antennaMode")
     def antenna_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -3234,6 +3234,18 @@ class ApRadioConfigArgs:
     def antenna_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "antenna_mode", value)
 
+    @_builtins.property
+    @pulumi.getter(name="antennaSelect")
+    def antenna_select(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Antenna Mode for AP which supports selectable antennas. enum: `external`, `internal`
+        """
+        return pulumi.get(self, "antenna_select")
+
+    @antenna_select.setter
+    def antenna_select(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "antenna_select", value)
+
     @_builtins.property
     @pulumi.getter
     def band24(self) -> Optional[pulumi.Input['ApRadioConfigBand24Args']]:
@@ -3318,6 +3330,18 @@ class ApRadioConfigArgs:
     def indoor_use(self, value: Optional[pulumi.Input[_builtins.bool]]):
         pulumi.set(self, "indoor_use", value)
 
+    @_builtins.property
+    @pulumi.getter(name="rrmManaged")
+    def rrm_managed(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Enable RRM to manage all radio settings (ignores all band_xxx configs)
+        """
+        return pulumi.get(self, "rrm_managed")
+
+    @rrm_managed.setter
+    def rrm_managed(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "rrm_managed", value)
+
     @_builtins.property
     @pulumi.getter(name="scanningEnabled")
     def scanning_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
@@ -3553,6 +3577,10 @@ if not MYPY:
     class ApRadioConfigBand5ArgsDict(TypedDict):
         allow_rrm_disable: NotRequired[pulumi.Input[_builtins.bool]]
         ant_gain: NotRequired[pulumi.Input[_builtins.int]]
+        antenna_beam_pattern: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        enum: `narrow`, `medium`, `wide`
+        """
         antenna_mode: NotRequired[pulumi.Input[_builtins.str]]
         """
         enum: `1x1`, `2x2`, `3x3`, `4x4`, `default`
@@ -3597,6 +3625,7 @@ class ApRadioConfigBand5Args:
     def __init__(__self__, *,
                  allow_rrm_disable: Optional[pulumi.Input[_builtins.bool]] = None,
                  ant_gain: Optional[pulumi.Input[_builtins.int]] = None,
+                 antenna_beam_pattern: Optional[pulumi.Input[_builtins.str]] = None,
                  antenna_mode: Optional[pulumi.Input[_builtins.str]] = None,
                  bandwidth: Optional[pulumi.Input[_builtins.int]] = None,
                  channel: Optional[pulumi.Input[_builtins.int]] = None,
@@ -3607,6 +3636,7 @@ class ApRadioConfigBand5Args:
                  power_min: Optional[pulumi.Input[_builtins.int]] = None,
                  preamble: Optional[pulumi.Input[_builtins.str]] = None):
         """
+        :param pulumi.Input[_builtins.str] antenna_beam_pattern: enum: `narrow`, `medium`, `wide`
         :param pulumi.Input[_builtins.str] antenna_mode: enum: `1x1`, `2x2`, `3x3`, `4x4`, `default`
         :param pulumi.Input[_builtins.int] bandwidth: channel width for the 5GHz band. enum: `0`(disabled, response only), `20`, `40`, `80`
         :param pulumi.Input[_builtins.int] channel: For Device. (primary) channel for the band, 0 means using the Site Setting
@@ -3621,6 +3651,8 @@ class ApRadioConfigBand5Args:
             pulumi.set(__self__, "allow_rrm_disable", allow_rrm_disable)
         if ant_gain is not None:
             pulumi.set(__self__, "ant_gain", ant_gain)
+        if antenna_beam_pattern is not None:
+            pulumi.set(__self__, "antenna_beam_pattern", antenna_beam_pattern)
         if antenna_mode is not None:
             pulumi.set(__self__, "antenna_mode", antenna_mode)
         if bandwidth is not None:
@@ -3658,6 +3690,18 @@ class ApRadioConfigBand5Args:
     def ant_gain(self, value: Optional[pulumi.Input[_builtins.int]]):
         pulumi.set(self, "ant_gain", value)
 
+    @_builtins.property
+    @pulumi.getter(name="antennaBeamPattern")
+    def antenna_beam_pattern(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        enum: `narrow`, `medium`, `wide`
+        """
+        return pulumi.get(self, "antenna_beam_pattern")
+
+    @antenna_beam_pattern.setter
+    def antenna_beam_pattern(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "antenna_beam_pattern", value)
+
     @_builtins.property
     @pulumi.getter(name="antennaMode")
     def antenna_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -3771,6 +3815,10 @@ if not MYPY:
     class ApRadioConfigBand5On24RadioArgsDict(TypedDict):
         allow_rrm_disable: NotRequired[pulumi.Input[_builtins.bool]]
         ant_gain: NotRequired[pulumi.Input[_builtins.int]]
+        antenna_beam_pattern: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        enum: `narrow`, `medium`, `wide`
+        """
         antenna_mode: NotRequired[pulumi.Input[_builtins.str]]
         """
         enum: `1x1`, `2x2`, `3x3`, `4x4`, `default`
@@ -3815,6 +3863,7 @@ class ApRadioConfigBand5On24RadioArgs:
     def __init__(__self__, *,
                  allow_rrm_disable: Optional[pulumi.Input[_builtins.bool]] = None,
                  ant_gain: Optional[pulumi.Input[_builtins.int]] = None,
+                 antenna_beam_pattern: Optional[pulumi.Input[_builtins.str]] = None,
                  antenna_mode: Optional[pulumi.Input[_builtins.str]] = None,
                  bandwidth: Optional[pulumi.Input[_builtins.int]] = None,
                  channel: Optional[pulumi.Input[_builtins.int]] = None,
@@ -3825,6 +3874,7 @@ class ApRadioConfigBand5On24RadioArgs:
                  power_min: Optional[pulumi.Input[_builtins.int]] = None,
                  preamble: Optional[pulumi.Input[_builtins.str]] = None):
         """
+        :param pulumi.Input[_builtins.str] antenna_beam_pattern: enum: `narrow`, `medium`, `wide`
         :param pulumi.Input[_builtins.str] antenna_mode: enum: `1x1`, `2x2`, `3x3`, `4x4`, `default`
         :param pulumi.Input[_builtins.int] bandwidth: channel width for the 5GHz band. enum: `0`(disabled, response only), `20`, `40`, `80`
         :param pulumi.Input[_builtins.int] channel: For Device. (primary) channel for the band, 0 means using the Site Setting
@@ -3839,6 +3889,8 @@ class ApRadioConfigBand5On24RadioArgs:
             pulumi.set(__self__, "allow_rrm_disable", allow_rrm_disable)
         if ant_gain is not None:
             pulumi.set(__self__, "ant_gain", ant_gain)
+        if antenna_beam_pattern is not None:
+            pulumi.set(__self__, "antenna_beam_pattern", antenna_beam_pattern)
         if antenna_mode is not None:
             pulumi.set(__self__, "antenna_mode", antenna_mode)
         if bandwidth is not None:
@@ -3876,6 +3928,18 @@ class ApRadioConfigBand5On24RadioArgs:
     def ant_gain(self, value: Optional[pulumi.Input[_builtins.int]]):
         pulumi.set(self, "ant_gain", value)
 
+    @_builtins.property
+    @pulumi.getter(name="antennaBeamPattern")
+    def antenna_beam_pattern(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        enum: `narrow`, `medium`, `wide`
+        """
+        return pulumi.get(self, "antenna_beam_pattern")
+
+    @antenna_beam_pattern.setter
+    def antenna_beam_pattern(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "antenna_beam_pattern", value)
+
     @_builtins.property
     @pulumi.getter(name="antennaMode")
     def antenna_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -3989,6 +4053,10 @@ if not MYPY:
     class ApRadioConfigBand6ArgsDict(TypedDict):
         allow_rrm_disable: NotRequired[pulumi.Input[_builtins.bool]]
         ant_gain: NotRequired[pulumi.Input[_builtins.int]]
+        antenna_beam_pattern: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        enum: `narrow`, `medium`, `wide`
+        """
         antenna_mode: NotRequired[pulumi.Input[_builtins.str]]
         """
         enum: `1x1`, `2x2`, `3x3`, `4x4`, `default`
@@ -4037,6 +4105,7 @@ class ApRadioConfigBand6Args:
     def __init__(__self__, *,
                  allow_rrm_disable: Optional[pulumi.Input[_builtins.bool]] = None,
                  ant_gain: Optional[pulumi.Input[_builtins.int]] = None,
+                 antenna_beam_pattern: Optional[pulumi.Input[_builtins.str]] = None,
                  antenna_mode: Optional[pulumi.Input[_builtins.str]] = None,
                  bandwidth: Optional[pulumi.Input[_builtins.int]] = None,
                  channel: Optional[pulumi.Input[_builtins.int]] = None,
@@ -4048,6 +4117,7 @@ class ApRadioConfigBand6Args:
                  preamble: Optional[pulumi.Input[_builtins.str]] = None,
                  standard_power: Optional[pulumi.Input[_builtins.bool]] = None):
         """
+        :param pulumi.Input[_builtins.str] antenna_beam_pattern: enum: `narrow`, `medium`, `wide`
         :param pulumi.Input[_builtins.str] antenna_mode: enum: `1x1`, `2x2`, `3x3`, `4x4`, `default`
         :param pulumi.Input[_builtins.int] bandwidth: channel width for the 6GHz band. enum: `0`(disabled, response only), `20`, `40`, `80`, `160`
         :param pulumi.Input[_builtins.int] channel: For Device. (primary) channel for the band, 0 means using the Site Setting
@@ -4063,6 +4133,8 @@ class ApRadioConfigBand6Args:
             pulumi.set(__self__, "allow_rrm_disable", allow_rrm_disable)
         if ant_gain is not None:
             pulumi.set(__self__, "ant_gain", ant_gain)
+        if antenna_beam_pattern is not None:
+            pulumi.set(__self__, "antenna_beam_pattern", antenna_beam_pattern)
         if antenna_mode is not None:
             pulumi.set(__self__, "antenna_mode", antenna_mode)
         if bandwidth is not None:
@@ -4102,6 +4174,18 @@ class ApRadioConfigBand6Args:
     def ant_gain(self, value: Optional[pulumi.Input[_builtins.int]]):
         pulumi.set(self, "ant_gain", value)
 
+    @_builtins.property
+    @pulumi.getter(name="antennaBeamPattern")
+    def antenna_beam_pattern(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        enum: `narrow`, `medium`, `wide`
+        """
+        return pulumi.get(self, "antenna_beam_pattern")
+
+    @antenna_beam_pattern.setter
+    def antenna_beam_pattern(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "antenna_beam_pattern", value)
+
     @_builtins.property
     @pulumi.getter(name="antennaMode")
     def antenna_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -7574,7 +7658,7 @@ if not MYPY:
         """
         ae_lacp_force_up: NotRequired[pulumi.Input[_builtins.bool]]
         """
-        For SRX Only, if `aggregated`==`true`.Sets the state of the interface as UP when the peer has limited LACP capability. Use case: When a device connected to this AE port is ZTPing for the first time, it will not have LACP configured on the other end. **Note:** Turning this on will enable force-up on one of the interfaces in the bundle only
+        For SRX only, if `aggregated`==`true`.Sets the state of the interface as UP when the peer has limited LACP capability. Use case: When a device connected to this AE port is ZTPing for the first time, it will not have LACP configured on the other end. **Note:** Turning this on will enable force-up on one of the interfaces in the bundle only
         """
         aggregated: NotRequired[pulumi.Input[_builtins.bool]]
         critical: NotRequired[pulumi.Input[_builtins.bool]]
@@ -7781,7 +7865,7 @@ class GatewayPortConfigArgs:
         :param pulumi.Input[_builtins.str] usage: port usage name. enum: `ha_control`, `ha_data`, `lan`, `wan`
         :param pulumi.Input[_builtins.bool] ae_disable_lacp: If `aggregated`==`true`. To disable LCP support for the AE interface
         :param pulumi.Input[_builtins.str] ae_idx: If `aggregated`==`true`. Users could force to use the designated AE name (must be an integer between 0 and 127)
-        :param pulumi.Input[_builtins.bool] ae_lacp_force_up: For SRX Only, if `aggregated`==`true`.Sets the state of the interface as UP when the peer has limited LACP capability. Use case: When a device connected to this AE port is ZTPing for the first time, it will not have LACP configured on the other end. **Note:** Turning this on will enable force-up on one of the interfaces in the bundle only
+        :param pulumi.Input[_builtins.bool] ae_lacp_force_up: For SRX only, if `aggregated`==`true`.Sets the state of the interface as UP when the peer has limited LACP capability. Use case: When a device connected to this AE port is ZTPing for the first time, it will not have LACP configured on the other end. **Note:** Turning this on will enable force-up on one of the interfaces in the bundle only
         :param pulumi.Input[_builtins.bool] critical: To generate port up/down alarm, set it to true
         :param pulumi.Input[_builtins.str] description: Interface Description. Can be a variable (i.e. "{{myvar}}")
         :param pulumi.Input[_builtins.bool] disabled: Port admin up (true) / down (false)
@@ -7952,7 +8036,7 @@ class GatewayPortConfigArgs:
     @pulumi.getter(name="aeLacpForceUp")
     def ae_lacp_force_up(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        For SRX Only, if `aggregated`==`true`.Sets the state of the interface as UP when the peer has limited LACP capability. Use case: When a device connected to this AE port is ZTPing for the first time, it will not have LACP configured on the other end. **Note:** Turning this on will enable force-up on one of the interfaces in the bundle only
+        For SRX only, if `aggregated`==`true`.Sets the state of the interface as UP when the peer has limited LACP capability. Use case: When a device connected to this AE port is ZTPing for the first time, it will not have LACP configured on the other end. **Note:** Turning this on will enable force-up on one of the interfaces in the bundle only
         """
         return pulumi.get(self, "ae_lacp_force_up")
 
@@ -9779,7 +9863,7 @@ if not MYPY:
         """
         appqoe: NotRequired[pulumi.Input['GatewayServicePolicyAppqoeArgsDict']]
         """
-        For SRX Only
+        SRX only
         """
         ewfs: NotRequired[pulumi.Input[Sequence[pulumi.Input['GatewayServicePolicyEwfArgsDict']]]]
         idp: NotRequired[pulumi.Input['GatewayServicePolicyIdpArgsDict']]
@@ -9803,10 +9887,18 @@ if not MYPY:
         """
         Required when `servicepolicy_id` is not defined. List of Applications / Destinations
         """
+        skyatp: NotRequired[pulumi.Input['GatewayServicePolicySkyatpArgsDict']]
+        """
+        SRX only
+        """
         ssl_proxy: NotRequired[pulumi.Input['GatewayServicePolicySslProxyArgsDict']]
         """
         For SRX-only
         """
+        syslog: NotRequired[pulumi.Input['GatewayServicePolicySyslogArgsDict']]
+        """
+        Required for syslog logging
+        """
         tenants: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         """
         Required when `servicepolicy_id` is not defined. List of Networks / Users
@@ -9827,18 +9919,22 @@ class GatewayServicePolicyArgs:
                  path_preference: Optional[pulumi.Input[_builtins.str]] = None,
                  servicepolicy_id: Optional[pulumi.Input[_builtins.str]] = None,
                  services: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+                 skyatp: Optional[pulumi.Input['GatewayServicePolicySkyatpArgs']] = None,
                  ssl_proxy: Optional[pulumi.Input['GatewayServicePolicySslProxyArgs']] = None,
+                 syslog: Optional[pulumi.Input['GatewayServicePolicySyslogArgs']] = None,
                  tenants: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
         :param pulumi.Input[_builtins.str] action: Required when `servicepolicy_id` is not defined, optional otherwise (override the servicepolicy action). enum: `allow`, `deny`
         :param pulumi.Input['GatewayServicePolicyAntivirusArgs'] antivirus: For SRX-only
-        :param pulumi.Input['GatewayServicePolicyAppqoeArgs'] appqoe: For SRX Only
+        :param pulumi.Input['GatewayServicePolicyAppqoeArgs'] appqoe: SRX only
         :param pulumi.Input[_builtins.bool] local_routing: access within the same VRF
         :param pulumi.Input[_builtins.str] name: Required when `servicepolicy_id` is not defined, optional otherwise (override the servicepolicy name)
         :param pulumi.Input[_builtins.str] path_preference: By default, we derive all paths available and use them. Optionally, you can customize by using `path_preference`
         :param pulumi.Input[_builtins.str] servicepolicy_id: Used to link servicepolicy defined at org level and overwrite some attributes
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] services: Required when `servicepolicy_id` is not defined. List of Applications / Destinations
+        :param pulumi.Input['GatewayServicePolicySkyatpArgs'] skyatp: SRX only
         :param pulumi.Input['GatewayServicePolicySslProxyArgs'] ssl_proxy: For SRX-only
+        :param pulumi.Input['GatewayServicePolicySyslogArgs'] syslog: Required for syslog logging
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tenants: Required when `servicepolicy_id` is not defined. List of Networks / Users
         """
         if action is not None:
@@ -9861,8 +9957,12 @@ class GatewayServicePolicyArgs:
             pulumi.set(__self__, "servicepolicy_id", servicepolicy_id)
         if services is not None:
             pulumi.set(__self__, "services", services)
+        if skyatp is not None:
+            pulumi.set(__self__, "skyatp", skyatp)
         if ssl_proxy is not None:
             pulumi.set(__self__, "ssl_proxy", ssl_proxy)
+        if syslog is not None:
+            pulumi.set(__self__, "syslog", syslog)
         if tenants is not None:
             pulumi.set(__self__, "tenants", tenants)
 
@@ -9894,7 +9994,7 @@ class GatewayServicePolicyArgs:
     @pulumi.getter
     def appqoe(self) -> Optional[pulumi.Input['GatewayServicePolicyAppqoeArgs']]:
         """
-        For SRX Only
+        SRX only
         """
         return pulumi.get(self, "appqoe")
 
@@ -9980,6 +10080,18 @@ class GatewayServicePolicyArgs:
     def services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
         pulumi.set(self, "services", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def skyatp(self) -> Optional[pulumi.Input['GatewayServicePolicySkyatpArgs']]:
+        """
+        SRX only
+        """
+        return pulumi.get(self, "skyatp")
+
+    @skyatp.setter
+    def skyatp(self, value: Optional[pulumi.Input['GatewayServicePolicySkyatpArgs']]):
+        pulumi.set(self, "skyatp", value)
+
     @_builtins.property
     @pulumi.getter(name="sslProxy")
     def ssl_proxy(self) -> Optional[pulumi.Input['GatewayServicePolicySslProxyArgs']]:
@@ -9992,6 +10104,18 @@ class GatewayServicePolicyArgs:
     def ssl_proxy(self, value: Optional[pulumi.Input['GatewayServicePolicySslProxyArgs']]):
         pulumi.set(self, "ssl_proxy", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def syslog(self) -> Optional[pulumi.Input['GatewayServicePolicySyslogArgs']]:
+        """
+        Required for syslog logging
+        """
+        return pulumi.get(self, "syslog")
+
+    @syslog.setter
+    def syslog(self, value: Optional[pulumi.Input['GatewayServicePolicySyslogArgs']]):
+        pulumi.set(self, "syslog", value)
+
     @_builtins.property
     @pulumi.getter
     def tenants(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
@@ -10242,6 +10366,98 @@ class GatewayServicePolicyIdpArgs:
         pulumi.set(self, "profile", value)
 
 
+if not MYPY:
+    class GatewayServicePolicySkyatpArgsDict(TypedDict):
+        dns_dga_detection: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        enum: `disabled`, `default`, `standard`, `strict`
+        """
+        dns_tunnel_detection: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        enum: `disabled`, `default`, `standard`, `strict`
+        """
+        http_inspection: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        enum: `disabled`, `standard`
+        """
+        iot_device_policy: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        enum: `disabled`, `enabled`
+        """
+elif False:
+    GatewayServicePolicySkyatpArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GatewayServicePolicySkyatpArgs:
+    def __init__(__self__, *,
+                 dns_dga_detection: Optional[pulumi.Input[_builtins.str]] = None,
+                 dns_tunnel_detection: Optional[pulumi.Input[_builtins.str]] = None,
+                 http_inspection: Optional[pulumi.Input[_builtins.str]] = None,
+                 iot_device_policy: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] dns_dga_detection: enum: `disabled`, `default`, `standard`, `strict`
+        :param pulumi.Input[_builtins.str] dns_tunnel_detection: enum: `disabled`, `default`, `standard`, `strict`
+        :param pulumi.Input[_builtins.str] http_inspection: enum: `disabled`, `standard`
+        :param pulumi.Input[_builtins.str] iot_device_policy: enum: `disabled`, `enabled`
+        """
+        if dns_dga_detection is not None:
+            pulumi.set(__self__, "dns_dga_detection", dns_dga_detection)
+        if dns_tunnel_detection is not None:
+            pulumi.set(__self__, "dns_tunnel_detection", dns_tunnel_detection)
+        if http_inspection is not None:
+            pulumi.set(__self__, "http_inspection", http_inspection)
+        if iot_device_policy is not None:
+            pulumi.set(__self__, "iot_device_policy", iot_device_policy)
+
+    @_builtins.property
+    @pulumi.getter(name="dnsDgaDetection")
+    def dns_dga_detection(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        enum: `disabled`, `default`, `standard`, `strict`
+        """
+        return pulumi.get(self, "dns_dga_detection")
+
+    @dns_dga_detection.setter
+    def dns_dga_detection(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "dns_dga_detection", value)
+
+    @_builtins.property
+    @pulumi.getter(name="dnsTunnelDetection")
+    def dns_tunnel_detection(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        enum: `disabled`, `default`, `standard`, `strict`
+        """
+        return pulumi.get(self, "dns_tunnel_detection")
+
+    @dns_tunnel_detection.setter
+    def dns_tunnel_detection(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "dns_tunnel_detection", value)
+
+    @_builtins.property
+    @pulumi.getter(name="httpInspection")
+    def http_inspection(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        enum: `disabled`, `standard`
+        """
+        return pulumi.get(self, "http_inspection")
+
+    @http_inspection.setter
+    def http_inspection(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "http_inspection", value)
+
+    @_builtins.property
+    @pulumi.getter(name="iotDevicePolicy")
+    def iot_device_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        enum: `disabled`, `enabled`
+        """
+        return pulumi.get(self, "iot_device_policy")
+
+    @iot_device_policy.setter
+    def iot_device_policy(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "iot_device_policy", value)
+
+
 if not MYPY:
     class GatewayServicePolicySslProxyArgsDict(TypedDict):
         ciphers_category: NotRequired[pulumi.Input[_builtins.str]]
@@ -10287,6 +10503,42 @@ class GatewayServicePolicySslProxyArgs:
         pulumi.set(self, "enabled", value)
 
 
+if not MYPY:
+    class GatewayServicePolicySyslogArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[_builtins.bool]]
+        server_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+elif False:
+    GatewayServicePolicySyslogArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GatewayServicePolicySyslogArgs:
+    def __init__(__self__, *,
+                 enabled: Optional[pulumi.Input[_builtins.bool]] = None,
+                 server_names: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if server_names is not None:
+            pulumi.set(__self__, "server_names", server_names)
+
+    @_builtins.property
+    @pulumi.getter
+    def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "enabled", value)
+
+    @_builtins.property
+    @pulumi.getter(name="serverNames")
+    def server_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        return pulumi.get(self, "server_names")
+
+    @server_names.setter
+    def server_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "server_names", value)
+
+
 if not MYPY:
     class GatewayTunnelConfigsArgsDict(TypedDict):
         auto_provision: NotRequired[pulumi.Input['GatewayTunnelConfigsAutoProvisionArgsDict']]
@@ -12320,7 +12572,7 @@ if not MYPY:
         """
         ether_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         """
-        Can only be used under dst tags.
+        ARP / IPv6. Default is `any`
         """
         gbp_tag: NotRequired[pulumi.Input[_builtins.int]]
         """
@@ -12393,7 +12645,7 @@ class SwitchAclTagsArgs:
                  * `resource`: can only be used in `dst_tags`
                  * `static_gbp`: applying gbp tag against matching conditions
                  * `subnet`'
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ether_types: Can only be used under dst tags.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ether_types: ARP / IPv6. Default is `any`
         :param pulumi.Input[_builtins.int] gbp_tag: Required if
                  - `type`==`dynamic_gbp` (gbp_tag received from RADIUS)
                  - `type`==`gbp_resource`
@@ -12462,7 +12714,7 @@ class SwitchAclTagsArgs:
     @pulumi.getter(name="etherTypes")
     def ether_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        Can only be used under dst tags.
+        ARP / IPv6. Default is `any`
         """
         return pulumi.get(self, "ether_types")
 
@@ -13674,7 +13926,7 @@ if not MYPY:
         """
         allow_dhcpd: NotRequired[pulumi.Input[_builtins.bool]]
         """
-        If DHCP snooping is enabled, whether DHCP server is allowed on the interfaces with. All the interfaces from port configs using this port usage are effected. Please notice that allow_dhcpd is a tri_state. When it is not defined, it means using the system's default setting which depends on whether the port is an access or trunk port.
+        Controls whether DHCP server traffic is allowed on ports using this configuration if DHCP snooping is enabled. This is a tri-state setting; true: ports become trusted ports allowing DHCP server traffic, false: ports become untrusted blocking DHCP server traffic, undefined: use system defaults (access ports default to untrusted, trunk ports default to trusted).
         """
         allow_multiple_supplicants: NotRequired[pulumi.Input[_builtins.bool]]
         bypass_auth_when_server_down: NotRequired[pulumi.Input[_builtins.bool]]
@@ -13843,7 +14095,7 @@ class SwitchLocalPortConfigArgs:
         """
         :param pulumi.Input[_builtins.str] usage: Port usage name.
         :param pulumi.Input[_builtins.bool] all_networks: Only if `mode`==`trunk` whether to trunk all network/vlans
-        :param pulumi.Input[_builtins.bool] allow_dhcpd: If DHCP snooping is enabled, whether DHCP server is allowed on the interfaces with. All the interfaces from port configs using this port usage are effected. Please notice that allow_dhcpd is a tri_state. When it is not defined, it means using the system's default setting which depends on whether the port is an access or trunk port.
+        :param pulumi.Input[_builtins.bool] allow_dhcpd: Controls whether DHCP server traffic is allowed on ports using this configuration if DHCP snooping is enabled. This is a tri-state setting; true: ports become trusted ports allowing DHCP server traffic, false: ports become untrusted blocking DHCP server traffic, undefined: use system defaults (access ports default to untrusted, trunk ports default to trusted).
         :param pulumi.Input[_builtins.bool] bypass_auth_when_server_down: Only if `port_auth`==`dot1x` bypass auth for known clients if set to true when RADIUS server is down
         :param pulumi.Input[_builtins.bool] bypass_auth_when_server_down_for_unknown_client: Only if `port_auth`=`dot1x` bypass auth for all (including unknown clients) if set to true when RADIUS server is down
         :param pulumi.Input[_builtins.bool] disable_autoneg: Only if `mode`!=`dynamic` if speed and duplex are specified, whether to disable autonegotiation
@@ -13976,7 +14228,7 @@ class SwitchLocalPortConfigArgs:
     @pulumi.getter(name="allowDhcpd")
     def allow_dhcpd(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        If DHCP snooping is enabled, whether DHCP server is allowed on the interfaces with. All the interfaces from port configs using this port usage are effected. Please notice that allow_dhcpd is a tri_state. When it is not defined, it means using the system's default setting which depends on whether the port is an access or trunk port.
+        Controls whether DHCP server traffic is allowed on ports using this configuration if DHCP snooping is enabled. This is a tri-state setting; true: ports become trusted ports allowing DHCP server traffic, false: ports become untrusted blocking DHCP server traffic, undefined: use system defaults (access ports default to untrusted, trunk ports default to trusted).
         """
         return pulumi.get(self, "allow_dhcpd")
 
@@ -15958,7 +16210,7 @@ if not MYPY:
         """
         allow_dhcpd: NotRequired[pulumi.Input[_builtins.bool]]
         """
-        Only if `mode`!=`dynamic`. If DHCP snooping is enabled, whether DHCP server is allowed on the interfaces with. All the interfaces from port configs using this port usage are effected. Please notice that allow_dhcpd is a tri_state. When it is not defined, it means using the system's default setting which depends on whether the port is an access or trunk port.
+        Only applies when `mode`!=`dynamic`. Controls whether DHCP server traffic is allowed on ports using this configuration if DHCP snooping is enabled. This is a tri-state setting; true: ports become trusted ports allowing DHCP server traffic, false: ports become untrusted blocking DHCP server traffic, undefined: use system defaults (access ports default to untrusted, trunk ports default to trusted).
         """
         allow_multiple_supplicants: NotRequired[pulumi.Input[_builtins.bool]]
         """
@@ -15972,6 +16224,10 @@ if not MYPY:
         """
         Only if `mode`!=`dynamic` and `port_auth`=`dot1x`. Bypass auth for all (including unknown clients) if set to true when RADIUS server is down
         """
+        bypass_auth_when_server_down_for_voip: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        Only if `mode`!=`dynamic` and `port_auth`==`dot1x`. Bypass auth for VOIP if set to true when RADIUS server is down
+        """
         community_vlan_id: NotRequired[pulumi.Input[_builtins.int]]
         """
         Only if `mode`!=`dynamic`. To be used together with `isolation` under networks. Signaling that this port connects to the networks isolated but wired clients belong to the same community can talk to each other
@@ -16052,6 +16308,10 @@ if not MYPY:
         """
         Only if `mode`!=`dynamic`. Whether PoE capabilities are disabled for a port
         """
+        poe_priority: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        PoE priority. enum: `low`, `high`
+        """
         port_auth: NotRequired[pulumi.Input[_builtins.str]]
         """
         Only if `mode`!=`dynamic`. If dot1x is desired, set to dot1x. enum: `dot1x`
@@ -16127,6 +16387,7 @@ class SwitchPortUsagesArgs:
                  allow_multiple_supplicants: Optional[pulumi.Input[_builtins.bool]] = None,
                  bypass_auth_when_server_down: Optional[pulumi.Input[_builtins.bool]] = None,
                  bypass_auth_when_server_down_for_unknown_client: Optional[pulumi.Input[_builtins.bool]] = None,
+                 bypass_auth_when_server_down_for_voip: Optional[pulumi.Input[_builtins.bool]] = None,
                  community_vlan_id: Optional[pulumi.Input[_builtins.int]] = None,
                  description: Optional[pulumi.Input[_builtins.str]] = None,
                  disable_autoneg: Optional[pulumi.Input[_builtins.bool]] = None,
@@ -16147,6 +16408,7 @@ class SwitchPortUsagesArgs:
                  networks: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  persist_mac: Optional[pulumi.Input[_builtins.bool]] = None,
                  poe_disabled: Optional[pulumi.Input[_builtins.bool]] = None,
+                 poe_priority: Optional[pulumi.Input[_builtins.str]] = None,
                  port_auth: Optional[pulumi.Input[_builtins.str]] = None,
                  port_network: Optional[pulumi.Input[_builtins.str]] = None,
                  reauth_interval: Optional[pulumi.Input[_builtins.str]] = None,
@@ -16165,10 +16427,11 @@ class SwitchPortUsagesArgs:
                  voip_network: Optional[pulumi.Input[_builtins.str]] = None):
         """
         :param pulumi.Input[_builtins.bool] all_networks: Only if `mode`==`trunk`. Whether to trunk all network/vlans
-        :param pulumi.Input[_builtins.bool] allow_dhcpd: Only if `mode`!=`dynamic`. If DHCP snooping is enabled, whether DHCP server is allowed on the interfaces with. All the interfaces from port configs using this port usage are effected. Please notice that allow_dhcpd is a tri_state. When it is not defined, it means using the system's default setting which depends on whether the port is an access or trunk port.
+        :param pulumi.Input[_builtins.bool] allow_dhcpd: Only applies when `mode`!=`dynamic`. Controls whether DHCP server traffic is allowed on ports using this configuration if DHCP snooping is enabled. This is a tri-state setting; true: ports become trusted ports allowing DHCP server traffic, false: ports become untrusted blocking DHCP server traffic, undefined: use system defaults (access ports default to untrusted, trunk ports default to trusted).
         :param pulumi.Input[_builtins.bool] allow_multiple_supplicants: Only if `mode`!=`dynamic`
         :param pulumi.Input[_builtins.bool] bypass_auth_when_server_down: Only if `mode`!=`dynamic` and `port_auth`==`dot1x`. Bypass auth for known clients if set to true when RADIUS server is down
         :param pulumi.Input[_builtins.bool] bypass_auth_when_server_down_for_unknown_client: Only if `mode`!=`dynamic` and `port_auth`=`dot1x`. Bypass auth for all (including unknown clients) if set to true when RADIUS server is down
+        :param pulumi.Input[_builtins.bool] bypass_auth_when_server_down_for_voip: Only if `mode`!=`dynamic` and `port_auth`==`dot1x`. Bypass auth for VOIP if set to true when RADIUS server is down
         :param pulumi.Input[_builtins.int] community_vlan_id: Only if `mode`!=`dynamic`. To be used together with `isolation` under networks. Signaling that this port connects to the networks isolated but wired clients belong to the same community can talk to each other
         :param pulumi.Input[_builtins.str] description: Only if `mode`!=`dynamic`
         :param pulumi.Input[_builtins.bool] disable_autoneg: Only if `mode`!=`dynamic`. If speed and duplex are specified, whether to disable autonegotiation
@@ -16189,6 +16452,7 @@ class SwitchPortUsagesArgs:
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] networks: Only if `mode`==`trunk`, the list of network/vlans
         :param pulumi.Input[_builtins.bool] persist_mac: Only if `mode`==`access` and `port_auth`!=`dot1x`. Whether the port should retain dynamically learned MAC addresses
         :param pulumi.Input[_builtins.bool] poe_disabled: Only if `mode`!=`dynamic`. Whether PoE capabilities are disabled for a port
+        :param pulumi.Input[_builtins.str] poe_priority: PoE priority. enum: `low`, `high`
         :param pulumi.Input[_builtins.str] port_auth: Only if `mode`!=`dynamic`. If dot1x is desired, set to dot1x. enum: `dot1x`
         :param pulumi.Input[_builtins.str] port_network: Only if `mode`!=`dynamic`. Native network/vlan for untagged traffic
         :param pulumi.Input[_builtins.str] reauth_interval: Only if `mode`!=`dynamic` and `port_auth`=`dot1x` reauthentication interval range between 10 and 65535 (default: 3600)
@@ -16216,6 +16480,8 @@ class SwitchPortUsagesArgs:
             pulumi.set(__self__, "bypass_auth_when_server_down", bypass_auth_when_server_down)
         if bypass_auth_when_server_down_for_unknown_client is not None:
             pulumi.set(__self__, "bypass_auth_when_server_down_for_unknown_client", bypass_auth_when_server_down_for_unknown_client)
+        if bypass_auth_when_server_down_for_voip is not None:
+            pulumi.set(__self__, "bypass_auth_when_server_down_for_voip", bypass_auth_when_server_down_for_voip)
         if community_vlan_id is not None:
             pulumi.set(__self__, "community_vlan_id", community_vlan_id)
         if description is not None:
@@ -16256,6 +16522,8 @@ class SwitchPortUsagesArgs:
             pulumi.set(__self__, "persist_mac", persist_mac)
         if poe_disabled is not None:
             pulumi.set(__self__, "poe_disabled", poe_disabled)
+        if poe_priority is not None:
+            pulumi.set(__self__, "poe_priority", poe_priority)
         if port_auth is not None:
             pulumi.set(__self__, "port_auth", port_auth)
         if port_network is not None:
@@ -16305,7 +16573,7 @@ class SwitchPortUsagesArgs:
     @pulumi.getter(name="allowDhcpd")
     def allow_dhcpd(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        Only if `mode`!=`dynamic`. If DHCP snooping is enabled, whether DHCP server is allowed on the interfaces with. All the interfaces from port configs using this port usage are effected. Please notice that allow_dhcpd is a tri_state. When it is not defined, it means using the system's default setting which depends on whether the port is an access or trunk port.
+        Only applies when `mode`!=`dynamic`. Controls whether DHCP server traffic is allowed on ports using this configuration if DHCP snooping is enabled. This is a tri-state setting; true: ports become trusted ports allowing DHCP server traffic, false: ports become untrusted blocking DHCP server traffic, undefined: use system defaults (access ports default to untrusted, trunk ports default to trusted).
         """
         return pulumi.get(self, "allow_dhcpd")
 
@@ -16349,6 +16617,18 @@ class SwitchPortUsagesArgs:
     def bypass_auth_when_server_down_for_unknown_client(self, value: Optional[pulumi.Input[_builtins.bool]]):
         pulumi.set(self, "bypass_auth_when_server_down_for_unknown_client", value)
 
+    @_builtins.property
+    @pulumi.getter(name="bypassAuthWhenServerDownForVoip")
+    def bypass_auth_when_server_down_for_voip(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Only if `mode`!=`dynamic` and `port_auth`==`dot1x`. Bypass auth for VOIP if set to true when RADIUS server is down
+        """
+        return pulumi.get(self, "bypass_auth_when_server_down_for_voip")
+
+    @bypass_auth_when_server_down_for_voip.setter
+    def bypass_auth_when_server_down_for_voip(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "bypass_auth_when_server_down_for_voip", value)
+
     @_builtins.property
     @pulumi.getter(name="communityVlanId")
     def community_vlan_id(self) -> Optional[pulumi.Input[_builtins.int]]:
@@ -16589,6 +16869,18 @@ class SwitchPortUsagesArgs:
     def poe_disabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
         pulumi.set(self, "poe_disabled", value)
 
+    @_builtins.property
+    @pulumi.getter(name="poePriority")
+    def poe_priority(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        PoE priority. enum: `low`, `high`
+        """
+        return pulumi.get(self, "poe_priority")
+
+    @poe_priority.setter
+    def poe_priority(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "poe_priority", value)
+
     @_builtins.property
     @pulumi.getter(name="portAuth")
     def port_auth(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -16786,7 +17078,7 @@ if not MYPY:
     class SwitchPortUsagesRuleArgsDict(TypedDict):
         src: pulumi.Input[_builtins.str]
         """
-        enum: `link_peermac`, `lldp_chassis_id`, `lldp_hardware_revision`, `lldp_manufacturer_name`, `lldp_oui`, `lldp_serial_number`, `lldp_system_name`, `radius_dynamicfilter`, `radius_usermac`, `radius_username`
+        enum: `link_peermac`, `lldp_chassis_id`, `lldp_hardware_revision`, `lldp_manufacturer_name`, `lldp_oui`, `lldp_serial_number`, `lldp_system_description`, `lldp_system_name`, `radius_dynamicfilter`, `radius_usermac`, `radius_username`
         """
         equals: NotRequired[pulumi.Input[_builtins.str]]
         equals_anies: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
@@ -16815,7 +17107,7 @@ class SwitchPortUsagesRuleArgs:
                  expression: Optional[pulumi.Input[_builtins.str]] = None,
                  usage: Optional[pulumi.Input[_builtins.str]] = None):
         """
-        :param pulumi.Input[_builtins.str] src: enum: `link_peermac`, `lldp_chassis_id`, `lldp_hardware_revision`, `lldp_manufacturer_name`, `lldp_oui`, `lldp_serial_number`, `lldp_system_name`, `radius_dynamicfilter`, `radius_usermac`, `radius_username`
+        :param pulumi.Input[_builtins.str] src: enum: `link_peermac`, `lldp_chassis_id`, `lldp_hardware_revision`, `lldp_manufacturer_name`, `lldp_oui`, `lldp_serial_number`, `lldp_system_description`, `lldp_system_name`, `radius_dynamicfilter`, `radius_usermac`, `radius_username`
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] equals_anies: Use `equals_any` to match any item in a list
         :param pulumi.Input[_builtins.str] expression: "[0:3]":"abcdef" > "abc"
                "split(.)[1]": "a.b.c" > "b"
@@ -16836,7 +17128,7 @@ class SwitchPortUsagesRuleArgs:
     @pulumi.getter
     def src(self) -> pulumi.Input[_builtins.str]:
         """
-        enum: `link_peermac`, `lldp_chassis_id`, `lldp_hardware_revision`, `lldp_manufacturer_name`, `lldp_oui`, `lldp_serial_number`, `lldp_system_name`, `radius_dynamicfilter`, `radius_usermac`, `radius_username`
+        enum: `link_peermac`, `lldp_chassis_id`, `lldp_hardware_revision`, `lldp_manufacturer_name`, `lldp_oui`, `lldp_serial_number`, `lldp_system_description`, `lldp_system_name`, `radius_dynamicfilter`, `radius_usermac`, `radius_username`
         """
         return pulumi.get(self, "src")