# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins as _builtins
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities
from . import outputs

__all__ = [
    'ApplianceRadioSettingsFiveGhzSettings',
    'ApplianceRadioSettingsTwoFourGhzSettings',
    'ApplianceUplinksSettingsInterfaces',
    'ApplianceUplinksSettingsInterfacesWan1',
    'ApplianceUplinksSettingsInterfacesWan1Pppoe',
    'ApplianceUplinksSettingsInterfacesWan1PppoeAuthentication',
    'ApplianceUplinksSettingsInterfacesWan1Svis',
    'ApplianceUplinksSettingsInterfacesWan1SvisIpv4',
    'ApplianceUplinksSettingsInterfacesWan1SvisIpv4Nameservers',
    'ApplianceUplinksSettingsInterfacesWan1SvisIpv6',
    'ApplianceUplinksSettingsInterfacesWan1SvisIpv6Nameservers',
    'ApplianceUplinksSettingsInterfacesWan1VlanTagging',
    'ApplianceUplinksSettingsInterfacesWan2',
    'ApplianceUplinksSettingsInterfacesWan2Pppoe',
    'ApplianceUplinksSettingsInterfacesWan2PppoeAuthentication',
    'ApplianceUplinksSettingsInterfacesWan2Svis',
    'ApplianceUplinksSettingsInterfacesWan2SvisIpv4',
    'ApplianceUplinksSettingsInterfacesWan2SvisIpv4Nameservers',
    'ApplianceUplinksSettingsInterfacesWan2SvisIpv6',
    'ApplianceUplinksSettingsInterfacesWan2SvisIpv6Nameservers',
    'ApplianceUplinksSettingsInterfacesWan2VlanTagging',
    'ApplianceVmxAuthenticationTokenItem',
    'BlinkLedsItem',
    'BlinkLedsParameters',
    'CameraCustomAnalyticsParameter',
    'CameraGenerateSnapshotParameters',
    'CameraSenseAudioDetection',
    'CameraWirelessProfilesIds',
    'CellularGatewayLanFixedIpAssignment',
    'CellularGatewayLanReservedIpRange',
    'CellularGatewayPortForwardingRulesRule',
    'CellularSimsSim',
    'CellularSimsSimApn',
    'CellularSimsSimApnAuthentication',
    'CellularSimsSimFailover',
    'LiveToolsArpTableCallback',
    'LiveToolsArpTableCallbackHttpServer',
    'LiveToolsArpTableCallbackPayloadTemplate',
    'LiveToolsArpTableEntry',
    'LiveToolsArpTableRequest',
    'LiveToolsCableCallback',
    'LiveToolsCableCallbackHttpServer',
    'LiveToolsCableCallbackPayloadTemplate',
    'LiveToolsCableRequest',
    'LiveToolsCableResult',
    'LiveToolsCableResultPair',
    'LiveToolsPingDeviceItem',
    'LiveToolsPingDeviceItemCallback',
    'LiveToolsPingDeviceItemRequest',
    'LiveToolsPingDeviceParameters',
    'LiveToolsPingDeviceParametersCallback',
    'LiveToolsPingDeviceParametersCallbackHttpServer',
    'LiveToolsPingDeviceParametersCallbackPayloadTemplate',
    'LiveToolsPingItem',
    'LiveToolsPingItemCallback',
    'LiveToolsPingItemRequest',
    'LiveToolsPingParameters',
    'LiveToolsPingParametersCallback',
    'LiveToolsPingParametersCallbackHttpServer',
    'LiveToolsPingParametersCallbackPayloadTemplate',
    'LiveToolsThroughputTestCallback',
    'LiveToolsThroughputTestCallbackHttpServer',
    'LiveToolsThroughputTestCallbackPayloadTemplate',
    'LiveToolsThroughputTestRequest',
    'LiveToolsThroughputTestResult',
    'LiveToolsThroughputTestResultSpeeds',
    'LiveToolsWakeOnLanCallback',
    'LiveToolsWakeOnLanCallbackHttpServer',
    'LiveToolsWakeOnLanCallbackPayloadTemplate',
    'LiveToolsWakeOnLanRequest',
    'ManagementInterfaceDdnsHostnames',
    'ManagementInterfaceWan1',
    'ManagementInterfaceWan2',
    'SensorRelationshipsLivestream',
    'SensorRelationshipsLivestreamRelatedDevice',
    'SensorRelationshipsLivestreamRequest',
    'SensorRelationshipsLivestreamRequestRelatedDevice',
    'SwitchPortsCycleItem',
    'SwitchPortsCycleParameters',
    'SwitchPortsMirror',
    'SwitchPortsModule',
    'SwitchPortsProfile',
    'SwitchRoutingInterfacesDhcpDhcpOption',
    'SwitchRoutingInterfacesDhcpFixedIpAssignment',
    'SwitchRoutingInterfacesDhcpReservedIpRange',
    'SwitchRoutingInterfacesIpv6',
    'SwitchRoutingInterfacesOspfSettings',
    'SwitchRoutingInterfacesOspfV3',
    'WirelessAlternateManagementInterfaceIpv6Item',
    'WirelessAlternateManagementInterfaceIpv6ItemAddress',
    'WirelessAlternateManagementInterfaceIpv6ItemAddressNameservers',
    'WirelessAlternateManagementInterfaceIpv6Parameters',
    'WirelessAlternateManagementInterfaceIpv6ParametersAddress',
    'WirelessAlternateManagementInterfaceIpv6ParametersAddressNameservers',
    'WirelessRadioSettingsFiveGhzSettings',
    'WirelessRadioSettingsTwoFourGhzSettings',
    'BaseDetail',
    'GetAppliancePerformanceItemResult',
    'GetApplianceRadioSettingsItemResult',
    'GetApplianceRadioSettingsItemFiveGhzSettingsResult',
    'GetApplianceRadioSettingsItemTwoFourGhzSettingsResult',
    'GetApplianceUplinksSettingsItemResult',
    'GetApplianceUplinksSettingsItemInterfacesResult',
    'GetApplianceUplinksSettingsItemInterfacesWan1Result',
    'GetApplianceUplinksSettingsItemInterfacesWan1PppoeResult',
    'GetApplianceUplinksSettingsItemInterfacesWan1PppoeAuthenticationResult',
    'GetApplianceUplinksSettingsItemInterfacesWan1SvisResult',
    'GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv4Result',
    'GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv4NameserversResult',
    'GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv6Result',
    'GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv6NameserversResult',
    'GetApplianceUplinksSettingsItemInterfacesWan1VlanTaggingResult',
    'GetApplianceUplinksSettingsItemInterfacesWan2Result',
    'GetApplianceUplinksSettingsItemInterfacesWan2PppoeResult',
    'GetApplianceUplinksSettingsItemInterfacesWan2PppoeAuthenticationResult',
    'GetApplianceUplinksSettingsItemInterfacesWan2SvisResult',
    'GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv4Result',
    'GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv4NameserversResult',
    'GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv6Result',
    'GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv6NameserversResult',
    'GetApplianceUplinksSettingsItemInterfacesWan2VlanTaggingResult',
    'GetCameraAnalyticsLiveItemResult',
    'GetCameraAnalyticsLiveItemZonesResult',
    'GetCameraAnalyticsLiveItemZonesStatus0Result',
    'GetCameraCustomAnalyticsItemResult',
    'GetCameraCustomAnalyticsItemParameterResult',
    'GetCameraQualityAndRetentionItemResult',
    'GetCameraSenseItemResult',
    'GetCameraSenseItemAudioDetectionResult',
    'GetCameraVideoLinkItemResult',
    'GetCameraVideoSettingsItemResult',
    'GetCameraWirelessProfilesItemResult',
    'GetCameraWirelessProfilesItemIdsResult',
    'GetCellularGatewayLanItemResult',
    'GetCellularGatewayLanItemFixedIpAssignmentResult',
    'GetCellularGatewayLanItemReservedIpRangeResult',
    'GetCellularGatewayPortForwardingRulesItemResult',
    'GetCellularGatewayPortForwardingRulesItemRuleResult',
    'GetCellularSimsItemResult',
    'GetCellularSimsItemSimResult',
    'GetCellularSimsItemSimApnResult',
    'GetCellularSimsItemSimApnAuthenticationResult',
    'GetLiveToolsArpTableItemResult',
    'GetLiveToolsArpTableItemEntryResult',
    'GetLiveToolsArpTableItemRequestResult',
    'GetLiveToolsCableTestItemResult',
    'GetLiveToolsCableTestItemRequestResult',
    'GetLiveToolsCableTestItemResultResult',
    'GetLiveToolsCableTestItemResultPairResult',
    'GetLiveToolsPingDeviceItemResult',
    'GetLiveToolsPingDeviceItemCallbackResult',
    'GetLiveToolsPingDeviceItemRequestResult',
    'GetLiveToolsPingDeviceItemResultsResult',
    'GetLiveToolsPingDeviceItemResultsLatenciesResult',
    'GetLiveToolsPingDeviceItemResultsLossResult',
    'GetLiveToolsPingDeviceItemResultsReplyResult',
    'GetLiveToolsPingItemResult',
    'GetLiveToolsPingItemRequestResult',
    'GetLiveToolsPingItemResultsResult',
    'GetLiveToolsPingItemResultsLatenciesResult',
    'GetLiveToolsPingItemResultsLossResult',
    'GetLiveToolsPingItemResultsReplyResult',
    'GetLiveToolsThroughputTestItemResult',
    'GetLiveToolsThroughputTestItemRequestResult',
    'GetLiveToolsThroughputTestItemResultResult',
    'GetLiveToolsThroughputTestItemResultSpeedsResult',
    'GetLiveToolsWakeOnLanItemResult',
    'GetLiveToolsWakeOnLanItemRequestResult',
    'GetLldpCdpItemResult',
    'GetLldpCdpItemPortsResult',
    'GetLldpCdpItemPortsStatus12Result',
    'GetLldpCdpItemPortsStatus12CdpResult',
    'GetLldpCdpItemPortsStatus12LldpResult',
    'GetLldpCdpItemPortsStatus8Result',
    'GetLldpCdpItemPortsStatus8CdpResult',
    'GetManagementInterfaceItemResult',
    'GetManagementInterfaceItemDdnsHostnamesResult',
    'GetManagementInterfaceItemWan1Result',
    'GetManagementInterfaceItemWan2Result',
    'GetSensorRelationshipsItemResult',
    'GetSensorRelationshipsItemLivestreamResult',
    'GetSensorRelationshipsItemLivestreamRelatedDeviceResult',
    'GetSwitchPortsItemResult',
    'GetSwitchPortsItemMirrorResult',
    'GetSwitchPortsItemModuleResult',
    'GetSwitchPortsItemProfileResult',
    'GetSwitchPortsStatusesItemResult',
    'GetSwitchPortsStatusesItemCdpResult',
    'GetSwitchPortsStatusesItemLldpResult',
    'GetSwitchPortsStatusesItemSecurePortResult',
    'GetSwitchPortsStatusesItemSecurePortConfigOverridesResult',
    'GetSwitchPortsStatusesItemSpanningTreeResult',
    'GetSwitchPortsStatusesItemTrafficInKbpsResult',
    'GetSwitchPortsStatusesItemUsageInKbResult',
    'GetSwitchRoutingInterfacesDhcpItemResult',
    'GetSwitchRoutingInterfacesDhcpItemDhcpOptionResult',
    'GetSwitchRoutingInterfacesDhcpItemFixedIpAssignmentResult',
    'GetSwitchRoutingInterfacesDhcpItemReservedIpRangeResult',
    'GetSwitchRoutingInterfacesItemResult',
    'GetSwitchRoutingInterfacesItemIpv6Result',
    'GetSwitchRoutingInterfacesItemOspfSettingsResult',
    'GetSwitchRoutingInterfacesItemOspfV3Result',
    'GetSwitchRoutingStaticRoutesItemResult',
    'GetSwitchWarmSpareItemResult',
    'GetWirelessBluetoothSettingsItemResult',
    'GetWirelessConnectionStatsItemResult',
    'GetWirelessConnectionStatsItemConnectionStatsResult',
    'GetWirelessLatencyStatsItemResult',
    'GetWirelessLatencyStatsItemLatencyStatsResult',
    'GetWirelessLatencyStatsItemLatencyStatsBackgroundTrafficResult',
    'GetWirelessLatencyStatsItemLatencyStatsBackgroundTrafficRawDistributionResult',
    'GetWirelessRadioSettingsItemResult',
    'GetWirelessRadioSettingsItemFiveGhzSettingsResult',
    'GetWirelessRadioSettingsItemTwoFourGhzSettingsResult',
    'GetWirelessStatusItemResult',
    'GetWirelessStatusItemBasicServiceSetResult',
]

@pulumi.output_type
class ApplianceRadioSettingsFiveGhzSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "channelWidth":
            suggest = "channel_width"
        elif key == "targetPower":
            suggest = "target_power"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceRadioSettingsFiveGhzSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceRadioSettingsFiveGhzSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceRadioSettingsFiveGhzSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 channel: Optional[_builtins.int] = None,
                 channel_width: Optional[_builtins.int] = None,
                 target_power: Optional[_builtins.int] = None):
        """
        :param _builtins.int channel: Manual channel for 5 GHz
        :param _builtins.int channel_width: Manual channel width for 5 GHz
        :param _builtins.int target_power: Manual target power for 5 GHz
        """
        if channel is not None:
            pulumi.set(__self__, "channel", channel)
        if channel_width is not None:
            pulumi.set(__self__, "channel_width", channel_width)
        if target_power is not None:
            pulumi.set(__self__, "target_power", target_power)

    @_builtins.property
    @pulumi.getter
    def channel(self) -> Optional[_builtins.int]:
        """
        Manual channel for 5 GHz
        """
        return pulumi.get(self, "channel")

    @_builtins.property
    @pulumi.getter(name="channelWidth")
    def channel_width(self) -> Optional[_builtins.int]:
        """
        Manual channel width for 5 GHz
        """
        return pulumi.get(self, "channel_width")

    @_builtins.property
    @pulumi.getter(name="targetPower")
    def target_power(self) -> Optional[_builtins.int]:
        """
        Manual target power for 5 GHz
        """
        return pulumi.get(self, "target_power")


@pulumi.output_type
class ApplianceRadioSettingsTwoFourGhzSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetPower":
            suggest = "target_power"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceRadioSettingsTwoFourGhzSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceRadioSettingsTwoFourGhzSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceRadioSettingsTwoFourGhzSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 channel: Optional[_builtins.int] = None,
                 target_power: Optional[_builtins.int] = None):
        """
        :param _builtins.int channel: Manual channel for 2.4 GHz
        :param _builtins.int target_power: Manual target power for 2.4 GHz
        """
        if channel is not None:
            pulumi.set(__self__, "channel", channel)
        if target_power is not None:
            pulumi.set(__self__, "target_power", target_power)

    @_builtins.property
    @pulumi.getter
    def channel(self) -> Optional[_builtins.int]:
        """
        Manual channel for 2.4 GHz
        """
        return pulumi.get(self, "channel")

    @_builtins.property
    @pulumi.getter(name="targetPower")
    def target_power(self) -> Optional[_builtins.int]:
        """
        Manual target power for 2.4 GHz
        """
        return pulumi.get(self, "target_power")


@pulumi.output_type
class ApplianceUplinksSettingsInterfaces(dict):
    def __init__(__self__, *,
                 wan1: Optional['outputs.ApplianceUplinksSettingsInterfacesWan1'] = None,
                 wan2: Optional['outputs.ApplianceUplinksSettingsInterfacesWan2'] = None):
        """
        :param 'ApplianceUplinksSettingsInterfacesWan1Args' wan1: WAN 1 settings.
        :param 'ApplianceUplinksSettingsInterfacesWan2Args' wan2: WAN 2 settings.
        """
        if wan1 is not None:
            pulumi.set(__self__, "wan1", wan1)
        if wan2 is not None:
            pulumi.set(__self__, "wan2", wan2)

    @_builtins.property
    @pulumi.getter
    def wan1(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan1']:
        """
        WAN 1 settings.
        """
        return pulumi.get(self, "wan1")

    @_builtins.property
    @pulumi.getter
    def wan2(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan2']:
        """
        WAN 2 settings.
        """
        return pulumi.get(self, "wan2")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan1(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vlanTagging":
            suggest = "vlan_tagging"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceUplinksSettingsInterfacesWan1. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceUplinksSettingsInterfacesWan1.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceUplinksSettingsInterfacesWan1.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None,
                 pppoe: Optional['outputs.ApplianceUplinksSettingsInterfacesWan1Pppoe'] = None,
                 svis: Optional['outputs.ApplianceUplinksSettingsInterfacesWan1Svis'] = None,
                 vlan_tagging: Optional['outputs.ApplianceUplinksSettingsInterfacesWan1VlanTagging'] = None):
        """
        :param _builtins.bool enabled: Enable or disable the interface.
        :param 'ApplianceUplinksSettingsInterfacesWan1PppoeArgs' pppoe: Configuration options for PPPoE.
        :param 'ApplianceUplinksSettingsInterfacesWan1SvisArgs' svis: SVI settings by protocol.
        :param 'ApplianceUplinksSettingsInterfacesWan1VlanTaggingArgs' vlan_tagging: VLAN tagging settings.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if pppoe is not None:
            pulumi.set(__self__, "pppoe", pppoe)
        if svis is not None:
            pulumi.set(__self__, "svis", svis)
        if vlan_tagging is not None:
            pulumi.set(__self__, "vlan_tagging", vlan_tagging)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Enable or disable the interface.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def pppoe(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan1Pppoe']:
        """
        Configuration options for PPPoE.
        """
        return pulumi.get(self, "pppoe")

    @_builtins.property
    @pulumi.getter
    def svis(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan1Svis']:
        """
        SVI settings by protocol.
        """
        return pulumi.get(self, "svis")

    @_builtins.property
    @pulumi.getter(name="vlanTagging")
    def vlan_tagging(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan1VlanTagging']:
        """
        VLAN tagging settings.
        """
        return pulumi.get(self, "vlan_tagging")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan1Pppoe(dict):
    def __init__(__self__, *,
                 authentication: Optional['outputs.ApplianceUplinksSettingsInterfacesWan1PppoeAuthentication'] = None,
                 enabled: Optional[_builtins.bool] = None):
        """
        :param 'ApplianceUplinksSettingsInterfacesWan1PppoeAuthenticationArgs' authentication: Settings for PPPoE Authentication.
        :param _builtins.bool enabled: Whether PPPoE is enabled.
        """
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def authentication(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan1PppoeAuthentication']:
        """
        Settings for PPPoE Authentication.
        """
        return pulumi.get(self, "authentication")

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Whether PPPoE is enabled.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan1PppoeAuthentication(dict):
    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None,
                 password: Optional[_builtins.str] = None,
                 username: Optional[_builtins.str] = None):
        """
        :param _builtins.bool enabled: Whether PPPoE authentication is enabled.
        :param _builtins.str password: Password for PPPoE authentication. This parameter is not returned.
        :param _builtins.str username: Username for PPPoE authentication.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Whether PPPoE authentication is enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[_builtins.str]:
        """
        Password for PPPoE authentication. This parameter is not returned.
        """
        return pulumi.get(self, "password")

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[_builtins.str]:
        """
        Username for PPPoE authentication.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan1Svis(dict):
    def __init__(__self__, *,
                 ipv4: Optional['outputs.ApplianceUplinksSettingsInterfacesWan1SvisIpv4'] = None,
                 ipv6: Optional['outputs.ApplianceUplinksSettingsInterfacesWan1SvisIpv6'] = None):
        """
        :param 'ApplianceUplinksSettingsInterfacesWan1SvisIpv4Args' ipv4: IPv4 settings for static/dynamic mode.
        :param 'ApplianceUplinksSettingsInterfacesWan1SvisIpv6Args' ipv6: IPv6 settings for static/dynamic mode.
        """
        if ipv4 is not None:
            pulumi.set(__self__, "ipv4", ipv4)
        if ipv6 is not None:
            pulumi.set(__self__, "ipv6", ipv6)

    @_builtins.property
    @pulumi.getter
    def ipv4(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan1SvisIpv4']:
        """
        IPv4 settings for static/dynamic mode.
        """
        return pulumi.get(self, "ipv4")

    @_builtins.property
    @pulumi.getter
    def ipv6(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan1SvisIpv6']:
        """
        IPv6 settings for static/dynamic mode.
        """
        return pulumi.get(self, "ipv6")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan1SvisIpv4(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "assignmentMode":
            suggest = "assignment_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceUplinksSettingsInterfacesWan1SvisIpv4. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceUplinksSettingsInterfacesWan1SvisIpv4.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceUplinksSettingsInterfacesWan1SvisIpv4.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[_builtins.str] = None,
                 assignment_mode: Optional[_builtins.str] = None,
                 gateway: Optional[_builtins.str] = None,
                 nameservers: Optional['outputs.ApplianceUplinksSettingsInterfacesWan1SvisIpv4Nameservers'] = None):
        """
        :param _builtins.str address: IP address and subnet mask when in static mode.
        :param _builtins.str assignment_mode: The assignment mode for this SVI. Applies only when PPPoE is disabled.
        :param _builtins.str gateway: Gateway IP address when in static mode.
        :param 'ApplianceUplinksSettingsInterfacesWan1SvisIpv4NameserversArgs' nameservers: The nameserver settings for this SVI.
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if assignment_mode is not None:
            pulumi.set(__self__, "assignment_mode", assignment_mode)
        if gateway is not None:
            pulumi.set(__self__, "gateway", gateway)
        if nameservers is not None:
            pulumi.set(__self__, "nameservers", nameservers)

    @_builtins.property
    @pulumi.getter
    def address(self) -> Optional[_builtins.str]:
        """
        IP address and subnet mask when in static mode.
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> Optional[_builtins.str]:
        """
        The assignment mode for this SVI. Applies only when PPPoE is disabled.
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> Optional[_builtins.str]:
        """
        Gateway IP address when in static mode.
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def nameservers(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan1SvisIpv4Nameservers']:
        """
        The nameserver settings for this SVI.
        """
        return pulumi.get(self, "nameservers")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan1SvisIpv4Nameservers(dict):
    def __init__(__self__, *,
                 addresses: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] addresses: Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence[_builtins.str]]:
        """
        Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan1SvisIpv6(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "assignmentMode":
            suggest = "assignment_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceUplinksSettingsInterfacesWan1SvisIpv6. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceUplinksSettingsInterfacesWan1SvisIpv6.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceUplinksSettingsInterfacesWan1SvisIpv6.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[_builtins.str] = None,
                 assignment_mode: Optional[_builtins.str] = None,
                 gateway: Optional[_builtins.str] = None,
                 nameservers: Optional['outputs.ApplianceUplinksSettingsInterfacesWan1SvisIpv6Nameservers'] = None):
        """
        :param _builtins.str address: Static address that will override the one(s) received by SLAAC.
        :param _builtins.str assignment_mode: The assignment mode for this SVI. Applies only when PPPoE is disabled.
        :param _builtins.str gateway: Static gateway that will override the one received by autoconf.
        :param 'ApplianceUplinksSettingsInterfacesWan1SvisIpv6NameserversArgs' nameservers: The nameserver settings for this SVI.
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if assignment_mode is not None:
            pulumi.set(__self__, "assignment_mode", assignment_mode)
        if gateway is not None:
            pulumi.set(__self__, "gateway", gateway)
        if nameservers is not None:
            pulumi.set(__self__, "nameservers", nameservers)

    @_builtins.property
    @pulumi.getter
    def address(self) -> Optional[_builtins.str]:
        """
        Static address that will override the one(s) received by SLAAC.
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> Optional[_builtins.str]:
        """
        The assignment mode for this SVI. Applies only when PPPoE is disabled.
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> Optional[_builtins.str]:
        """
        Static gateway that will override the one received by autoconf.
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def nameservers(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan1SvisIpv6Nameservers']:
        """
        The nameserver settings for this SVI.
        """
        return pulumi.get(self, "nameservers")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan1SvisIpv6Nameservers(dict):
    def __init__(__self__, *,
                 addresses: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] addresses: Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence[_builtins.str]]:
        """
        Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan1VlanTagging(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vlanId":
            suggest = "vlan_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceUplinksSettingsInterfacesWan1VlanTagging. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceUplinksSettingsInterfacesWan1VlanTagging.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceUplinksSettingsInterfacesWan1VlanTagging.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None,
                 vlan_id: Optional[_builtins.int] = None):
        """
        :param _builtins.bool enabled: Whether VLAN tagging is enabled.
        :param _builtins.int vlan_id: The ID of the VLAN to use for VLAN tagging.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if vlan_id is not None:
            pulumi.set(__self__, "vlan_id", vlan_id)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Whether VLAN tagging is enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> Optional[_builtins.int]:
        """
        The ID of the VLAN to use for VLAN tagging.
        """
        return pulumi.get(self, "vlan_id")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vlanTagging":
            suggest = "vlan_tagging"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceUplinksSettingsInterfacesWan2. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceUplinksSettingsInterfacesWan2.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceUplinksSettingsInterfacesWan2.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None,
                 pppoe: Optional['outputs.ApplianceUplinksSettingsInterfacesWan2Pppoe'] = None,
                 svis: Optional['outputs.ApplianceUplinksSettingsInterfacesWan2Svis'] = None,
                 vlan_tagging: Optional['outputs.ApplianceUplinksSettingsInterfacesWan2VlanTagging'] = None):
        """
        :param _builtins.bool enabled: Enable or disable the interface.
        :param 'ApplianceUplinksSettingsInterfacesWan2PppoeArgs' pppoe: Configuration options for PPPoE.
        :param 'ApplianceUplinksSettingsInterfacesWan2SvisArgs' svis: SVI settings by protocol.
        :param 'ApplianceUplinksSettingsInterfacesWan2VlanTaggingArgs' vlan_tagging: VLAN tagging settings.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if pppoe is not None:
            pulumi.set(__self__, "pppoe", pppoe)
        if svis is not None:
            pulumi.set(__self__, "svis", svis)
        if vlan_tagging is not None:
            pulumi.set(__self__, "vlan_tagging", vlan_tagging)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Enable or disable the interface.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def pppoe(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan2Pppoe']:
        """
        Configuration options for PPPoE.
        """
        return pulumi.get(self, "pppoe")

    @_builtins.property
    @pulumi.getter
    def svis(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan2Svis']:
        """
        SVI settings by protocol.
        """
        return pulumi.get(self, "svis")

    @_builtins.property
    @pulumi.getter(name="vlanTagging")
    def vlan_tagging(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan2VlanTagging']:
        """
        VLAN tagging settings.
        """
        return pulumi.get(self, "vlan_tagging")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan2Pppoe(dict):
    def __init__(__self__, *,
                 authentication: Optional['outputs.ApplianceUplinksSettingsInterfacesWan2PppoeAuthentication'] = None,
                 enabled: Optional[_builtins.bool] = None):
        """
        :param 'ApplianceUplinksSettingsInterfacesWan2PppoeAuthenticationArgs' authentication: Settings for PPPoE Authentication.
        :param _builtins.bool enabled: Whether PPPoE is enabled.
        """
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def authentication(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan2PppoeAuthentication']:
        """
        Settings for PPPoE Authentication.
        """
        return pulumi.get(self, "authentication")

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Whether PPPoE is enabled.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan2PppoeAuthentication(dict):
    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None,
                 password: Optional[_builtins.str] = None,
                 username: Optional[_builtins.str] = None):
        """
        :param _builtins.bool enabled: Whether PPPoE authentication is enabled.
        :param _builtins.str password: Password for PPPoE authentication. This parameter is not returned.
        :param _builtins.str username: Username for PPPoE authentication.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Whether PPPoE authentication is enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[_builtins.str]:
        """
        Password for PPPoE authentication. This parameter is not returned.
        """
        return pulumi.get(self, "password")

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[_builtins.str]:
        """
        Username for PPPoE authentication.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan2Svis(dict):
    def __init__(__self__, *,
                 ipv4: Optional['outputs.ApplianceUplinksSettingsInterfacesWan2SvisIpv4'] = None,
                 ipv6: Optional['outputs.ApplianceUplinksSettingsInterfacesWan2SvisIpv6'] = None):
        """
        :param 'ApplianceUplinksSettingsInterfacesWan2SvisIpv4Args' ipv4: IPv4 settings for static/dynamic mode.
        :param 'ApplianceUplinksSettingsInterfacesWan2SvisIpv6Args' ipv6: IPv6 settings for static/dynamic mode.
        """
        if ipv4 is not None:
            pulumi.set(__self__, "ipv4", ipv4)
        if ipv6 is not None:
            pulumi.set(__self__, "ipv6", ipv6)

    @_builtins.property
    @pulumi.getter
    def ipv4(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan2SvisIpv4']:
        """
        IPv4 settings for static/dynamic mode.
        """
        return pulumi.get(self, "ipv4")

    @_builtins.property
    @pulumi.getter
    def ipv6(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan2SvisIpv6']:
        """
        IPv6 settings for static/dynamic mode.
        """
        return pulumi.get(self, "ipv6")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan2SvisIpv4(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "assignmentMode":
            suggest = "assignment_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceUplinksSettingsInterfacesWan2SvisIpv4. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceUplinksSettingsInterfacesWan2SvisIpv4.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceUplinksSettingsInterfacesWan2SvisIpv4.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[_builtins.str] = None,
                 assignment_mode: Optional[_builtins.str] = None,
                 gateway: Optional[_builtins.str] = None,
                 nameservers: Optional['outputs.ApplianceUplinksSettingsInterfacesWan2SvisIpv4Nameservers'] = None):
        """
        :param _builtins.str address: IP address and subnet mask when in static mode.
        :param _builtins.str assignment_mode: The assignment mode for this SVI. Applies only when PPPoE is disabled.
        :param _builtins.str gateway: Gateway IP address when in static mode.
        :param 'ApplianceUplinksSettingsInterfacesWan2SvisIpv4NameserversArgs' nameservers: The nameserver settings for this SVI.
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if assignment_mode is not None:
            pulumi.set(__self__, "assignment_mode", assignment_mode)
        if gateway is not None:
            pulumi.set(__self__, "gateway", gateway)
        if nameservers is not None:
            pulumi.set(__self__, "nameservers", nameservers)

    @_builtins.property
    @pulumi.getter
    def address(self) -> Optional[_builtins.str]:
        """
        IP address and subnet mask when in static mode.
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> Optional[_builtins.str]:
        """
        The assignment mode for this SVI. Applies only when PPPoE is disabled.
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> Optional[_builtins.str]:
        """
        Gateway IP address when in static mode.
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def nameservers(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan2SvisIpv4Nameservers']:
        """
        The nameserver settings for this SVI.
        """
        return pulumi.get(self, "nameservers")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan2SvisIpv4Nameservers(dict):
    def __init__(__self__, *,
                 addresses: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] addresses: Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence[_builtins.str]]:
        """
        Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan2SvisIpv6(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "assignmentMode":
            suggest = "assignment_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceUplinksSettingsInterfacesWan2SvisIpv6. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceUplinksSettingsInterfacesWan2SvisIpv6.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceUplinksSettingsInterfacesWan2SvisIpv6.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[_builtins.str] = None,
                 assignment_mode: Optional[_builtins.str] = None,
                 gateway: Optional[_builtins.str] = None,
                 nameservers: Optional['outputs.ApplianceUplinksSettingsInterfacesWan2SvisIpv6Nameservers'] = None):
        """
        :param _builtins.str address: Static address that will override the one(s) received by SLAAC.
        :param _builtins.str assignment_mode: The assignment mode for this SVI. Applies only when PPPoE is disabled.
        :param _builtins.str gateway: Static gateway that will override the one received by autoconf.
        :param 'ApplianceUplinksSettingsInterfacesWan2SvisIpv6NameserversArgs' nameservers: The nameserver settings for this SVI.
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if assignment_mode is not None:
            pulumi.set(__self__, "assignment_mode", assignment_mode)
        if gateway is not None:
            pulumi.set(__self__, "gateway", gateway)
        if nameservers is not None:
            pulumi.set(__self__, "nameservers", nameservers)

    @_builtins.property
    @pulumi.getter
    def address(self) -> Optional[_builtins.str]:
        """
        Static address that will override the one(s) received by SLAAC.
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> Optional[_builtins.str]:
        """
        The assignment mode for this SVI. Applies only when PPPoE is disabled.
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> Optional[_builtins.str]:
        """
        Static gateway that will override the one received by autoconf.
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def nameservers(self) -> Optional['outputs.ApplianceUplinksSettingsInterfacesWan2SvisIpv6Nameservers']:
        """
        The nameserver settings for this SVI.
        """
        return pulumi.get(self, "nameservers")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan2SvisIpv6Nameservers(dict):
    def __init__(__self__, *,
                 addresses: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] addresses: Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence[_builtins.str]]:
        """
        Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class ApplianceUplinksSettingsInterfacesWan2VlanTagging(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vlanId":
            suggest = "vlan_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceUplinksSettingsInterfacesWan2VlanTagging. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceUplinksSettingsInterfacesWan2VlanTagging.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceUplinksSettingsInterfacesWan2VlanTagging.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None,
                 vlan_id: Optional[_builtins.int] = None):
        """
        :param _builtins.bool enabled: Whether VLAN tagging is enabled.
        :param _builtins.int vlan_id: The ID of the VLAN to use for VLAN tagging.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if vlan_id is not None:
            pulumi.set(__self__, "vlan_id", vlan_id)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Whether VLAN tagging is enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> Optional[_builtins.int]:
        """
        The ID of the VLAN to use for VLAN tagging.
        """
        return pulumi.get(self, "vlan_id")


@pulumi.output_type
class ApplianceVmxAuthenticationTokenItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "expiresAt":
            suggest = "expires_at"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplianceVmxAuthenticationTokenItem. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplianceVmxAuthenticationTokenItem.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplianceVmxAuthenticationTokenItem.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 expires_at: Optional[_builtins.str] = None,
                 token: Optional[_builtins.str] = None):
        """
        :param _builtins.str expires_at: The expiration time for the token, in ISO 8601 format
        :param _builtins.str token: The newly generated authentication token for the vMX instance
        """
        if expires_at is not None:
            pulumi.set(__self__, "expires_at", expires_at)
        if token is not None:
            pulumi.set(__self__, "token", token)

    @_builtins.property
    @pulumi.getter(name="expiresAt")
    def expires_at(self) -> Optional[_builtins.str]:
        """
        The expiration time for the token, in ISO 8601 format
        """
        return pulumi.get(self, "expires_at")

    @_builtins.property
    @pulumi.getter
    def token(self) -> Optional[_builtins.str]:
        """
        The newly generated authentication token for the vMX instance
        """
        return pulumi.get(self, "token")


@pulumi.output_type
class BlinkLedsItem(dict):
    def __init__(__self__, *,
                 duration: Optional[_builtins.int] = None,
                 duty: Optional[_builtins.int] = None,
                 period: Optional[_builtins.int] = None):
        """
        :param _builtins.int duration: The duration in seconds. Will be between 5 and 120. Default is 20 seconds
        :param _builtins.int duty: The duty cycle as the percent active. Will be between 10 and 90. Default is 50
        :param _builtins.int period: The period in milliseconds. Will be between 100 and 1000. Default is 160 milliseconds
        """
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if duty is not None:
            pulumi.set(__self__, "duty", duty)
        if period is not None:
            pulumi.set(__self__, "period", period)

    @_builtins.property
    @pulumi.getter
    def duration(self) -> Optional[_builtins.int]:
        """
        The duration in seconds. Will be between 5 and 120. Default is 20 seconds
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def duty(self) -> Optional[_builtins.int]:
        """
        The duty cycle as the percent active. Will be between 10 and 90. Default is 50
        """
        return pulumi.get(self, "duty")

    @_builtins.property
    @pulumi.getter
    def period(self) -> Optional[_builtins.int]:
        """
        The period in milliseconds. Will be between 100 and 1000. Default is 160 milliseconds
        """
        return pulumi.get(self, "period")


@pulumi.output_type
class BlinkLedsParameters(dict):
    def __init__(__self__, *,
                 duration: Optional[_builtins.int] = None,
                 duty: Optional[_builtins.int] = None,
                 period: Optional[_builtins.int] = None):
        """
        :param _builtins.int duration: The duration in seconds. Must be between 5 and 120. Default is 20 seconds
        :param _builtins.int duty: The duty cycle as the percent active. Must be between 10 and 90. Default is 50.
        :param _builtins.int period: The period in milliseconds. Must be between 100 and 1000. Default is 160 milliseconds
        """
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if duty is not None:
            pulumi.set(__self__, "duty", duty)
        if period is not None:
            pulumi.set(__self__, "period", period)

    @_builtins.property
    @pulumi.getter
    def duration(self) -> Optional[_builtins.int]:
        """
        The duration in seconds. Must be between 5 and 120. Default is 20 seconds
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def duty(self) -> Optional[_builtins.int]:
        """
        The duty cycle as the percent active. Must be between 10 and 90. Default is 50.
        """
        return pulumi.get(self, "duty")

    @_builtins.property
    @pulumi.getter
    def period(self) -> Optional[_builtins.int]:
        """
        The period in milliseconds. Must be between 100 and 1000. Default is 160 milliseconds
        """
        return pulumi.get(self, "period")


@pulumi.output_type
class CameraCustomAnalyticsParameter(dict):
    def __init__(__self__, *,
                 name: Optional[_builtins.str] = None,
                 value: Optional[_builtins.float] = None):
        """
        :param _builtins.str name: Name of the parameter
        :param _builtins.float value: Value of the parameter
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        Name of the parameter
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter
    def value(self) -> Optional[_builtins.float]:
        """
        Value of the parameter
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class CameraGenerateSnapshotParameters(dict):
    def __init__(__self__, *,
                 fullframe: Optional[_builtins.bool] = None,
                 timestamp: Optional[_builtins.str] = None):
        """
        :param _builtins.bool fullframe: [optional] If set to "true" the snapshot will be taken at full sensor resolution. This will error if used with timestamp.
        :param _builtins.str timestamp: [optional] The snapshot will be taken from this time on the camera. The timestamp is expected to be in ISO 8601 format. If no timestamp is specified, we will assume current time.
        """
        if fullframe is not None:
            pulumi.set(__self__, "fullframe", fullframe)
        if timestamp is not None:
            pulumi.set(__self__, "timestamp", timestamp)

    @_builtins.property
    @pulumi.getter
    def fullframe(self) -> Optional[_builtins.bool]:
        """
        [optional] If set to "true" the snapshot will be taken at full sensor resolution. This will error if used with timestamp.
        """
        return pulumi.get(self, "fullframe")

    @_builtins.property
    @pulumi.getter
    def timestamp(self) -> Optional[_builtins.str]:
        """
        [optional] The snapshot will be taken from this time on the camera. The timestamp is expected to be in ISO 8601 format. If no timestamp is specified, we will assume current time.
        """
        return pulumi.get(self, "timestamp")


@pulumi.output_type
class CameraSenseAudioDetection(dict):
    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None):
        """
        :param _builtins.bool enabled: Boolean indicating if audio detection is enabled(true) or disabled(false) on the camera
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Boolean indicating if audio detection is enabled(true) or disabled(false) on the camera
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class CameraWirelessProfilesIds(dict):
    def __init__(__self__, *,
                 backup: Optional[_builtins.str] = None,
                 primary: Optional[_builtins.str] = None,
                 secondary: Optional[_builtins.str] = None):
        """
        :param _builtins.str backup: The id of the backup wireless profile
        :param _builtins.str primary: The id of the primary wireless profile
        :param _builtins.str secondary: The id of the secondary wireless profile
        """
        if backup is not None:
            pulumi.set(__self__, "backup", backup)
        if primary is not None:
            pulumi.set(__self__, "primary", primary)
        if secondary is not None:
            pulumi.set(__self__, "secondary", secondary)

    @_builtins.property
    @pulumi.getter
    def backup(self) -> Optional[_builtins.str]:
        """
        The id of the backup wireless profile
        """
        return pulumi.get(self, "backup")

    @_builtins.property
    @pulumi.getter
    def primary(self) -> Optional[_builtins.str]:
        """
        The id of the primary wireless profile
        """
        return pulumi.get(self, "primary")

    @_builtins.property
    @pulumi.getter
    def secondary(self) -> Optional[_builtins.str]:
        """
        The id of the secondary wireless profile
        """
        return pulumi.get(self, "secondary")


@pulumi.output_type
class CellularGatewayLanFixedIpAssignment(dict):
    def __init__(__self__, *,
                 ip: Optional[_builtins.str] = None,
                 mac: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.str ip: The IP address you want to assign to a specific server or device
        :param _builtins.str mac: The MAC address of the server or device that hosts the internal resource that you wish to receive the specified IP address
        :param _builtins.str name: A descriptive name of the assignment
        """
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if mac is not None:
            pulumi.set(__self__, "mac", mac)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def ip(self) -> Optional[_builtins.str]:
        """
        The IP address you want to assign to a specific server or device
        """
        return pulumi.get(self, "ip")

    @_builtins.property
    @pulumi.getter
    def mac(self) -> Optional[_builtins.str]:
        """
        The MAC address of the server or device that hosts the internal resource that you wish to receive the specified IP address
        """
        return pulumi.get(self, "mac")

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        A descriptive name of the assignment
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class CellularGatewayLanReservedIpRange(dict):
    def __init__(__self__, *,
                 comment: Optional[_builtins.str] = None,
                 end: Optional[_builtins.str] = None,
                 start: Optional[_builtins.str] = None):
        """
        :param _builtins.str comment: Comment explaining the reserved IP range
        :param _builtins.str end: Ending IP included in the reserved range of IPs
        :param _builtins.str start: Starting IP included in the reserved range of IPs
        """
        if comment is not None:
            pulumi.set(__self__, "comment", comment)
        if end is not None:
            pulumi.set(__self__, "end", end)
        if start is not None:
            pulumi.set(__self__, "start", start)

    @_builtins.property
    @pulumi.getter
    def comment(self) -> Optional[_builtins.str]:
        """
        Comment explaining the reserved IP range
        """
        return pulumi.get(self, "comment")

    @_builtins.property
    @pulumi.getter
    def end(self) -> Optional[_builtins.str]:
        """
        Ending IP included in the reserved range of IPs
        """
        return pulumi.get(self, "end")

    @_builtins.property
    @pulumi.getter
    def start(self) -> Optional[_builtins.str]:
        """
        Starting IP included in the reserved range of IPs
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class CellularGatewayPortForwardingRulesRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedIps":
            suggest = "allowed_ips"
        elif key == "lanIp":
            suggest = "lan_ip"
        elif key == "localPort":
            suggest = "local_port"
        elif key == "publicPort":
            suggest = "public_port"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CellularGatewayPortForwardingRulesRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CellularGatewayPortForwardingRulesRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CellularGatewayPortForwardingRulesRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access: Optional[_builtins.str] = None,
                 allowed_ips: Optional[Sequence[_builtins.str]] = None,
                 lan_ip: Optional[_builtins.str] = None,
                 local_port: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 protocol: Optional[_builtins.str] = None,
                 public_port: Optional[_builtins.str] = None,
                 uplink: Optional[_builtins.str] = None):
        """
        :param _builtins.str access: *any* or *restricted*. Specify the right to make inbound connections on the specified ports or port ranges. If *restricted*, a list of allowed IPs is mandatory.
        :param Sequence[_builtins.str] allowed_ips: An array of ranges of WAN IP addresses that are allowed to make inbound connections on the specified ports or port ranges.
        :param _builtins.str lan_ip: The IP address of the server or device that hosts the internal resource that you wish to make available on the WAN
        :param _builtins.str local_port: A port or port ranges that will receive the forwarded traffic from the WAN
        :param _builtins.str name: A descriptive name for the rule
        :param _builtins.str protocol: TCP or UDP
        :param _builtins.str public_port: A port or port ranges that will be forwarded to the host on the LAN
        """
        if access is not None:
            pulumi.set(__self__, "access", access)
        if allowed_ips is not None:
            pulumi.set(__self__, "allowed_ips", allowed_ips)
        if lan_ip is not None:
            pulumi.set(__self__, "lan_ip", lan_ip)
        if local_port is not None:
            pulumi.set(__self__, "local_port", local_port)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if public_port is not None:
            pulumi.set(__self__, "public_port", public_port)
        if uplink is not None:
            pulumi.set(__self__, "uplink", uplink)

    @_builtins.property
    @pulumi.getter
    def access(self) -> Optional[_builtins.str]:
        """
        *any* or *restricted*. Specify the right to make inbound connections on the specified ports or port ranges. If *restricted*, a list of allowed IPs is mandatory.
        """
        return pulumi.get(self, "access")

    @_builtins.property
    @pulumi.getter(name="allowedIps")
    def allowed_ips(self) -> Optional[Sequence[_builtins.str]]:
        """
        An array of ranges of WAN IP addresses that are allowed to make inbound connections on the specified ports or port ranges.
        """
        return pulumi.get(self, "allowed_ips")

    @_builtins.property
    @pulumi.getter(name="lanIp")
    def lan_ip(self) -> Optional[_builtins.str]:
        """
        The IP address of the server or device that hosts the internal resource that you wish to make available on the WAN
        """
        return pulumi.get(self, "lan_ip")

    @_builtins.property
    @pulumi.getter(name="localPort")
    def local_port(self) -> Optional[_builtins.str]:
        """
        A port or port ranges that will receive the forwarded traffic from the WAN
        """
        return pulumi.get(self, "local_port")

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        A descriptive name for the rule
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter
    def protocol(self) -> Optional[_builtins.str]:
        """
        TCP or UDP
        """
        return pulumi.get(self, "protocol")

    @_builtins.property
    @pulumi.getter(name="publicPort")
    def public_port(self) -> Optional[_builtins.str]:
        """
        A port or port ranges that will be forwarded to the host on the LAN
        """
        return pulumi.get(self, "public_port")

    @_builtins.property
    @pulumi.getter
    def uplink(self) -> Optional[_builtins.str]:
        return pulumi.get(self, "uplink")


@pulumi.output_type
class CellularSimsSim(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isPrimary":
            suggest = "is_primary"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CellularSimsSim. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CellularSimsSim.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CellularSimsSim.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 apns: Optional[Sequence['outputs.CellularSimsSimApn']] = None,
                 is_primary: Optional[_builtins.bool] = None,
                 slot: Optional[_builtins.str] = None):
        """
        :param Sequence['CellularSimsSimApnArgs'] apns: APN configurations. If empty, the default APN will be used.
        :param _builtins.bool is_primary: If true, this SIM is used for boot. Must be true on single-sim devices.
        :param _builtins.str slot: SIM slot being configured. Must be 'sim1' on single-sim devices.
        """
        if apns is not None:
            pulumi.set(__self__, "apns", apns)
        if is_primary is not None:
            pulumi.set(__self__, "is_primary", is_primary)
        if slot is not None:
            pulumi.set(__self__, "slot", slot)

    @_builtins.property
    @pulumi.getter
    def apns(self) -> Optional[Sequence['outputs.CellularSimsSimApn']]:
        """
        APN configurations. If empty, the default APN will be used.
        """
        return pulumi.get(self, "apns")

    @_builtins.property
    @pulumi.getter(name="isPrimary")
    def is_primary(self) -> Optional[_builtins.bool]:
        """
        If true, this SIM is used for boot. Must be true on single-sim devices.
        """
        return pulumi.get(self, "is_primary")

    @_builtins.property
    @pulumi.getter
    def slot(self) -> Optional[_builtins.str]:
        """
        SIM slot being configured. Must be 'sim1' on single-sim devices.
        """
        return pulumi.get(self, "slot")


@pulumi.output_type
class CellularSimsSimApn(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedIpTypes":
            suggest = "allowed_ip_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CellularSimsSimApn. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CellularSimsSimApn.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CellularSimsSimApn.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allowed_ip_types: Optional[Sequence[_builtins.str]] = None,
                 authentication: Optional['outputs.CellularSimsSimApnAuthentication'] = None,
                 name: Optional[_builtins.str] = None):
        """
        :param Sequence[_builtins.str] allowed_ip_types: IP versions to support (permitted values include 'ipv4', 'ipv6').
        :param 'CellularSimsSimApnAuthenticationArgs' authentication: APN authentication configurations.
        :param _builtins.str name: APN name.
        """
        if allowed_ip_types is not None:
            pulumi.set(__self__, "allowed_ip_types", allowed_ip_types)
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter(name="allowedIpTypes")
    def allowed_ip_types(self) -> Optional[Sequence[_builtins.str]]:
        """
        IP versions to support (permitted values include 'ipv4', 'ipv6').
        """
        return pulumi.get(self, "allowed_ip_types")

    @_builtins.property
    @pulumi.getter
    def authentication(self) -> Optional['outputs.CellularSimsSimApnAuthentication']:
        """
        APN authentication configurations.
        """
        return pulumi.get(self, "authentication")

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        APN name.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class CellularSimsSimApnAuthentication(dict):
    def __init__(__self__, *,
                 password: Optional[_builtins.str] = None,
                 type: Optional[_builtins.str] = None,
                 username: Optional[_builtins.str] = None):
        """
        :param _builtins.str password: APN password, if type is set (if APN password is not supplied, the password is left unchanged).
        :param _builtins.str type: APN auth type.
        :param _builtins.str username: APN username, if type is set.
        """
        if password is not None:
            pulumi.set(__self__, "password", password)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[_builtins.str]:
        """
        APN password, if type is set (if APN password is not supplied, the password is left unchanged).
        """
        return pulumi.get(self, "password")

    @_builtins.property
    @pulumi.getter
    def type(self) -> Optional[_builtins.str]:
        """
        APN auth type.
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[_builtins.str]:
        """
        APN username, if type is set.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class CellularSimsSimFailover(dict):
    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None,
                 timeout: Optional[_builtins.int] = None):
        """
        :param _builtins.bool enabled: Failover to secondary SIM (optional)
        :param _builtins.int timeout: Failover timeout in seconds (optional)
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Failover to secondary SIM (optional)
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def timeout(self) -> Optional[_builtins.int]:
        """
        Failover timeout in seconds (optional)
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class LiveToolsArpTableCallback(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpServer":
            suggest = "http_server"
        elif key == "payloadTemplate":
            suggest = "payload_template"
        elif key == "sharedSecret":
            suggest = "shared_secret"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsArpTableCallback. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsArpTableCallback.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsArpTableCallback.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_server: Optional['outputs.LiveToolsArpTableCallbackHttpServer'] = None,
                 payload_template: Optional['outputs.LiveToolsArpTableCallbackPayloadTemplate'] = None,
                 shared_secret: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param 'LiveToolsArpTableCallbackHttpServerArgs' http_server: The webhook receiver used for the callback webhook.
        :param 'LiveToolsArpTableCallbackPayloadTemplateArgs' payload_template: The payload template of the webhook used for the callback
        :param _builtins.str shared_secret: A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        :param _builtins.str url: The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        if http_server is not None:
            pulumi.set(__self__, "http_server", http_server)
        if payload_template is not None:
            pulumi.set(__self__, "payload_template", payload_template)
        if shared_secret is not None:
            pulumi.set(__self__, "shared_secret", shared_secret)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="httpServer")
    def http_server(self) -> Optional['outputs.LiveToolsArpTableCallbackHttpServer']:
        """
        The webhook receiver used for the callback webhook.
        """
        return pulumi.get(self, "http_server")

    @_builtins.property
    @pulumi.getter(name="payloadTemplate")
    def payload_template(self) -> Optional['outputs.LiveToolsArpTableCallbackPayloadTemplate']:
        """
        The payload template of the webhook used for the callback
        """
        return pulumi.get(self, "payload_template")

    @_builtins.property
    @pulumi.getter(name="sharedSecret")
    def shared_secret(self) -> Optional[_builtins.str]:
        """
        A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        """
        return pulumi.get(self, "shared_secret")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class LiveToolsArpTableCallbackHttpServer(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsArpTableCallbackPayloadTemplate(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsArpTableEntry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "lastUpdatedAt":
            suggest = "last_updated_at"
        elif key == "vlanId":
            suggest = "vlan_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsArpTableEntry. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsArpTableEntry.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsArpTableEntry.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip: Optional[_builtins.str] = None,
                 last_updated_at: Optional[_builtins.str] = None,
                 mac: Optional[_builtins.str] = None,
                 vlan_id: Optional[_builtins.int] = None):
        """
        :param _builtins.str ip: The IP address of the ARP table entry
        :param _builtins.str last_updated_at: Time of the last update of the ARP table entry
        :param _builtins.str mac: The MAC address of the ARP table entry
        :param _builtins.int vlan_id: The VLAN ID of the ARP table entry
        """
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if last_updated_at is not None:
            pulumi.set(__self__, "last_updated_at", last_updated_at)
        if mac is not None:
            pulumi.set(__self__, "mac", mac)
        if vlan_id is not None:
            pulumi.set(__self__, "vlan_id", vlan_id)

    @_builtins.property
    @pulumi.getter
    def ip(self) -> Optional[_builtins.str]:
        """
        The IP address of the ARP table entry
        """
        return pulumi.get(self, "ip")

    @_builtins.property
    @pulumi.getter(name="lastUpdatedAt")
    def last_updated_at(self) -> Optional[_builtins.str]:
        """
        Time of the last update of the ARP table entry
        """
        return pulumi.get(self, "last_updated_at")

    @_builtins.property
    @pulumi.getter
    def mac(self) -> Optional[_builtins.str]:
        """
        The MAC address of the ARP table entry
        """
        return pulumi.get(self, "mac")

    @_builtins.property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> Optional[_builtins.int]:
        """
        The VLAN ID of the ARP table entry
        """
        return pulumi.get(self, "vlan_id")


@pulumi.output_type
class LiveToolsArpTableRequest(dict):
    def __init__(__self__, *,
                 serial: Optional[_builtins.str] = None):
        """
        :param _builtins.str serial: Device serial number
        """
        if serial is not None:
            pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter
    def serial(self) -> Optional[_builtins.str]:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class LiveToolsCableCallback(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpServer":
            suggest = "http_server"
        elif key == "payloadTemplate":
            suggest = "payload_template"
        elif key == "sharedSecret":
            suggest = "shared_secret"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsCableCallback. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsCableCallback.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsCableCallback.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_server: Optional['outputs.LiveToolsCableCallbackHttpServer'] = None,
                 payload_template: Optional['outputs.LiveToolsCableCallbackPayloadTemplate'] = None,
                 shared_secret: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param 'LiveToolsCableCallbackHttpServerArgs' http_server: The webhook receiver used for the callback webhook.
        :param 'LiveToolsCableCallbackPayloadTemplateArgs' payload_template: The payload template of the webhook used for the callback
        :param _builtins.str shared_secret: A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        :param _builtins.str url: The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        if http_server is not None:
            pulumi.set(__self__, "http_server", http_server)
        if payload_template is not None:
            pulumi.set(__self__, "payload_template", payload_template)
        if shared_secret is not None:
            pulumi.set(__self__, "shared_secret", shared_secret)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="httpServer")
    def http_server(self) -> Optional['outputs.LiveToolsCableCallbackHttpServer']:
        """
        The webhook receiver used for the callback webhook.
        """
        return pulumi.get(self, "http_server")

    @_builtins.property
    @pulumi.getter(name="payloadTemplate")
    def payload_template(self) -> Optional['outputs.LiveToolsCableCallbackPayloadTemplate']:
        """
        The payload template of the webhook used for the callback
        """
        return pulumi.get(self, "payload_template")

    @_builtins.property
    @pulumi.getter(name="sharedSecret")
    def shared_secret(self) -> Optional[_builtins.str]:
        """
        A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        """
        return pulumi.get(self, "shared_secret")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class LiveToolsCableCallbackHttpServer(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsCableCallbackPayloadTemplate(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsCableRequest(dict):
    def __init__(__self__, *,
                 ports: Optional[Sequence[_builtins.str]] = None,
                 serial: Optional[_builtins.str] = None):
        """
        :param Sequence[_builtins.str] ports: A list of ports for which to perform the cable test.
        :param _builtins.str serial: Device serial number
        """
        if ports is not None:
            pulumi.set(__self__, "ports", ports)
        if serial is not None:
            pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[_builtins.str]]:
        """
        A list of ports for which to perform the cable test.
        """
        return pulumi.get(self, "ports")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> Optional[_builtins.str]:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class LiveToolsCableResult(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "speedMbps":
            suggest = "speed_mbps"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsCableResult. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsCableResult.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsCableResult.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 error: Optional[_builtins.str] = None,
                 pairs: Optional[Sequence['outputs.LiveToolsCableResultPair']] = None,
                 port: Optional[_builtins.str] = None,
                 speed_mbps: Optional[_builtins.int] = None,
                 status: Optional[_builtins.str] = None):
        """
        :param _builtins.str error: If an error occurred during the cable test, the error message will be populated here.
        :param Sequence['LiveToolsCableResultPairArgs'] pairs: Results for each twisted pair within the cable.
        :param _builtins.str port: The port for which the test was performed.
        :param _builtins.int speed_mbps: Speed in Mbps.  A speed of 0 indicates the port is down or the port speed is automatic.
        :param _builtins.str status: The current status of the port. If the cable test is still being performed on the port, "in-progress" is used. If an error occurred during the cable test, "error" is used and the error property will be populated.
        """
        if error is not None:
            pulumi.set(__self__, "error", error)
        if pairs is not None:
            pulumi.set(__self__, "pairs", pairs)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if speed_mbps is not None:
            pulumi.set(__self__, "speed_mbps", speed_mbps)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter
    def error(self) -> Optional[_builtins.str]:
        """
        If an error occurred during the cable test, the error message will be populated here.
        """
        return pulumi.get(self, "error")

    @_builtins.property
    @pulumi.getter
    def pairs(self) -> Optional[Sequence['outputs.LiveToolsCableResultPair']]:
        """
        Results for each twisted pair within the cable.
        """
        return pulumi.get(self, "pairs")

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[_builtins.str]:
        """
        The port for which the test was performed.
        """
        return pulumi.get(self, "port")

    @_builtins.property
    @pulumi.getter(name="speedMbps")
    def speed_mbps(self) -> Optional[_builtins.int]:
        """
        Speed in Mbps.  A speed of 0 indicates the port is down or the port speed is automatic.
        """
        return pulumi.get(self, "speed_mbps")

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional[_builtins.str]:
        """
        The current status of the port. If the cable test is still being performed on the port, "in-progress" is used. If an error occurred during the cable test, "error" is used and the error property will be populated.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class LiveToolsCableResultPair(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "lengthMeters":
            suggest = "length_meters"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsCableResultPair. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsCableResultPair.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsCableResultPair.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 index: Optional[_builtins.int] = None,
                 length_meters: Optional[_builtins.int] = None,
                 status: Optional[_builtins.str] = None):
        """
        :param _builtins.int index: The index of the twisted pair tested.
        :param _builtins.int length_meters: The detected length of the twisted pair.
        :param _builtins.str status: The test result of the twisted pair tested.
        """
        if index is not None:
            pulumi.set(__self__, "index", index)
        if length_meters is not None:
            pulumi.set(__self__, "length_meters", length_meters)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter
    def index(self) -> Optional[_builtins.int]:
        """
        The index of the twisted pair tested.
        """
        return pulumi.get(self, "index")

    @_builtins.property
    @pulumi.getter(name="lengthMeters")
    def length_meters(self) -> Optional[_builtins.int]:
        """
        The detected length of the twisted pair.
        """
        return pulumi.get(self, "length_meters")

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional[_builtins.str]:
        """
        The test result of the twisted pair tested.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class LiveToolsPingDeviceItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pingId":
            suggest = "ping_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsPingDeviceItem. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsPingDeviceItem.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsPingDeviceItem.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 callback: Optional['outputs.LiveToolsPingDeviceItemCallback'] = None,
                 ping_id: Optional[_builtins.str] = None,
                 request: Optional['outputs.LiveToolsPingDeviceItemRequest'] = None,
                 status: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param 'LiveToolsPingDeviceItemCallbackArgs' callback: Information for callback used to send back results
        :param _builtins.str ping_id: Id to check the status of your ping request.
        :param 'LiveToolsPingDeviceItemRequestArgs' request: Ping request parameters
        :param _builtins.str status: Status of the ping request.
        :param _builtins.str url: GET this url to check the status of your ping request.
        """
        if callback is not None:
            pulumi.set(__self__, "callback", callback)
        if ping_id is not None:
            pulumi.set(__self__, "ping_id", ping_id)
        if request is not None:
            pulumi.set(__self__, "request", request)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter
    def callback(self) -> Optional['outputs.LiveToolsPingDeviceItemCallback']:
        """
        Information for callback used to send back results
        """
        return pulumi.get(self, "callback")

    @_builtins.property
    @pulumi.getter(name="pingId")
    def ping_id(self) -> Optional[_builtins.str]:
        """
        Id to check the status of your ping request.
        """
        return pulumi.get(self, "ping_id")

    @_builtins.property
    @pulumi.getter
    def request(self) -> Optional['outputs.LiveToolsPingDeviceItemRequest']:
        """
        Ping request parameters
        """
        return pulumi.get(self, "request")

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional[_builtins.str]:
        """
        Status of the ping request.
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        GET this url to check the status of your ping request.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class LiveToolsPingDeviceItemCallback(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None,
                 status: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The ID of the callback. To check the status of the callback, use this ID in a request to /webhooks/callbacks/statuses/{id}
        :param _builtins.str status: The status of the callback
        :param _builtins.str url: The callback URL for the webhook target. This was either provided in the original request or comes from a configured webhook receiver
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the callback. To check the status of the callback, use this ID in a request to /webhooks/callbacks/statuses/{id}
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional[_builtins.str]:
        """
        The status of the callback
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        The callback URL for the webhook target. This was either provided in the original request or comes from a configured webhook receiver
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class LiveToolsPingDeviceItemRequest(dict):
    def __init__(__self__, *,
                 count: Optional[_builtins.int] = None,
                 serial: Optional[_builtins.str] = None,
                 target: Optional[_builtins.str] = None):
        """
        :param _builtins.int count: Number of pings to send
        :param _builtins.str serial: Device serial number
        :param _builtins.str target: IP address or FQDN to ping
        """
        if count is not None:
            pulumi.set(__self__, "count", count)
        if serial is not None:
            pulumi.set(__self__, "serial", serial)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @_builtins.property
    @pulumi.getter
    def count(self) -> Optional[_builtins.int]:
        """
        Number of pings to send
        """
        return pulumi.get(self, "count")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> Optional[_builtins.str]:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")

    @_builtins.property
    @pulumi.getter
    def target(self) -> Optional[_builtins.str]:
        """
        IP address or FQDN to ping
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class LiveToolsPingDeviceParameters(dict):
    def __init__(__self__, *,
                 callback: Optional['outputs.LiveToolsPingDeviceParametersCallback'] = None,
                 count: Optional[_builtins.int] = None):
        """
        :param 'LiveToolsPingDeviceParametersCallbackArgs' callback: Details for the callback. Please include either an httpServerId OR url and sharedSecret
        :param _builtins.int count: Count parameter to pass to ping. [1..5], default 5
        """
        if callback is not None:
            pulumi.set(__self__, "callback", callback)
        if count is not None:
            pulumi.set(__self__, "count", count)

    @_builtins.property
    @pulumi.getter
    def callback(self) -> Optional['outputs.LiveToolsPingDeviceParametersCallback']:
        """
        Details for the callback. Please include either an httpServerId OR url and sharedSecret
        """
        return pulumi.get(self, "callback")

    @_builtins.property
    @pulumi.getter
    def count(self) -> Optional[_builtins.int]:
        """
        Count parameter to pass to ping. [1..5], default 5
        """
        return pulumi.get(self, "count")


@pulumi.output_type
class LiveToolsPingDeviceParametersCallback(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpServer":
            suggest = "http_server"
        elif key == "payloadTemplate":
            suggest = "payload_template"
        elif key == "sharedSecret":
            suggest = "shared_secret"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsPingDeviceParametersCallback. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsPingDeviceParametersCallback.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsPingDeviceParametersCallback.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_server: Optional['outputs.LiveToolsPingDeviceParametersCallbackHttpServer'] = None,
                 payload_template: Optional['outputs.LiveToolsPingDeviceParametersCallbackPayloadTemplate'] = None,
                 shared_secret: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param 'LiveToolsPingDeviceParametersCallbackHttpServerArgs' http_server: The webhook receiver used for the callback webhook.
        :param 'LiveToolsPingDeviceParametersCallbackPayloadTemplateArgs' payload_template: The payload template of the webhook used for the callback
        :param _builtins.str shared_secret: A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        :param _builtins.str url: The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        if http_server is not None:
            pulumi.set(__self__, "http_server", http_server)
        if payload_template is not None:
            pulumi.set(__self__, "payload_template", payload_template)
        if shared_secret is not None:
            pulumi.set(__self__, "shared_secret", shared_secret)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="httpServer")
    def http_server(self) -> Optional['outputs.LiveToolsPingDeviceParametersCallbackHttpServer']:
        """
        The webhook receiver used for the callback webhook.
        """
        return pulumi.get(self, "http_server")

    @_builtins.property
    @pulumi.getter(name="payloadTemplate")
    def payload_template(self) -> Optional['outputs.LiveToolsPingDeviceParametersCallbackPayloadTemplate']:
        """
        The payload template of the webhook used for the callback
        """
        return pulumi.get(self, "payload_template")

    @_builtins.property
    @pulumi.getter(name="sharedSecret")
    def shared_secret(self) -> Optional[_builtins.str]:
        """
        A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        """
        return pulumi.get(self, "shared_secret")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class LiveToolsPingDeviceParametersCallbackHttpServer(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsPingDeviceParametersCallbackPayloadTemplate(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsPingItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pingId":
            suggest = "ping_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsPingItem. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsPingItem.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsPingItem.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 callback: Optional['outputs.LiveToolsPingItemCallback'] = None,
                 ping_id: Optional[_builtins.str] = None,
                 request: Optional['outputs.LiveToolsPingItemRequest'] = None,
                 status: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param 'LiveToolsPingItemCallbackArgs' callback: Information for callback used to send back results
        :param _builtins.str ping_id: Id to check the status of your ping request.
        :param 'LiveToolsPingItemRequestArgs' request: Ping request parameters
        :param _builtins.str status: Status of the ping request.
        :param _builtins.str url: GET this url to check the status of your ping request.
        """
        if callback is not None:
            pulumi.set(__self__, "callback", callback)
        if ping_id is not None:
            pulumi.set(__self__, "ping_id", ping_id)
        if request is not None:
            pulumi.set(__self__, "request", request)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter
    def callback(self) -> Optional['outputs.LiveToolsPingItemCallback']:
        """
        Information for callback used to send back results
        """
        return pulumi.get(self, "callback")

    @_builtins.property
    @pulumi.getter(name="pingId")
    def ping_id(self) -> Optional[_builtins.str]:
        """
        Id to check the status of your ping request.
        """
        return pulumi.get(self, "ping_id")

    @_builtins.property
    @pulumi.getter
    def request(self) -> Optional['outputs.LiveToolsPingItemRequest']:
        """
        Ping request parameters
        """
        return pulumi.get(self, "request")

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional[_builtins.str]:
        """
        Status of the ping request.
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        GET this url to check the status of your ping request.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class LiveToolsPingItemCallback(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None,
                 status: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The ID of the callback. To check the status of the callback, use this ID in a request to /webhooks/callbacks/statuses/{id}
        :param _builtins.str status: The status of the callback
        :param _builtins.str url: The callback URL for the webhook target. This was either provided in the original request or comes from a configured webhook receiver
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the callback. To check the status of the callback, use this ID in a request to /webhooks/callbacks/statuses/{id}
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional[_builtins.str]:
        """
        The status of the callback
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        The callback URL for the webhook target. This was either provided in the original request or comes from a configured webhook receiver
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class LiveToolsPingItemRequest(dict):
    def __init__(__self__, *,
                 count: Optional[_builtins.int] = None,
                 serial: Optional[_builtins.str] = None,
                 target: Optional[_builtins.str] = None):
        """
        :param _builtins.int count: Number of pings to send
        :param _builtins.str serial: Device serial number
        :param _builtins.str target: IP address or FQDN to ping
        """
        if count is not None:
            pulumi.set(__self__, "count", count)
        if serial is not None:
            pulumi.set(__self__, "serial", serial)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @_builtins.property
    @pulumi.getter
    def count(self) -> Optional[_builtins.int]:
        """
        Number of pings to send
        """
        return pulumi.get(self, "count")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> Optional[_builtins.str]:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")

    @_builtins.property
    @pulumi.getter
    def target(self) -> Optional[_builtins.str]:
        """
        IP address or FQDN to ping
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class LiveToolsPingParameters(dict):
    def __init__(__self__, *,
                 callback: Optional['outputs.LiveToolsPingParametersCallback'] = None,
                 count: Optional[_builtins.int] = None,
                 target: Optional[_builtins.str] = None):
        """
        :param 'LiveToolsPingParametersCallbackArgs' callback: Details for the callback. Please include either an httpServerId OR url and sharedSecret
        :param _builtins.int count: Count parameter to pass to ping. [1..5], default 5
        :param _builtins.str target: FQDN, IPv4 or IPv6 address
        """
        if callback is not None:
            pulumi.set(__self__, "callback", callback)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @_builtins.property
    @pulumi.getter
    def callback(self) -> Optional['outputs.LiveToolsPingParametersCallback']:
        """
        Details for the callback. Please include either an httpServerId OR url and sharedSecret
        """
        return pulumi.get(self, "callback")

    @_builtins.property
    @pulumi.getter
    def count(self) -> Optional[_builtins.int]:
        """
        Count parameter to pass to ping. [1..5], default 5
        """
        return pulumi.get(self, "count")

    @_builtins.property
    @pulumi.getter
    def target(self) -> Optional[_builtins.str]:
        """
        FQDN, IPv4 or IPv6 address
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class LiveToolsPingParametersCallback(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpServer":
            suggest = "http_server"
        elif key == "payloadTemplate":
            suggest = "payload_template"
        elif key == "sharedSecret":
            suggest = "shared_secret"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsPingParametersCallback. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsPingParametersCallback.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsPingParametersCallback.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_server: Optional['outputs.LiveToolsPingParametersCallbackHttpServer'] = None,
                 payload_template: Optional['outputs.LiveToolsPingParametersCallbackPayloadTemplate'] = None,
                 shared_secret: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param 'LiveToolsPingParametersCallbackHttpServerArgs' http_server: The webhook receiver used for the callback webhook.
        :param 'LiveToolsPingParametersCallbackPayloadTemplateArgs' payload_template: The payload template of the webhook used for the callback
        :param _builtins.str shared_secret: A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        :param _builtins.str url: The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        if http_server is not None:
            pulumi.set(__self__, "http_server", http_server)
        if payload_template is not None:
            pulumi.set(__self__, "payload_template", payload_template)
        if shared_secret is not None:
            pulumi.set(__self__, "shared_secret", shared_secret)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="httpServer")
    def http_server(self) -> Optional['outputs.LiveToolsPingParametersCallbackHttpServer']:
        """
        The webhook receiver used for the callback webhook.
        """
        return pulumi.get(self, "http_server")

    @_builtins.property
    @pulumi.getter(name="payloadTemplate")
    def payload_template(self) -> Optional['outputs.LiveToolsPingParametersCallbackPayloadTemplate']:
        """
        The payload template of the webhook used for the callback
        """
        return pulumi.get(self, "payload_template")

    @_builtins.property
    @pulumi.getter(name="sharedSecret")
    def shared_secret(self) -> Optional[_builtins.str]:
        """
        A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        """
        return pulumi.get(self, "shared_secret")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class LiveToolsPingParametersCallbackHttpServer(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsPingParametersCallbackPayloadTemplate(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsThroughputTestCallback(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpServer":
            suggest = "http_server"
        elif key == "payloadTemplate":
            suggest = "payload_template"
        elif key == "sharedSecret":
            suggest = "shared_secret"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsThroughputTestCallback. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsThroughputTestCallback.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsThroughputTestCallback.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_server: Optional['outputs.LiveToolsThroughputTestCallbackHttpServer'] = None,
                 payload_template: Optional['outputs.LiveToolsThroughputTestCallbackPayloadTemplate'] = None,
                 shared_secret: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param 'LiveToolsThroughputTestCallbackHttpServerArgs' http_server: The webhook receiver used for the callback webhook.
        :param 'LiveToolsThroughputTestCallbackPayloadTemplateArgs' payload_template: The payload template of the webhook used for the callback
        :param _builtins.str shared_secret: A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        :param _builtins.str url: The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        if http_server is not None:
            pulumi.set(__self__, "http_server", http_server)
        if payload_template is not None:
            pulumi.set(__self__, "payload_template", payload_template)
        if shared_secret is not None:
            pulumi.set(__self__, "shared_secret", shared_secret)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="httpServer")
    def http_server(self) -> Optional['outputs.LiveToolsThroughputTestCallbackHttpServer']:
        """
        The webhook receiver used for the callback webhook.
        """
        return pulumi.get(self, "http_server")

    @_builtins.property
    @pulumi.getter(name="payloadTemplate")
    def payload_template(self) -> Optional['outputs.LiveToolsThroughputTestCallbackPayloadTemplate']:
        """
        The payload template of the webhook used for the callback
        """
        return pulumi.get(self, "payload_template")

    @_builtins.property
    @pulumi.getter(name="sharedSecret")
    def shared_secret(self) -> Optional[_builtins.str]:
        """
        A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        """
        return pulumi.get(self, "shared_secret")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class LiveToolsThroughputTestCallbackHttpServer(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsThroughputTestCallbackPayloadTemplate(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsThroughputTestRequest(dict):
    def __init__(__self__, *,
                 serial: Optional[_builtins.str] = None):
        """
        :param _builtins.str serial: Device serial number
        """
        if serial is not None:
            pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter
    def serial(self) -> Optional[_builtins.str]:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class LiveToolsThroughputTestResult(dict):
    def __init__(__self__, *,
                 speeds: Optional['outputs.LiveToolsThroughputTestResultSpeeds'] = None):
        """
        :param 'LiveToolsThroughputTestResultSpeedsArgs' speeds: Shows the speeds (Mbps)
        """
        if speeds is not None:
            pulumi.set(__self__, "speeds", speeds)

    @_builtins.property
    @pulumi.getter
    def speeds(self) -> Optional['outputs.LiveToolsThroughputTestResultSpeeds']:
        """
        Shows the speeds (Mbps)
        """
        return pulumi.get(self, "speeds")


@pulumi.output_type
class LiveToolsThroughputTestResultSpeeds(dict):
    def __init__(__self__, *,
                 downstream: Optional[_builtins.int] = None):
        """
        :param _builtins.int downstream: Shows the download speed from shard (Mbps)
        """
        if downstream is not None:
            pulumi.set(__self__, "downstream", downstream)

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> Optional[_builtins.int]:
        """
        Shows the download speed from shard (Mbps)
        """
        return pulumi.get(self, "downstream")


@pulumi.output_type
class LiveToolsWakeOnLanCallback(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpServer":
            suggest = "http_server"
        elif key == "payloadTemplate":
            suggest = "payload_template"
        elif key == "sharedSecret":
            suggest = "shared_secret"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsWakeOnLanCallback. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsWakeOnLanCallback.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsWakeOnLanCallback.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_server: Optional['outputs.LiveToolsWakeOnLanCallbackHttpServer'] = None,
                 payload_template: Optional['outputs.LiveToolsWakeOnLanCallbackPayloadTemplate'] = None,
                 shared_secret: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param 'LiveToolsWakeOnLanCallbackHttpServerArgs' http_server: The webhook receiver used for the callback webhook.
        :param 'LiveToolsWakeOnLanCallbackPayloadTemplateArgs' payload_template: The payload template of the webhook used for the callback
        :param _builtins.str shared_secret: A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        :param _builtins.str url: The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        if http_server is not None:
            pulumi.set(__self__, "http_server", http_server)
        if payload_template is not None:
            pulumi.set(__self__, "payload_template", payload_template)
        if shared_secret is not None:
            pulumi.set(__self__, "shared_secret", shared_secret)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="httpServer")
    def http_server(self) -> Optional['outputs.LiveToolsWakeOnLanCallbackHttpServer']:
        """
        The webhook receiver used for the callback webhook.
        """
        return pulumi.get(self, "http_server")

    @_builtins.property
    @pulumi.getter(name="payloadTemplate")
    def payload_template(self) -> Optional['outputs.LiveToolsWakeOnLanCallbackPayloadTemplate']:
        """
        The payload template of the webhook used for the callback
        """
        return pulumi.get(self, "payload_template")

    @_builtins.property
    @pulumi.getter(name="sharedSecret")
    def shared_secret(self) -> Optional[_builtins.str]:
        """
        A shared secret that will be included in the requests sent to the callback URL. It can be used to verify that the request was sent by Meraki. If using this field, please also specify an url.
        """
        return pulumi.get(self, "shared_secret")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        The callback URL for the webhook target. If using this field, please also specify a sharedSecret.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class LiveToolsWakeOnLanCallbackHttpServer(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The webhook receiver ID that will receive information. If specifying this, please leave the url and sharedSecret fields blank.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsWakeOnLanCallbackPayloadTemplate(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the payload template. Defaults to 'wpt_00005' for the Callback (included) template.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class LiveToolsWakeOnLanRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vlanId":
            suggest = "vlan_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveToolsWakeOnLanRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveToolsWakeOnLanRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveToolsWakeOnLanRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 mac: Optional[_builtins.str] = None,
                 serial: Optional[_builtins.str] = None,
                 vlan_id: Optional[_builtins.int] = None):
        """
        :param _builtins.str mac: The target's MAC address
        :param _builtins.str serial: Device serial number
        :param _builtins.int vlan_id: The target's VLAN (1 to 4094)
        """
        if mac is not None:
            pulumi.set(__self__, "mac", mac)
        if serial is not None:
            pulumi.set(__self__, "serial", serial)
        if vlan_id is not None:
            pulumi.set(__self__, "vlan_id", vlan_id)

    @_builtins.property
    @pulumi.getter
    def mac(self) -> Optional[_builtins.str]:
        """
        The target's MAC address
        """
        return pulumi.get(self, "mac")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> Optional[_builtins.str]:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")

    @_builtins.property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> Optional[_builtins.int]:
        """
        The target's VLAN (1 to 4094)
        """
        return pulumi.get(self, "vlan_id")


@pulumi.output_type
class ManagementInterfaceDdnsHostnames(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "activeDdnsHostname":
            suggest = "active_ddns_hostname"
        elif key == "ddnsHostnameWan1":
            suggest = "ddns_hostname_wan1"
        elif key == "ddnsHostnameWan2":
            suggest = "ddns_hostname_wan2"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ManagementInterfaceDdnsHostnames. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ManagementInterfaceDdnsHostnames.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ManagementInterfaceDdnsHostnames.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 active_ddns_hostname: Optional[_builtins.str] = None,
                 ddns_hostname_wan1: Optional[_builtins.str] = None,
                 ddns_hostname_wan2: Optional[_builtins.str] = None):
        """
        :param _builtins.str active_ddns_hostname: Active dynamic DNS hostname.
        :param _builtins.str ddns_hostname_wan1: WAN 1 dynamic DNS hostname.
        :param _builtins.str ddns_hostname_wan2: WAN 2 dynamic DNS hostname.
        """
        if active_ddns_hostname is not None:
            pulumi.set(__self__, "active_ddns_hostname", active_ddns_hostname)
        if ddns_hostname_wan1 is not None:
            pulumi.set(__self__, "ddns_hostname_wan1", ddns_hostname_wan1)
        if ddns_hostname_wan2 is not None:
            pulumi.set(__self__, "ddns_hostname_wan2", ddns_hostname_wan2)

    @_builtins.property
    @pulumi.getter(name="activeDdnsHostname")
    def active_ddns_hostname(self) -> Optional[_builtins.str]:
        """
        Active dynamic DNS hostname.
        """
        return pulumi.get(self, "active_ddns_hostname")

    @_builtins.property
    @pulumi.getter(name="ddnsHostnameWan1")
    def ddns_hostname_wan1(self) -> Optional[_builtins.str]:
        """
        WAN 1 dynamic DNS hostname.
        """
        return pulumi.get(self, "ddns_hostname_wan1")

    @_builtins.property
    @pulumi.getter(name="ddnsHostnameWan2")
    def ddns_hostname_wan2(self) -> Optional[_builtins.str]:
        """
        WAN 2 dynamic DNS hostname.
        """
        return pulumi.get(self, "ddns_hostname_wan2")


@pulumi.output_type
class ManagementInterfaceWan1(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "staticDns":
            suggest = "static_dns"
        elif key == "staticGatewayIp":
            suggest = "static_gateway_ip"
        elif key == "staticIp":
            suggest = "static_ip"
        elif key == "staticSubnetMask":
            suggest = "static_subnet_mask"
        elif key == "usingStaticIp":
            suggest = "using_static_ip"
        elif key == "wanEnabled":
            suggest = "wan_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ManagementInterfaceWan1. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ManagementInterfaceWan1.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ManagementInterfaceWan1.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 static_dns: Optional[Sequence[_builtins.str]] = None,
                 static_gateway_ip: Optional[_builtins.str] = None,
                 static_ip: Optional[_builtins.str] = None,
                 static_subnet_mask: Optional[_builtins.str] = None,
                 using_static_ip: Optional[_builtins.bool] = None,
                 vlan: Optional[_builtins.int] = None,
                 wan_enabled: Optional[_builtins.str] = None):
        """
        :param Sequence[_builtins.str] static_dns: Up to two DNS IPs.
        :param _builtins.str static_gateway_ip: The IP of the gateway on the WAN.
        :param _builtins.str static_ip: The IP the device should use on the WAN.
        :param _builtins.str static_subnet_mask: The subnet mask for the WAN.
        :param _builtins.bool using_static_ip: Configure the interface to have static IP settings or use DHCP.
        :param _builtins.int vlan: The VLAN that management traffic should be tagged with. Applies whether usingStaticIp is true or false.
        :param _builtins.str wan_enabled: Enable or disable the interface (only for MX devices). Valid values are 'enabled', 'disabled', and 'not configured'.
        """
        if static_dns is not None:
            pulumi.set(__self__, "static_dns", static_dns)
        if static_gateway_ip is not None:
            pulumi.set(__self__, "static_gateway_ip", static_gateway_ip)
        if static_ip is not None:
            pulumi.set(__self__, "static_ip", static_ip)
        if static_subnet_mask is not None:
            pulumi.set(__self__, "static_subnet_mask", static_subnet_mask)
        if using_static_ip is not None:
            pulumi.set(__self__, "using_static_ip", using_static_ip)
        if vlan is not None:
            pulumi.set(__self__, "vlan", vlan)
        if wan_enabled is not None:
            pulumi.set(__self__, "wan_enabled", wan_enabled)

    @_builtins.property
    @pulumi.getter(name="staticDns")
    def static_dns(self) -> Optional[Sequence[_builtins.str]]:
        """
        Up to two DNS IPs.
        """
        return pulumi.get(self, "static_dns")

    @_builtins.property
    @pulumi.getter(name="staticGatewayIp")
    def static_gateway_ip(self) -> Optional[_builtins.str]:
        """
        The IP of the gateway on the WAN.
        """
        return pulumi.get(self, "static_gateway_ip")

    @_builtins.property
    @pulumi.getter(name="staticIp")
    def static_ip(self) -> Optional[_builtins.str]:
        """
        The IP the device should use on the WAN.
        """
        return pulumi.get(self, "static_ip")

    @_builtins.property
    @pulumi.getter(name="staticSubnetMask")
    def static_subnet_mask(self) -> Optional[_builtins.str]:
        """
        The subnet mask for the WAN.
        """
        return pulumi.get(self, "static_subnet_mask")

    @_builtins.property
    @pulumi.getter(name="usingStaticIp")
    def using_static_ip(self) -> Optional[_builtins.bool]:
        """
        Configure the interface to have static IP settings or use DHCP.
        """
        return pulumi.get(self, "using_static_ip")

    @_builtins.property
    @pulumi.getter
    def vlan(self) -> Optional[_builtins.int]:
        """
        The VLAN that management traffic should be tagged with. Applies whether usingStaticIp is true or false.
        """
        return pulumi.get(self, "vlan")

    @_builtins.property
    @pulumi.getter(name="wanEnabled")
    def wan_enabled(self) -> Optional[_builtins.str]:
        """
        Enable or disable the interface (only for MX devices). Valid values are 'enabled', 'disabled', and 'not configured'.
        """
        return pulumi.get(self, "wan_enabled")


@pulumi.output_type
class ManagementInterfaceWan2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "staticDns":
            suggest = "static_dns"
        elif key == "staticGatewayIp":
            suggest = "static_gateway_ip"
        elif key == "staticIp":
            suggest = "static_ip"
        elif key == "staticSubnetMask":
            suggest = "static_subnet_mask"
        elif key == "usingStaticIp":
            suggest = "using_static_ip"
        elif key == "wanEnabled":
            suggest = "wan_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ManagementInterfaceWan2. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ManagementInterfaceWan2.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ManagementInterfaceWan2.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 static_dns: Optional[Sequence[_builtins.str]] = None,
                 static_gateway_ip: Optional[_builtins.str] = None,
                 static_ip: Optional[_builtins.str] = None,
                 static_subnet_mask: Optional[_builtins.str] = None,
                 using_static_ip: Optional[_builtins.bool] = None,
                 vlan: Optional[_builtins.int] = None,
                 wan_enabled: Optional[_builtins.str] = None):
        """
        :param Sequence[_builtins.str] static_dns: Up to two DNS IPs.
        :param _builtins.str static_gateway_ip: The IP of the gateway on the WAN.
        :param _builtins.str static_ip: The IP the device should use on the WAN.
        :param _builtins.str static_subnet_mask: The subnet mask for the WAN.
        :param _builtins.bool using_static_ip: Configure the interface to have static IP settings or use DHCP.
        :param _builtins.int vlan: The VLAN that management traffic should be tagged with. Applies whether usingStaticIp is true or false.
        :param _builtins.str wan_enabled: Enable or disable the interface (only for MX devices). Valid values are 'enabled', 'disabled', and 'not configured'.
        """
        if static_dns is not None:
            pulumi.set(__self__, "static_dns", static_dns)
        if static_gateway_ip is not None:
            pulumi.set(__self__, "static_gateway_ip", static_gateway_ip)
        if static_ip is not None:
            pulumi.set(__self__, "static_ip", static_ip)
        if static_subnet_mask is not None:
            pulumi.set(__self__, "static_subnet_mask", static_subnet_mask)
        if using_static_ip is not None:
            pulumi.set(__self__, "using_static_ip", using_static_ip)
        if vlan is not None:
            pulumi.set(__self__, "vlan", vlan)
        if wan_enabled is not None:
            pulumi.set(__self__, "wan_enabled", wan_enabled)

    @_builtins.property
    @pulumi.getter(name="staticDns")
    def static_dns(self) -> Optional[Sequence[_builtins.str]]:
        """
        Up to two DNS IPs.
        """
        return pulumi.get(self, "static_dns")

    @_builtins.property
    @pulumi.getter(name="staticGatewayIp")
    def static_gateway_ip(self) -> Optional[_builtins.str]:
        """
        The IP of the gateway on the WAN.
        """
        return pulumi.get(self, "static_gateway_ip")

    @_builtins.property
    @pulumi.getter(name="staticIp")
    def static_ip(self) -> Optional[_builtins.str]:
        """
        The IP the device should use on the WAN.
        """
        return pulumi.get(self, "static_ip")

    @_builtins.property
    @pulumi.getter(name="staticSubnetMask")
    def static_subnet_mask(self) -> Optional[_builtins.str]:
        """
        The subnet mask for the WAN.
        """
        return pulumi.get(self, "static_subnet_mask")

    @_builtins.property
    @pulumi.getter(name="usingStaticIp")
    def using_static_ip(self) -> Optional[_builtins.bool]:
        """
        Configure the interface to have static IP settings or use DHCP.
        """
        return pulumi.get(self, "using_static_ip")

    @_builtins.property
    @pulumi.getter
    def vlan(self) -> Optional[_builtins.int]:
        """
        The VLAN that management traffic should be tagged with. Applies whether usingStaticIp is true or false.
        """
        return pulumi.get(self, "vlan")

    @_builtins.property
    @pulumi.getter(name="wanEnabled")
    def wan_enabled(self) -> Optional[_builtins.str]:
        """
        Enable or disable the interface (only for MX devices). Valid values are 'enabled', 'disabled', and 'not configured'.
        """
        return pulumi.get(self, "wan_enabled")


@pulumi.output_type
class SensorRelationshipsLivestream(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "relatedDevices":
            suggest = "related_devices"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SensorRelationshipsLivestream. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SensorRelationshipsLivestream.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SensorRelationshipsLivestream.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 related_devices: Optional[Sequence['outputs.SensorRelationshipsLivestreamRelatedDevice']] = None):
        """
        :param Sequence['SensorRelationshipsLivestreamRelatedDeviceArgs'] related_devices: An array of the related devices for the role
        """
        if related_devices is not None:
            pulumi.set(__self__, "related_devices", related_devices)

    @_builtins.property
    @pulumi.getter(name="relatedDevices")
    def related_devices(self) -> Optional[Sequence['outputs.SensorRelationshipsLivestreamRelatedDevice']]:
        """
        An array of the related devices for the role
        """
        return pulumi.get(self, "related_devices")


@pulumi.output_type
class SensorRelationshipsLivestreamRelatedDevice(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "productType":
            suggest = "product_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SensorRelationshipsLivestreamRelatedDevice. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SensorRelationshipsLivestreamRelatedDevice.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SensorRelationshipsLivestreamRelatedDevice.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 product_type: Optional[_builtins.str] = None,
                 serial: Optional[_builtins.str] = None):
        """
        :param _builtins.str product_type: The product type of the related device
        :param _builtins.str serial: The serial of the related device
        """
        if product_type is not None:
            pulumi.set(__self__, "product_type", product_type)
        if serial is not None:
            pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> Optional[_builtins.str]:
        """
        The product type of the related device
        """
        return pulumi.get(self, "product_type")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> Optional[_builtins.str]:
        """
        The serial of the related device
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class SensorRelationshipsLivestreamRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "relatedDevices":
            suggest = "related_devices"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SensorRelationshipsLivestreamRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SensorRelationshipsLivestreamRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SensorRelationshipsLivestreamRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 related_devices: Optional[Sequence['outputs.SensorRelationshipsLivestreamRequestRelatedDevice']] = None):
        """
        :param Sequence['SensorRelationshipsLivestreamRequestRelatedDeviceArgs'] related_devices: An array of the related devices for the role
        """
        if related_devices is not None:
            pulumi.set(__self__, "related_devices", related_devices)

    @_builtins.property
    @pulumi.getter(name="relatedDevices")
    def related_devices(self) -> Optional[Sequence['outputs.SensorRelationshipsLivestreamRequestRelatedDevice']]:
        """
        An array of the related devices for the role
        """
        return pulumi.get(self, "related_devices")


@pulumi.output_type
class SensorRelationshipsLivestreamRequestRelatedDevice(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "productType":
            suggest = "product_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SensorRelationshipsLivestreamRequestRelatedDevice. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SensorRelationshipsLivestreamRequestRelatedDevice.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SensorRelationshipsLivestreamRequestRelatedDevice.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 product_type: Optional[_builtins.str] = None,
                 serial: Optional[_builtins.str] = None):
        """
        :param _builtins.str product_type: The product type of the related device
        :param _builtins.str serial: The serial of the related device
        """
        if product_type is not None:
            pulumi.set(__self__, "product_type", product_type)
        if serial is not None:
            pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> Optional[_builtins.str]:
        """
        The product type of the related device
        """
        return pulumi.get(self, "product_type")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> Optional[_builtins.str]:
        """
        The serial of the related device
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class SwitchPortsCycleItem(dict):
    def __init__(__self__, *,
                 ports: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] ports: List of switch ports
        """
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @_builtins.property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[_builtins.str]]:
        """
        List of switch ports
        """
        return pulumi.get(self, "ports")


@pulumi.output_type
class SwitchPortsCycleParameters(dict):
    def __init__(__self__, *,
                 ports: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] ports: List of switch ports
        """
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @_builtins.property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[_builtins.str]]:
        """
        List of switch ports
        """
        return pulumi.get(self, "ports")


@pulumi.output_type
class SwitchPortsMirror(dict):
    def __init__(__self__, *,
                 mode: Optional[_builtins.str] = None):
        """
        :param _builtins.str mode: The port mirror mode. Can be one of ('Destination port', 'Source port' or 'Not mirroring traffic').
        """
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional[_builtins.str]:
        """
        The port mirror mode. Can be one of ('Destination port', 'Source port' or 'Not mirroring traffic').
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class SwitchPortsModule(dict):
    def __init__(__self__, *,
                 model: Optional[_builtins.str] = None):
        """
        :param _builtins.str model: The model of the expansion module.
        """
        if model is not None:
            pulumi.set(__self__, "model", model)

    @_builtins.property
    @pulumi.getter
    def model(self) -> Optional[_builtins.str]:
        """
        The model of the expansion module.
        """
        return pulumi.get(self, "model")


@pulumi.output_type
class SwitchPortsProfile(dict):
    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None,
                 id: Optional[_builtins.str] = None,
                 iname: Optional[_builtins.str] = None):
        """
        :param _builtins.bool enabled: When enabled, override this port's configuration with a port profile.
        :param _builtins.str id: When enabled, the ID of the port profile used to override the port's configuration.
        :param _builtins.str iname: When enabled, the IName of the profile.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if iname is not None:
            pulumi.set(__self__, "iname", iname)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        When enabled, override this port's configuration with a port profile.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        When enabled, the ID of the port profile used to override the port's configuration.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def iname(self) -> Optional[_builtins.str]:
        """
        When enabled, the IName of the profile.
        """
        return pulumi.get(self, "iname")


@pulumi.output_type
class SwitchRoutingInterfacesDhcpDhcpOption(dict):
    def __init__(__self__, *,
                 code: Optional[_builtins.str] = None,
                 type: Optional[_builtins.str] = None,
                 value: Optional[_builtins.str] = None):
        """
        :param _builtins.str code: The code for DHCP option which should be from 2 to 254
        :param _builtins.str type: The type of the DHCP option which should be one of ('text', 'ip', 'integer' or 'hex')
        :param _builtins.str value: The value of the DHCP option
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def code(self) -> Optional[_builtins.str]:
        """
        The code for DHCP option which should be from 2 to 254
        """
        return pulumi.get(self, "code")

    @_builtins.property
    @pulumi.getter
    def type(self) -> Optional[_builtins.str]:
        """
        The type of the DHCP option which should be one of ('text', 'ip', 'integer' or 'hex')
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def value(self) -> Optional[_builtins.str]:
        """
        The value of the DHCP option
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class SwitchRoutingInterfacesDhcpFixedIpAssignment(dict):
    def __init__(__self__, *,
                 ip: Optional[_builtins.str] = None,
                 mac: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.str ip: The IP address of the client which has fixed IP address assigned to it
        :param _builtins.str mac: The MAC address of the client which has fixed IP address
        :param _builtins.str name: The name of the client which has fixed IP address
        """
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if mac is not None:
            pulumi.set(__self__, "mac", mac)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def ip(self) -> Optional[_builtins.str]:
        """
        The IP address of the client which has fixed IP address assigned to it
        """
        return pulumi.get(self, "ip")

    @_builtins.property
    @pulumi.getter
    def mac(self) -> Optional[_builtins.str]:
        """
        The MAC address of the client which has fixed IP address
        """
        return pulumi.get(self, "mac")

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        The name of the client which has fixed IP address
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class SwitchRoutingInterfacesDhcpReservedIpRange(dict):
    def __init__(__self__, *,
                 comment: Optional[_builtins.str] = None,
                 end: Optional[_builtins.str] = None,
                 start: Optional[_builtins.str] = None):
        """
        :param _builtins.str comment: The comment for the reserved IP range
        :param _builtins.str end: The ending IP address of the reserved IP range
        :param _builtins.str start: The starting IP address of the reserved IP range
        """
        if comment is not None:
            pulumi.set(__self__, "comment", comment)
        if end is not None:
            pulumi.set(__self__, "end", end)
        if start is not None:
            pulumi.set(__self__, "start", start)

    @_builtins.property
    @pulumi.getter
    def comment(self) -> Optional[_builtins.str]:
        """
        The comment for the reserved IP range
        """
        return pulumi.get(self, "comment")

    @_builtins.property
    @pulumi.getter
    def end(self) -> Optional[_builtins.str]:
        """
        The ending IP address of the reserved IP range
        """
        return pulumi.get(self, "end")

    @_builtins.property
    @pulumi.getter
    def start(self) -> Optional[_builtins.str]:
        """
        The starting IP address of the reserved IP range
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class SwitchRoutingInterfacesIpv6(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "assignmentMode":
            suggest = "assignment_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SwitchRoutingInterfacesIpv6. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SwitchRoutingInterfacesIpv6.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SwitchRoutingInterfacesIpv6.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[_builtins.str] = None,
                 assignment_mode: Optional[_builtins.str] = None,
                 gateway: Optional[_builtins.str] = None,
                 prefix: Optional[_builtins.str] = None):
        """
        :param _builtins.str address: IPv6 address
        :param _builtins.str assignment_mode: Assignment mode
        :param _builtins.str gateway: IPv6 gateway
        :param _builtins.str prefix: IPv6 subnet
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if assignment_mode is not None:
            pulumi.set(__self__, "assignment_mode", assignment_mode)
        if gateway is not None:
            pulumi.set(__self__, "gateway", gateway)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @_builtins.property
    @pulumi.getter
    def address(self) -> Optional[_builtins.str]:
        """
        IPv6 address
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> Optional[_builtins.str]:
        """
        Assignment mode
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> Optional[_builtins.str]:
        """
        IPv6 gateway
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def prefix(self) -> Optional[_builtins.str]:
        """
        IPv6 subnet
        """
        return pulumi.get(self, "prefix")


@pulumi.output_type
class SwitchRoutingInterfacesOspfSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isPassiveEnabled":
            suggest = "is_passive_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SwitchRoutingInterfacesOspfSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SwitchRoutingInterfacesOspfSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SwitchRoutingInterfacesOspfSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 area: Optional[_builtins.str] = None,
                 cost: Optional[_builtins.int] = None,
                 is_passive_enabled: Optional[_builtins.bool] = None):
        """
        :param _builtins.str area: Area id
        :param _builtins.int cost: OSPF Cost
        :param _builtins.bool is_passive_enabled: Disable sending Hello packets on this interface's IPv4 area
        """
        if area is not None:
            pulumi.set(__self__, "area", area)
        if cost is not None:
            pulumi.set(__self__, "cost", cost)
        if is_passive_enabled is not None:
            pulumi.set(__self__, "is_passive_enabled", is_passive_enabled)

    @_builtins.property
    @pulumi.getter
    def area(self) -> Optional[_builtins.str]:
        """
        Area id
        """
        return pulumi.get(self, "area")

    @_builtins.property
    @pulumi.getter
    def cost(self) -> Optional[_builtins.int]:
        """
        OSPF Cost
        """
        return pulumi.get(self, "cost")

    @_builtins.property
    @pulumi.getter(name="isPassiveEnabled")
    def is_passive_enabled(self) -> Optional[_builtins.bool]:
        """
        Disable sending Hello packets on this interface's IPv4 area
        """
        return pulumi.get(self, "is_passive_enabled")


@pulumi.output_type
class SwitchRoutingInterfacesOspfV3(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isPassiveEnabled":
            suggest = "is_passive_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SwitchRoutingInterfacesOspfV3. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SwitchRoutingInterfacesOspfV3.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SwitchRoutingInterfacesOspfV3.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 area: Optional[_builtins.str] = None,
                 cost: Optional[_builtins.int] = None,
                 is_passive_enabled: Optional[_builtins.bool] = None):
        """
        :param _builtins.str area: Area id
        :param _builtins.int cost: OSPF Cost
        :param _builtins.bool is_passive_enabled: Disable sending Hello packets on this interface's IPv6 area
        """
        if area is not None:
            pulumi.set(__self__, "area", area)
        if cost is not None:
            pulumi.set(__self__, "cost", cost)
        if is_passive_enabled is not None:
            pulumi.set(__self__, "is_passive_enabled", is_passive_enabled)

    @_builtins.property
    @pulumi.getter
    def area(self) -> Optional[_builtins.str]:
        """
        Area id
        """
        return pulumi.get(self, "area")

    @_builtins.property
    @pulumi.getter
    def cost(self) -> Optional[_builtins.int]:
        """
        OSPF Cost
        """
        return pulumi.get(self, "cost")

    @_builtins.property
    @pulumi.getter(name="isPassiveEnabled")
    def is_passive_enabled(self) -> Optional[_builtins.bool]:
        """
        Disable sending Hello packets on this interface's IPv6 area
        """
        return pulumi.get(self, "is_passive_enabled")


@pulumi.output_type
class WirelessAlternateManagementInterfaceIpv6Item(dict):
    def __init__(__self__, *,
                 addresses: Optional[Sequence['outputs.WirelessAlternateManagementInterfaceIpv6ItemAddress']] = None):
        """
        :param Sequence['WirelessAlternateManagementInterfaceIpv6ItemAddressArgs'] addresses: configured alternate management interface addresses
        """
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence['outputs.WirelessAlternateManagementInterfaceIpv6ItemAddress']]:
        """
        configured alternate management interface addresses
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class WirelessAlternateManagementInterfaceIpv6ItemAddress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "assignmentMode":
            suggest = "assignment_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WirelessAlternateManagementInterfaceIpv6ItemAddress. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WirelessAlternateManagementInterfaceIpv6ItemAddress.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WirelessAlternateManagementInterfaceIpv6ItemAddress.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[_builtins.str] = None,
                 assignment_mode: Optional[_builtins.str] = None,
                 gateway: Optional[_builtins.str] = None,
                 nameservers: Optional['outputs.WirelessAlternateManagementInterfaceIpv6ItemAddressNameservers'] = None,
                 prefix: Optional[_builtins.str] = None,
                 protocol: Optional[_builtins.str] = None):
        """
        :param _builtins.str address: The IP address configured for the alternate management interface
        :param _builtins.str assignment_mode: The type of address assignment. Either static or dynamic.
        :param _builtins.str gateway: The gateway address configured for the alternate managment interface
        :param 'WirelessAlternateManagementInterfaceIpv6ItemAddressNameserversArgs' nameservers: The DNS servers settings for this address.
        :param _builtins.str prefix: The IPv6 prefix of the interface. Required if IPv6 object is included.
        :param _builtins.str protocol: The IP protocol used for the address
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if assignment_mode is not None:
            pulumi.set(__self__, "assignment_mode", assignment_mode)
        if gateway is not None:
            pulumi.set(__self__, "gateway", gateway)
        if nameservers is not None:
            pulumi.set(__self__, "nameservers", nameservers)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @_builtins.property
    @pulumi.getter
    def address(self) -> Optional[_builtins.str]:
        """
        The IP address configured for the alternate management interface
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> Optional[_builtins.str]:
        """
        The type of address assignment. Either static or dynamic.
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> Optional[_builtins.str]:
        """
        The gateway address configured for the alternate managment interface
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def nameservers(self) -> Optional['outputs.WirelessAlternateManagementInterfaceIpv6ItemAddressNameservers']:
        """
        The DNS servers settings for this address.
        """
        return pulumi.get(self, "nameservers")

    @_builtins.property
    @pulumi.getter
    def prefix(self) -> Optional[_builtins.str]:
        """
        The IPv6 prefix of the interface. Required if IPv6 object is included.
        """
        return pulumi.get(self, "prefix")

    @_builtins.property
    @pulumi.getter
    def protocol(self) -> Optional[_builtins.str]:
        """
        The IP protocol used for the address
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class WirelessAlternateManagementInterfaceIpv6ItemAddressNameservers(dict):
    def __init__(__self__, *,
                 addresses: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] addresses: Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence[_builtins.str]]:
        """
        Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class WirelessAlternateManagementInterfaceIpv6Parameters(dict):
    def __init__(__self__, *,
                 addresses: Optional[Sequence['outputs.WirelessAlternateManagementInterfaceIpv6ParametersAddress']] = None):
        """
        :param Sequence['WirelessAlternateManagementInterfaceIpv6ParametersAddressArgs'] addresses: configured alternate management interface addresses
        """
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence['outputs.WirelessAlternateManagementInterfaceIpv6ParametersAddress']]:
        """
        configured alternate management interface addresses
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class WirelessAlternateManagementInterfaceIpv6ParametersAddress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "assignmentMode":
            suggest = "assignment_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WirelessAlternateManagementInterfaceIpv6ParametersAddress. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WirelessAlternateManagementInterfaceIpv6ParametersAddress.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WirelessAlternateManagementInterfaceIpv6ParametersAddress.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[_builtins.str] = None,
                 assignment_mode: Optional[_builtins.str] = None,
                 gateway: Optional[_builtins.str] = None,
                 nameservers: Optional['outputs.WirelessAlternateManagementInterfaceIpv6ParametersAddressNameservers'] = None,
                 prefix: Optional[_builtins.str] = None,
                 protocol: Optional[_builtins.str] = None):
        """
        :param _builtins.str address: The IP address configured for the alternate management interface
        :param _builtins.str assignment_mode: The type of address assignment. Either static or dynamic.
        :param _builtins.str gateway: The gateway address configured for the alternate managment interface
        :param 'WirelessAlternateManagementInterfaceIpv6ParametersAddressNameserversArgs' nameservers: The DNS servers settings for this address.
        :param _builtins.str prefix: The IPv6 prefix length of the IPv6 interface. Required if IPv6 object is included.
        :param _builtins.str protocol: The IP protocol used for the address
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if assignment_mode is not None:
            pulumi.set(__self__, "assignment_mode", assignment_mode)
        if gateway is not None:
            pulumi.set(__self__, "gateway", gateway)
        if nameservers is not None:
            pulumi.set(__self__, "nameservers", nameservers)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @_builtins.property
    @pulumi.getter
    def address(self) -> Optional[_builtins.str]:
        """
        The IP address configured for the alternate management interface
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> Optional[_builtins.str]:
        """
        The type of address assignment. Either static or dynamic.
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> Optional[_builtins.str]:
        """
        The gateway address configured for the alternate managment interface
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def nameservers(self) -> Optional['outputs.WirelessAlternateManagementInterfaceIpv6ParametersAddressNameservers']:
        """
        The DNS servers settings for this address.
        """
        return pulumi.get(self, "nameservers")

    @_builtins.property
    @pulumi.getter
    def prefix(self) -> Optional[_builtins.str]:
        """
        The IPv6 prefix length of the IPv6 interface. Required if IPv6 object is included.
        """
        return pulumi.get(self, "prefix")

    @_builtins.property
    @pulumi.getter
    def protocol(self) -> Optional[_builtins.str]:
        """
        The IP protocol used for the address
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class WirelessAlternateManagementInterfaceIpv6ParametersAddressNameservers(dict):
    def __init__(__self__, *,
                 addresses: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] addresses: Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence[_builtins.str]]:
        """
        Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class WirelessRadioSettingsFiveGhzSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "channelWidth":
            suggest = "channel_width"
        elif key == "targetPower":
            suggest = "target_power"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WirelessRadioSettingsFiveGhzSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WirelessRadioSettingsFiveGhzSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WirelessRadioSettingsFiveGhzSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 channel: Optional[_builtins.int] = None,
                 channel_width: Optional[_builtins.str] = None,
                 target_power: Optional[_builtins.int] = None):
        """
        :param _builtins.int channel: Sets a manual channel for 5 GHz. Can be '36', '40', '44', '48', '52', '56', '60', '64', '100', '104', '108', '112', '116', '120', '124', '128', '132', '136', '140', '144', '149', '153', '157', '161', '165', '169', '173' or '177' or null for using auto channel.
        :param _builtins.str channel_width: Sets a manual channel for 5 GHz. Can be '0', '20', '40', '80' or '160' or null for using auto channel width.
        :param _builtins.int target_power: Set a manual target power for 5 GHz. Can be between '8' or '30' or null for using auto power range.
        """
        if channel is not None:
            pulumi.set(__self__, "channel", channel)
        if channel_width is not None:
            pulumi.set(__self__, "channel_width", channel_width)
        if target_power is not None:
            pulumi.set(__self__, "target_power", target_power)

    @_builtins.property
    @pulumi.getter
    def channel(self) -> Optional[_builtins.int]:
        """
        Sets a manual channel for 5 GHz. Can be '36', '40', '44', '48', '52', '56', '60', '64', '100', '104', '108', '112', '116', '120', '124', '128', '132', '136', '140', '144', '149', '153', '157', '161', '165', '169', '173' or '177' or null for using auto channel.
        """
        return pulumi.get(self, "channel")

    @_builtins.property
    @pulumi.getter(name="channelWidth")
    def channel_width(self) -> Optional[_builtins.str]:
        """
        Sets a manual channel for 5 GHz. Can be '0', '20', '40', '80' or '160' or null for using auto channel width.
        """
        return pulumi.get(self, "channel_width")

    @_builtins.property
    @pulumi.getter(name="targetPower")
    def target_power(self) -> Optional[_builtins.int]:
        """
        Set a manual target power for 5 GHz. Can be between '8' or '30' or null for using auto power range.
        """
        return pulumi.get(self, "target_power")


@pulumi.output_type
class WirelessRadioSettingsTwoFourGhzSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetPower":
            suggest = "target_power"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WirelessRadioSettingsTwoFourGhzSettings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WirelessRadioSettingsTwoFourGhzSettings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WirelessRadioSettingsTwoFourGhzSettings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 channel: Optional[_builtins.int] = None,
                 target_power: Optional[_builtins.int] = None):
        """
        :param _builtins.int channel: Sets a manual channel for 2.4 GHz. Can be '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13' or '14' or null for using auto channel.
        :param _builtins.int target_power: Set a manual target power for 2.4 GHz. Can be between '5' or '30' or null for using auto power range.
        """
        if channel is not None:
            pulumi.set(__self__, "channel", channel)
        if target_power is not None:
            pulumi.set(__self__, "target_power", target_power)

    @_builtins.property
    @pulumi.getter
    def channel(self) -> Optional[_builtins.int]:
        """
        Sets a manual channel for 2.4 GHz. Can be '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13' or '14' or null for using auto channel.
        """
        return pulumi.get(self, "channel")

    @_builtins.property
    @pulumi.getter(name="targetPower")
    def target_power(self) -> Optional[_builtins.int]:
        """
        Set a manual target power for 2.4 GHz. Can be between '5' or '30' or null for using auto power range.
        """
        return pulumi.get(self, "target_power")


@pulumi.output_type
class BaseDetail(dict):
    def __init__(__self__, *,
                 name: Optional[_builtins.str] = None,
                 value: Optional[_builtins.str] = None):
        """
        :param _builtins.str name: Additional property name
        :param _builtins.str value: Additional property value
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        Additional property name
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter
    def value(self) -> Optional[_builtins.str]:
        """
        Additional property value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetAppliancePerformanceItemResult(dict):
    def __init__(__self__, *,
                 perf_score: _builtins.int):
        pulumi.set(__self__, "perf_score", perf_score)

    @_builtins.property
    @pulumi.getter(name="perfScore")
    def perf_score(self) -> _builtins.int:
        return pulumi.get(self, "perf_score")


@pulumi.output_type
class GetApplianceRadioSettingsItemResult(dict):
    def __init__(__self__, *,
                 five_ghz_settings: 'outputs.GetApplianceRadioSettingsItemFiveGhzSettingsResult',
                 rf_profile_id: _builtins.str,
                 serial: _builtins.str,
                 two_four_ghz_settings: 'outputs.GetApplianceRadioSettingsItemTwoFourGhzSettingsResult'):
        """
        :param 'GetApplianceRadioSettingsItemFiveGhzSettingsArgs' five_ghz_settings: Manual radio settings for 5 GHz
        :param _builtins.str rf_profile_id: RF Profile ID
        :param _builtins.str serial: The device serial
        :param 'GetApplianceRadioSettingsItemTwoFourGhzSettingsArgs' two_four_ghz_settings: Manual radio settings for 2.4 GHz
        """
        pulumi.set(__self__, "five_ghz_settings", five_ghz_settings)
        pulumi.set(__self__, "rf_profile_id", rf_profile_id)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "two_four_ghz_settings", two_four_ghz_settings)

    @_builtins.property
    @pulumi.getter(name="fiveGhzSettings")
    def five_ghz_settings(self) -> 'outputs.GetApplianceRadioSettingsItemFiveGhzSettingsResult':
        """
        Manual radio settings for 5 GHz
        """
        return pulumi.get(self, "five_ghz_settings")

    @_builtins.property
    @pulumi.getter(name="rfProfileId")
    def rf_profile_id(self) -> _builtins.str:
        """
        RF Profile ID
        """
        return pulumi.get(self, "rf_profile_id")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        The device serial
        """
        return pulumi.get(self, "serial")

    @_builtins.property
    @pulumi.getter(name="twoFourGhzSettings")
    def two_four_ghz_settings(self) -> 'outputs.GetApplianceRadioSettingsItemTwoFourGhzSettingsResult':
        """
        Manual radio settings for 2.4 GHz
        """
        return pulumi.get(self, "two_four_ghz_settings")


@pulumi.output_type
class GetApplianceRadioSettingsItemFiveGhzSettingsResult(dict):
    def __init__(__self__, *,
                 channel: _builtins.int,
                 channel_width: _builtins.int,
                 target_power: _builtins.int):
        """
        :param _builtins.int channel: Manual channel for 5 GHz
        :param _builtins.int channel_width: Manual channel width for 5 GHz
        :param _builtins.int target_power: Manual target power for 5 GHz
        """
        pulumi.set(__self__, "channel", channel)
        pulumi.set(__self__, "channel_width", channel_width)
        pulumi.set(__self__, "target_power", target_power)

    @_builtins.property
    @pulumi.getter
    def channel(self) -> _builtins.int:
        """
        Manual channel for 5 GHz
        """
        return pulumi.get(self, "channel")

    @_builtins.property
    @pulumi.getter(name="channelWidth")
    def channel_width(self) -> _builtins.int:
        """
        Manual channel width for 5 GHz
        """
        return pulumi.get(self, "channel_width")

    @_builtins.property
    @pulumi.getter(name="targetPower")
    def target_power(self) -> _builtins.int:
        """
        Manual target power for 5 GHz
        """
        return pulumi.get(self, "target_power")


@pulumi.output_type
class GetApplianceRadioSettingsItemTwoFourGhzSettingsResult(dict):
    def __init__(__self__, *,
                 channel: _builtins.int,
                 target_power: _builtins.int):
        """
        :param _builtins.int channel: Manual channel for 2.4 GHz
        :param _builtins.int target_power: Manual target power for 2.4 GHz
        """
        pulumi.set(__self__, "channel", channel)
        pulumi.set(__self__, "target_power", target_power)

    @_builtins.property
    @pulumi.getter
    def channel(self) -> _builtins.int:
        """
        Manual channel for 2.4 GHz
        """
        return pulumi.get(self, "channel")

    @_builtins.property
    @pulumi.getter(name="targetPower")
    def target_power(self) -> _builtins.int:
        """
        Manual target power for 2.4 GHz
        """
        return pulumi.get(self, "target_power")


@pulumi.output_type
class GetApplianceUplinksSettingsItemResult(dict):
    def __init__(__self__, *,
                 interfaces: 'outputs.GetApplianceUplinksSettingsItemInterfacesResult'):
        """
        :param 'GetApplianceUplinksSettingsItemInterfacesArgs' interfaces: Interface settings.
        """
        pulumi.set(__self__, "interfaces", interfaces)

    @_builtins.property
    @pulumi.getter
    def interfaces(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesResult':
        """
        Interface settings.
        """
        return pulumi.get(self, "interfaces")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesResult(dict):
    def __init__(__self__, *,
                 wan1: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1Result',
                 wan2: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2Result'):
        """
        :param 'GetApplianceUplinksSettingsItemInterfacesWan1Args' wan1: WAN 1 settings.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan2Args' wan2: WAN 2 settings.
        """
        pulumi.set(__self__, "wan1", wan1)
        pulumi.set(__self__, "wan2", wan2)

    @_builtins.property
    @pulumi.getter
    def wan1(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1Result':
        """
        WAN 1 settings.
        """
        return pulumi.get(self, "wan1")

    @_builtins.property
    @pulumi.getter
    def wan2(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2Result':
        """
        WAN 2 settings.
        """
        return pulumi.get(self, "wan2")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan1Result(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 pppoe: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1PppoeResult',
                 svis: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1SvisResult',
                 vlan_tagging: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1VlanTaggingResult'):
        """
        :param _builtins.bool enabled: Enable or disable the interface.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan1PppoeArgs' pppoe: Configuration options for PPPoE.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan1SvisArgs' svis: SVI settings by protocol.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan1VlanTaggingArgs' vlan_tagging: VLAN tagging settings.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "pppoe", pppoe)
        pulumi.set(__self__, "svis", svis)
        pulumi.set(__self__, "vlan_tagging", vlan_tagging)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Enable or disable the interface.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def pppoe(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1PppoeResult':
        """
        Configuration options for PPPoE.
        """
        return pulumi.get(self, "pppoe")

    @_builtins.property
    @pulumi.getter
    def svis(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1SvisResult':
        """
        SVI settings by protocol.
        """
        return pulumi.get(self, "svis")

    @_builtins.property
    @pulumi.getter(name="vlanTagging")
    def vlan_tagging(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1VlanTaggingResult':
        """
        VLAN tagging settings.
        """
        return pulumi.get(self, "vlan_tagging")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan1PppoeResult(dict):
    def __init__(__self__, *,
                 authentication: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1PppoeAuthenticationResult',
                 enabled: _builtins.bool):
        """
        :param 'GetApplianceUplinksSettingsItemInterfacesWan1PppoeAuthenticationArgs' authentication: Settings for PPPoE Authentication.
        :param _builtins.bool enabled: Whether PPPoE is enabled.
        """
        pulumi.set(__self__, "authentication", authentication)
        pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def authentication(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1PppoeAuthenticationResult':
        """
        Settings for PPPoE Authentication.
        """
        return pulumi.get(self, "authentication")

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Whether PPPoE is enabled.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan1PppoeAuthenticationResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 username: _builtins.str):
        """
        :param _builtins.bool enabled: Whether PPPoE authentication is enabled.
        :param _builtins.str username: Username for PPPoE authentication.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Whether PPPoE authentication is enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def username(self) -> _builtins.str:
        """
        Username for PPPoE authentication.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan1SvisResult(dict):
    def __init__(__self__, *,
                 ipv4: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv4Result',
                 ipv6: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv6Result'):
        """
        :param 'GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv4Args' ipv4: IPv4 settings for static/dynamic mode.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv6Args' ipv6: IPv6 settings for static/dynamic mode.
        """
        pulumi.set(__self__, "ipv4", ipv4)
        pulumi.set(__self__, "ipv6", ipv6)

    @_builtins.property
    @pulumi.getter
    def ipv4(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv4Result':
        """
        IPv4 settings for static/dynamic mode.
        """
        return pulumi.get(self, "ipv4")

    @_builtins.property
    @pulumi.getter
    def ipv6(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv6Result':
        """
        IPv6 settings for static/dynamic mode.
        """
        return pulumi.get(self, "ipv6")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv4Result(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 assignment_mode: _builtins.str,
                 gateway: _builtins.str,
                 nameservers: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv4NameserversResult'):
        """
        :param _builtins.str address: IP address and subnet mask when in static mode.
        :param _builtins.str assignment_mode: The assignment mode for this SVI. Applies only when PPPoE is disabled.
        :param _builtins.str gateway: Gateway IP address when in static mode.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv4NameserversArgs' nameservers: The nameserver settings for this SVI.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "assignment_mode", assignment_mode)
        pulumi.set(__self__, "gateway", gateway)
        pulumi.set(__self__, "nameservers", nameservers)

    @_builtins.property
    @pulumi.getter
    def address(self) -> _builtins.str:
        """
        IP address and subnet mask when in static mode.
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> _builtins.str:
        """
        The assignment mode for this SVI. Applies only when PPPoE is disabled.
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> _builtins.str:
        """
        Gateway IP address when in static mode.
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def nameservers(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv4NameserversResult':
        """
        The nameserver settings for this SVI.
        """
        return pulumi.get(self, "nameservers")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv4NameserversResult(dict):
    def __init__(__self__, *,
                 addresses: Sequence[_builtins.str]):
        """
        :param Sequence[_builtins.str] addresses: Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Sequence[_builtins.str]:
        """
        Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv6Result(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 assignment_mode: _builtins.str,
                 gateway: _builtins.str,
                 nameservers: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv6NameserversResult'):
        """
        :param _builtins.str address: Static address that will override the one(s) received by SLAAC.
        :param _builtins.str assignment_mode: The assignment mode for this SVI. Applies only when PPPoE is disabled.
        :param _builtins.str gateway: Static gateway that will override the one received by autoconf.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv6NameserversArgs' nameservers: The nameserver settings for this SVI.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "assignment_mode", assignment_mode)
        pulumi.set(__self__, "gateway", gateway)
        pulumi.set(__self__, "nameservers", nameservers)

    @_builtins.property
    @pulumi.getter
    def address(self) -> _builtins.str:
        """
        Static address that will override the one(s) received by SLAAC.
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> _builtins.str:
        """
        The assignment mode for this SVI. Applies only when PPPoE is disabled.
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> _builtins.str:
        """
        Static gateway that will override the one received by autoconf.
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def nameservers(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv6NameserversResult':
        """
        The nameserver settings for this SVI.
        """
        return pulumi.get(self, "nameservers")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan1SvisIpv6NameserversResult(dict):
    def __init__(__self__, *,
                 addresses: Sequence[_builtins.str]):
        """
        :param Sequence[_builtins.str] addresses: Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Sequence[_builtins.str]:
        """
        Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan1VlanTaggingResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 vlan_id: _builtins.int):
        """
        :param _builtins.bool enabled: Whether VLAN tagging is enabled.
        :param _builtins.int vlan_id: The ID of the VLAN to use for VLAN tagging.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "vlan_id", vlan_id)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Whether VLAN tagging is enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> _builtins.int:
        """
        The ID of the VLAN to use for VLAN tagging.
        """
        return pulumi.get(self, "vlan_id")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan2Result(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 pppoe: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2PppoeResult',
                 svis: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2SvisResult',
                 vlan_tagging: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2VlanTaggingResult'):
        """
        :param _builtins.bool enabled: Enable or disable the interface.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan2PppoeArgs' pppoe: Configuration options for PPPoE.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan2SvisArgs' svis: SVI settings by protocol.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan2VlanTaggingArgs' vlan_tagging: VLAN tagging settings.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "pppoe", pppoe)
        pulumi.set(__self__, "svis", svis)
        pulumi.set(__self__, "vlan_tagging", vlan_tagging)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Enable or disable the interface.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def pppoe(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2PppoeResult':
        """
        Configuration options for PPPoE.
        """
        return pulumi.get(self, "pppoe")

    @_builtins.property
    @pulumi.getter
    def svis(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2SvisResult':
        """
        SVI settings by protocol.
        """
        return pulumi.get(self, "svis")

    @_builtins.property
    @pulumi.getter(name="vlanTagging")
    def vlan_tagging(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2VlanTaggingResult':
        """
        VLAN tagging settings.
        """
        return pulumi.get(self, "vlan_tagging")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan2PppoeResult(dict):
    def __init__(__self__, *,
                 authentication: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2PppoeAuthenticationResult',
                 enabled: _builtins.bool):
        """
        :param 'GetApplianceUplinksSettingsItemInterfacesWan2PppoeAuthenticationArgs' authentication: Settings for PPPoE Authentication.
        :param _builtins.bool enabled: Whether PPPoE is enabled.
        """
        pulumi.set(__self__, "authentication", authentication)
        pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def authentication(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2PppoeAuthenticationResult':
        """
        Settings for PPPoE Authentication.
        """
        return pulumi.get(self, "authentication")

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Whether PPPoE is enabled.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan2PppoeAuthenticationResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 username: _builtins.str):
        """
        :param _builtins.bool enabled: Whether PPPoE authentication is enabled.
        :param _builtins.str username: Username for PPPoE authentication.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Whether PPPoE authentication is enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def username(self) -> _builtins.str:
        """
        Username for PPPoE authentication.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan2SvisResult(dict):
    def __init__(__self__, *,
                 ipv4: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv4Result',
                 ipv6: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv6Result'):
        """
        :param 'GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv4Args' ipv4: IPv4 settings for static/dynamic mode.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv6Args' ipv6: IPv6 settings for static/dynamic mode.
        """
        pulumi.set(__self__, "ipv4", ipv4)
        pulumi.set(__self__, "ipv6", ipv6)

    @_builtins.property
    @pulumi.getter
    def ipv4(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv4Result':
        """
        IPv4 settings for static/dynamic mode.
        """
        return pulumi.get(self, "ipv4")

    @_builtins.property
    @pulumi.getter
    def ipv6(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv6Result':
        """
        IPv6 settings for static/dynamic mode.
        """
        return pulumi.get(self, "ipv6")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv4Result(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 assignment_mode: _builtins.str,
                 gateway: _builtins.str,
                 nameservers: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv4NameserversResult'):
        """
        :param _builtins.str address: IP address and subnet mask when in static mode.
        :param _builtins.str assignment_mode: The assignment mode for this SVI. Applies only when PPPoE is disabled.
        :param _builtins.str gateway: Gateway IP address when in static mode.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv4NameserversArgs' nameservers: The nameserver settings for this SVI.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "assignment_mode", assignment_mode)
        pulumi.set(__self__, "gateway", gateway)
        pulumi.set(__self__, "nameservers", nameservers)

    @_builtins.property
    @pulumi.getter
    def address(self) -> _builtins.str:
        """
        IP address and subnet mask when in static mode.
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> _builtins.str:
        """
        The assignment mode for this SVI. Applies only when PPPoE is disabled.
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> _builtins.str:
        """
        Gateway IP address when in static mode.
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def nameservers(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv4NameserversResult':
        """
        The nameserver settings for this SVI.
        """
        return pulumi.get(self, "nameservers")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv4NameserversResult(dict):
    def __init__(__self__, *,
                 addresses: Sequence[_builtins.str]):
        """
        :param Sequence[_builtins.str] addresses: Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Sequence[_builtins.str]:
        """
        Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv6Result(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 assignment_mode: _builtins.str,
                 gateway: _builtins.str,
                 nameservers: 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv6NameserversResult'):
        """
        :param _builtins.str address: Static address that will override the one(s) received by SLAAC.
        :param _builtins.str assignment_mode: The assignment mode for this SVI. Applies only when PPPoE is disabled.
        :param _builtins.str gateway: Static gateway that will override the one received by autoconf.
        :param 'GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv6NameserversArgs' nameservers: The nameserver settings for this SVI.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "assignment_mode", assignment_mode)
        pulumi.set(__self__, "gateway", gateway)
        pulumi.set(__self__, "nameservers", nameservers)

    @_builtins.property
    @pulumi.getter
    def address(self) -> _builtins.str:
        """
        Static address that will override the one(s) received by SLAAC.
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> _builtins.str:
        """
        The assignment mode for this SVI. Applies only when PPPoE is disabled.
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> _builtins.str:
        """
        Static gateway that will override the one received by autoconf.
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def nameservers(self) -> 'outputs.GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv6NameserversResult':
        """
        The nameserver settings for this SVI.
        """
        return pulumi.get(self, "nameservers")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan2SvisIpv6NameserversResult(dict):
    def __init__(__self__, *,
                 addresses: Sequence[_builtins.str]):
        """
        :param Sequence[_builtins.str] addresses: Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        pulumi.set(__self__, "addresses", addresses)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Sequence[_builtins.str]:
        """
        Up to 2 nameserver addresses to use, ordered in priority from highest to lowest priority.
        """
        return pulumi.get(self, "addresses")


@pulumi.output_type
class GetApplianceUplinksSettingsItemInterfacesWan2VlanTaggingResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 vlan_id: _builtins.int):
        """
        :param _builtins.bool enabled: Whether VLAN tagging is enabled.
        :param _builtins.int vlan_id: The ID of the VLAN to use for VLAN tagging.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "vlan_id", vlan_id)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Whether VLAN tagging is enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> _builtins.int:
        """
        The ID of the VLAN to use for VLAN tagging.
        """
        return pulumi.get(self, "vlan_id")


@pulumi.output_type
class GetCameraAnalyticsLiveItemResult(dict):
    def __init__(__self__, *,
                 ts: _builtins.str,
                 zones: 'outputs.GetCameraAnalyticsLiveItemZonesResult'):
        pulumi.set(__self__, "ts", ts)
        pulumi.set(__self__, "zones", zones)

    @_builtins.property
    @pulumi.getter
    def ts(self) -> _builtins.str:
        return pulumi.get(self, "ts")

    @_builtins.property
    @pulumi.getter
    def zones(self) -> 'outputs.GetCameraAnalyticsLiveItemZonesResult':
        return pulumi.get(self, "zones")


@pulumi.output_type
class GetCameraAnalyticsLiveItemZonesResult(dict):
    def __init__(__self__, *,
                 status0: 'outputs.GetCameraAnalyticsLiveItemZonesStatus0Result'):
        pulumi.set(__self__, "status0", status0)

    @_builtins.property
    @pulumi.getter
    def status0(self) -> 'outputs.GetCameraAnalyticsLiveItemZonesStatus0Result':
        return pulumi.get(self, "status0")


@pulumi.output_type
class GetCameraAnalyticsLiveItemZonesStatus0Result(dict):
    def __init__(__self__, *,
                 person: _builtins.int):
        pulumi.set(__self__, "person", person)

    @_builtins.property
    @pulumi.getter
    def person(self) -> _builtins.int:
        return pulumi.get(self, "person")


@pulumi.output_type
class GetCameraCustomAnalyticsItemResult(dict):
    def __init__(__self__, *,
                 artifact_id: _builtins.str,
                 enabled: _builtins.bool,
                 parameters: Sequence['outputs.GetCameraCustomAnalyticsItemParameterResult']):
        """
        :param _builtins.str artifact_id: Custom analytics artifact ID
        :param _builtins.bool enabled: Whether custom analytics is enabled
        :param Sequence['GetCameraCustomAnalyticsItemParameterArgs'] parameters: Parameters for the custom analytics workload
        """
        pulumi.set(__self__, "artifact_id", artifact_id)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "parameters", parameters)

    @_builtins.property
    @pulumi.getter(name="artifactId")
    def artifact_id(self) -> _builtins.str:
        """
        Custom analytics artifact ID
        """
        return pulumi.get(self, "artifact_id")

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Whether custom analytics is enabled
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def parameters(self) -> Sequence['outputs.GetCameraCustomAnalyticsItemParameterResult']:
        """
        Parameters for the custom analytics workload
        """
        return pulumi.get(self, "parameters")


@pulumi.output_type
class GetCameraCustomAnalyticsItemParameterResult(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 value: _builtins.float):
        """
        :param _builtins.str name: Name of the parameter
        :param _builtins.float value: Value of the parameter
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        Name of the parameter
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter
    def value(self) -> _builtins.float:
        """
        Value of the parameter
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetCameraQualityAndRetentionItemResult(dict):
    def __init__(__self__, *,
                 audio_recording_enabled: _builtins.bool,
                 motion_based_retention_enabled: _builtins.bool,
                 motion_detector_version: _builtins.int,
                 profile_id: _builtins.str,
                 quality: _builtins.str,
                 resolution: _builtins.str,
                 restricted_bandwidth_mode_enabled: _builtins.bool):
        pulumi.set(__self__, "audio_recording_enabled", audio_recording_enabled)
        pulumi.set(__self__, "motion_based_retention_enabled", motion_based_retention_enabled)
        pulumi.set(__self__, "motion_detector_version", motion_detector_version)
        pulumi.set(__self__, "profile_id", profile_id)
        pulumi.set(__self__, "quality", quality)
        pulumi.set(__self__, "resolution", resolution)
        pulumi.set(__self__, "restricted_bandwidth_mode_enabled", restricted_bandwidth_mode_enabled)

    @_builtins.property
    @pulumi.getter(name="audioRecordingEnabled")
    def audio_recording_enabled(self) -> _builtins.bool:
        return pulumi.get(self, "audio_recording_enabled")

    @_builtins.property
    @pulumi.getter(name="motionBasedRetentionEnabled")
    def motion_based_retention_enabled(self) -> _builtins.bool:
        return pulumi.get(self, "motion_based_retention_enabled")

    @_builtins.property
    @pulumi.getter(name="motionDetectorVersion")
    def motion_detector_version(self) -> _builtins.int:
        return pulumi.get(self, "motion_detector_version")

    @_builtins.property
    @pulumi.getter(name="profileId")
    def profile_id(self) -> _builtins.str:
        return pulumi.get(self, "profile_id")

    @_builtins.property
    @pulumi.getter
    def quality(self) -> _builtins.str:
        return pulumi.get(self, "quality")

    @_builtins.property
    @pulumi.getter
    def resolution(self) -> _builtins.str:
        return pulumi.get(self, "resolution")

    @_builtins.property
    @pulumi.getter(name="restrictedBandwidthModeEnabled")
    def restricted_bandwidth_mode_enabled(self) -> _builtins.bool:
        return pulumi.get(self, "restricted_bandwidth_mode_enabled")


@pulumi.output_type
class GetCameraSenseItemResult(dict):
    def __init__(__self__, *,
                 audio_detection: 'outputs.GetCameraSenseItemAudioDetectionResult',
                 mqtt_broker_id: _builtins.str,
                 mqtt_topics: Sequence[_builtins.str],
                 sense_enabled: _builtins.bool):
        pulumi.set(__self__, "audio_detection", audio_detection)
        pulumi.set(__self__, "mqtt_broker_id", mqtt_broker_id)
        pulumi.set(__self__, "mqtt_topics", mqtt_topics)
        pulumi.set(__self__, "sense_enabled", sense_enabled)

    @_builtins.property
    @pulumi.getter(name="audioDetection")
    def audio_detection(self) -> 'outputs.GetCameraSenseItemAudioDetectionResult':
        return pulumi.get(self, "audio_detection")

    @_builtins.property
    @pulumi.getter(name="mqttBrokerId")
    def mqtt_broker_id(self) -> _builtins.str:
        return pulumi.get(self, "mqtt_broker_id")

    @_builtins.property
    @pulumi.getter(name="mqttTopics")
    def mqtt_topics(self) -> Sequence[_builtins.str]:
        return pulumi.get(self, "mqtt_topics")

    @_builtins.property
    @pulumi.getter(name="senseEnabled")
    def sense_enabled(self) -> _builtins.bool:
        return pulumi.get(self, "sense_enabled")


@pulumi.output_type
class GetCameraSenseItemAudioDetectionResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool):
        pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetCameraVideoLinkItemResult(dict):
    def __init__(__self__, *,
                 url: _builtins.str,
                 vision_url: _builtins.str):
        pulumi.set(__self__, "url", url)
        pulumi.set(__self__, "vision_url", vision_url)

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        return pulumi.get(self, "url")

    @_builtins.property
    @pulumi.getter(name="visionUrl")
    def vision_url(self) -> _builtins.str:
        return pulumi.get(self, "vision_url")


@pulumi.output_type
class GetCameraVideoSettingsItemResult(dict):
    def __init__(__self__, *,
                 external_rtsp_enabled: _builtins.bool,
                 rtsp_url: _builtins.str):
        """
        :param _builtins.bool external_rtsp_enabled: Boolean indicating if external rtsp stream is exposed
        :param _builtins.str rtsp_url: External rstp url. Will only be returned if external rtsp stream is exposed
        """
        pulumi.set(__self__, "external_rtsp_enabled", external_rtsp_enabled)
        pulumi.set(__self__, "rtsp_url", rtsp_url)

    @_builtins.property
    @pulumi.getter(name="externalRtspEnabled")
    def external_rtsp_enabled(self) -> _builtins.bool:
        """
        Boolean indicating if external rtsp stream is exposed
        """
        return pulumi.get(self, "external_rtsp_enabled")

    @_builtins.property
    @pulumi.getter(name="rtspUrl")
    def rtsp_url(self) -> _builtins.str:
        """
        External rstp url. Will only be returned if external rtsp stream is exposed
        """
        return pulumi.get(self, "rtsp_url")


@pulumi.output_type
class GetCameraWirelessProfilesItemResult(dict):
    def __init__(__self__, *,
                 ids: 'outputs.GetCameraWirelessProfilesItemIdsResult'):
        pulumi.set(__self__, "ids", ids)

    @_builtins.property
    @pulumi.getter
    def ids(self) -> 'outputs.GetCameraWirelessProfilesItemIdsResult':
        return pulumi.get(self, "ids")


@pulumi.output_type
class GetCameraWirelessProfilesItemIdsResult(dict):
    def __init__(__self__, *,
                 backup: _builtins.str,
                 primary: _builtins.str,
                 secondary: _builtins.str):
        pulumi.set(__self__, "backup", backup)
        pulumi.set(__self__, "primary", primary)
        pulumi.set(__self__, "secondary", secondary)

    @_builtins.property
    @pulumi.getter
    def backup(self) -> _builtins.str:
        return pulumi.get(self, "backup")

    @_builtins.property
    @pulumi.getter
    def primary(self) -> _builtins.str:
        return pulumi.get(self, "primary")

    @_builtins.property
    @pulumi.getter
    def secondary(self) -> _builtins.str:
        return pulumi.get(self, "secondary")


@pulumi.output_type
class GetCellularGatewayLanItemResult(dict):
    def __init__(__self__, *,
                 device_lan_ip: _builtins.str,
                 device_name: _builtins.str,
                 device_subnet: _builtins.str,
                 fixed_ip_assignments: Sequence['outputs.GetCellularGatewayLanItemFixedIpAssignmentResult'],
                 reserved_ip_ranges: Sequence['outputs.GetCellularGatewayLanItemReservedIpRangeResult']):
        """
        :param _builtins.str device_lan_ip: Lan IP of the MG
        :param _builtins.str device_name: Name of the MG.
        :param _builtins.str device_subnet: Subnet configuration of the MG.
        :param Sequence['GetCellularGatewayLanItemFixedIpAssignmentArgs'] fixed_ip_assignments: list of all fixed IP assignments for a single MG
        :param Sequence['GetCellularGatewayLanItemReservedIpRangeArgs'] reserved_ip_ranges: list of all reserved IP ranges for a single MG
        """
        pulumi.set(__self__, "device_lan_ip", device_lan_ip)
        pulumi.set(__self__, "device_name", device_name)
        pulumi.set(__self__, "device_subnet", device_subnet)
        pulumi.set(__self__, "fixed_ip_assignments", fixed_ip_assignments)
        pulumi.set(__self__, "reserved_ip_ranges", reserved_ip_ranges)

    @_builtins.property
    @pulumi.getter(name="deviceLanIp")
    def device_lan_ip(self) -> _builtins.str:
        """
        Lan IP of the MG
        """
        return pulumi.get(self, "device_lan_ip")

    @_builtins.property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> _builtins.str:
        """
        Name of the MG.
        """
        return pulumi.get(self, "device_name")

    @_builtins.property
    @pulumi.getter(name="deviceSubnet")
    def device_subnet(self) -> _builtins.str:
        """
        Subnet configuration of the MG.
        """
        return pulumi.get(self, "device_subnet")

    @_builtins.property
    @pulumi.getter(name="fixedIpAssignments")
    def fixed_ip_assignments(self) -> Sequence['outputs.GetCellularGatewayLanItemFixedIpAssignmentResult']:
        """
        list of all fixed IP assignments for a single MG
        """
        return pulumi.get(self, "fixed_ip_assignments")

    @_builtins.property
    @pulumi.getter(name="reservedIpRanges")
    def reserved_ip_ranges(self) -> Sequence['outputs.GetCellularGatewayLanItemReservedIpRangeResult']:
        """
        list of all reserved IP ranges for a single MG
        """
        return pulumi.get(self, "reserved_ip_ranges")


@pulumi.output_type
class GetCellularGatewayLanItemFixedIpAssignmentResult(dict):
    def __init__(__self__, *,
                 ip: _builtins.str,
                 mac: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str ip: The IP address you want to assign to a specific server or device
        :param _builtins.str mac: The MAC address of the server or device that hosts the internal resource that you wish to receive the specified IP address
        :param _builtins.str name: A descriptive name of the assignment
        """
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def ip(self) -> _builtins.str:
        """
        The IP address you want to assign to a specific server or device
        """
        return pulumi.get(self, "ip")

    @_builtins.property
    @pulumi.getter
    def mac(self) -> _builtins.str:
        """
        The MAC address of the server or device that hosts the internal resource that you wish to receive the specified IP address
        """
        return pulumi.get(self, "mac")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        A descriptive name of the assignment
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetCellularGatewayLanItemReservedIpRangeResult(dict):
    def __init__(__self__, *,
                 comment: _builtins.str,
                 end: _builtins.str,
                 start: _builtins.str):
        """
        :param _builtins.str comment: Comment explaining the reserved IP range
        :param _builtins.str end: Ending IP included in the reserved range of IPs
        :param _builtins.str start: Starting IP included in the reserved range of IPs
        """
        pulumi.set(__self__, "comment", comment)
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @_builtins.property
    @pulumi.getter
    def comment(self) -> _builtins.str:
        """
        Comment explaining the reserved IP range
        """
        return pulumi.get(self, "comment")

    @_builtins.property
    @pulumi.getter
    def end(self) -> _builtins.str:
        """
        Ending IP included in the reserved range of IPs
        """
        return pulumi.get(self, "end")

    @_builtins.property
    @pulumi.getter
    def start(self) -> _builtins.str:
        """
        Starting IP included in the reserved range of IPs
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class GetCellularGatewayPortForwardingRulesItemResult(dict):
    def __init__(__self__, *,
                 rules: Sequence['outputs.GetCellularGatewayPortForwardingRulesItemRuleResult']):
        pulumi.set(__self__, "rules", rules)

    @_builtins.property
    @pulumi.getter
    def rules(self) -> Sequence['outputs.GetCellularGatewayPortForwardingRulesItemRuleResult']:
        return pulumi.get(self, "rules")


@pulumi.output_type
class GetCellularGatewayPortForwardingRulesItemRuleResult(dict):
    def __init__(__self__, *,
                 access: _builtins.str,
                 lan_ip: _builtins.str,
                 local_port: _builtins.str,
                 name: _builtins.str,
                 protocol: _builtins.str,
                 public_port: _builtins.str,
                 uplink: _builtins.str):
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "lan_ip", lan_ip)
        pulumi.set(__self__, "local_port", local_port)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "public_port", public_port)
        pulumi.set(__self__, "uplink", uplink)

    @_builtins.property
    @pulumi.getter
    def access(self) -> _builtins.str:
        return pulumi.get(self, "access")

    @_builtins.property
    @pulumi.getter(name="lanIp")
    def lan_ip(self) -> _builtins.str:
        return pulumi.get(self, "lan_ip")

    @_builtins.property
    @pulumi.getter(name="localPort")
    def local_port(self) -> _builtins.str:
        return pulumi.get(self, "local_port")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter
    def protocol(self) -> _builtins.str:
        return pulumi.get(self, "protocol")

    @_builtins.property
    @pulumi.getter(name="publicPort")
    def public_port(self) -> _builtins.str:
        return pulumi.get(self, "public_port")

    @_builtins.property
    @pulumi.getter
    def uplink(self) -> _builtins.str:
        return pulumi.get(self, "uplink")


@pulumi.output_type
class GetCellularSimsItemResult(dict):
    def __init__(__self__, *,
                 sims: Sequence['outputs.GetCellularSimsItemSimResult']):
        pulumi.set(__self__, "sims", sims)

    @_builtins.property
    @pulumi.getter
    def sims(self) -> Sequence['outputs.GetCellularSimsItemSimResult']:
        return pulumi.get(self, "sims")


@pulumi.output_type
class GetCellularSimsItemSimResult(dict):
    def __init__(__self__, *,
                 apns: Sequence['outputs.GetCellularSimsItemSimApnResult'],
                 is_primary: _builtins.bool,
                 slot: _builtins.str):
        pulumi.set(__self__, "apns", apns)
        pulumi.set(__self__, "is_primary", is_primary)
        pulumi.set(__self__, "slot", slot)

    @_builtins.property
    @pulumi.getter
    def apns(self) -> Sequence['outputs.GetCellularSimsItemSimApnResult']:
        return pulumi.get(self, "apns")

    @_builtins.property
    @pulumi.getter(name="isPrimary")
    def is_primary(self) -> _builtins.bool:
        return pulumi.get(self, "is_primary")

    @_builtins.property
    @pulumi.getter
    def slot(self) -> _builtins.str:
        return pulumi.get(self, "slot")


@pulumi.output_type
class GetCellularSimsItemSimApnResult(dict):
    def __init__(__self__, *,
                 allowed_ip_types: Sequence[_builtins.str],
                 authentication: 'outputs.GetCellularSimsItemSimApnAuthenticationResult',
                 name: _builtins.str):
        pulumi.set(__self__, "allowed_ip_types", allowed_ip_types)
        pulumi.set(__self__, "authentication", authentication)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter(name="allowedIpTypes")
    def allowed_ip_types(self) -> Sequence[_builtins.str]:
        return pulumi.get(self, "allowed_ip_types")

    @_builtins.property
    @pulumi.getter
    def authentication(self) -> 'outputs.GetCellularSimsItemSimApnAuthenticationResult':
        return pulumi.get(self, "authentication")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        return pulumi.get(self, "name")


@pulumi.output_type
class GetCellularSimsItemSimApnAuthenticationResult(dict):
    def __init__(__self__, *,
                 type: _builtins.str,
                 username: _builtins.str):
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def username(self) -> _builtins.str:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetLiveToolsArpTableItemResult(dict):
    def __init__(__self__, *,
                 arp_table_id: _builtins.str,
                 entries: Sequence['outputs.GetLiveToolsArpTableItemEntryResult'],
                 error: _builtins.str,
                 request: 'outputs.GetLiveToolsArpTableItemRequestResult',
                 status: _builtins.str,
                 url: _builtins.str):
        """
        :param _builtins.str arp_table_id: Id of the ARP table request. Used to check the status of the request.
        :param Sequence['GetLiveToolsArpTableItemEntryArgs'] entries: The ARP table entries
        :param _builtins.str error: An error message for a failed execution
        :param 'GetLiveToolsArpTableItemRequestArgs' request: ARP table request parameters
        :param _builtins.str status: Status of the ARP table request.
        :param _builtins.str url: GET this url to check the status of your ARP table request.
        """
        pulumi.set(__self__, "arp_table_id", arp_table_id)
        pulumi.set(__self__, "entries", entries)
        pulumi.set(__self__, "error", error)
        pulumi.set(__self__, "request", request)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="arpTableId")
    def arp_table_id(self) -> _builtins.str:
        """
        Id of the ARP table request. Used to check the status of the request.
        """
        return pulumi.get(self, "arp_table_id")

    @_builtins.property
    @pulumi.getter
    def entries(self) -> Sequence['outputs.GetLiveToolsArpTableItemEntryResult']:
        """
        The ARP table entries
        """
        return pulumi.get(self, "entries")

    @_builtins.property
    @pulumi.getter
    def error(self) -> _builtins.str:
        """
        An error message for a failed execution
        """
        return pulumi.get(self, "error")

    @_builtins.property
    @pulumi.getter
    def request(self) -> 'outputs.GetLiveToolsArpTableItemRequestResult':
        """
        ARP table request parameters
        """
        return pulumi.get(self, "request")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        Status of the ARP table request.
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        GET this url to check the status of your ARP table request.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetLiveToolsArpTableItemEntryResult(dict):
    def __init__(__self__, *,
                 ip: _builtins.str,
                 last_updated_at: _builtins.str,
                 mac: _builtins.str,
                 vlan_id: _builtins.int):
        """
        :param _builtins.str ip: The IP address of the ARP table entry
        :param _builtins.str last_updated_at: Time of the last update of the ARP table entry
        :param _builtins.str mac: The MAC address of the ARP table entry
        :param _builtins.int vlan_id: The VLAN ID of the ARP table entry
        """
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "last_updated_at", last_updated_at)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "vlan_id", vlan_id)

    @_builtins.property
    @pulumi.getter
    def ip(self) -> _builtins.str:
        """
        The IP address of the ARP table entry
        """
        return pulumi.get(self, "ip")

    @_builtins.property
    @pulumi.getter(name="lastUpdatedAt")
    def last_updated_at(self) -> _builtins.str:
        """
        Time of the last update of the ARP table entry
        """
        return pulumi.get(self, "last_updated_at")

    @_builtins.property
    @pulumi.getter
    def mac(self) -> _builtins.str:
        """
        The MAC address of the ARP table entry
        """
        return pulumi.get(self, "mac")

    @_builtins.property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> _builtins.int:
        """
        The VLAN ID of the ARP table entry
        """
        return pulumi.get(self, "vlan_id")


@pulumi.output_type
class GetLiveToolsArpTableItemRequestResult(dict):
    def __init__(__self__, *,
                 serial: _builtins.str):
        """
        :param _builtins.str serial: Device serial number
        """
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class GetLiveToolsCableTestItemResult(dict):
    def __init__(__self__, *,
                 cable_test_id: _builtins.str,
                 error: _builtins.str,
                 request: 'outputs.GetLiveToolsCableTestItemRequestResult',
                 results: Sequence['outputs.GetLiveToolsCableTestItemResultResult'],
                 status: _builtins.str,
                 url: _builtins.str):
        """
        :param _builtins.str cable_test_id: Id of the cable test request. Used to check the status of the request.
        :param _builtins.str error: An error message for a failed execution
        :param 'GetLiveToolsCableTestItemRequestArgs' request: Cable test request parameters
        :param Sequence['GetLiveToolsCableTestItemResultArgs'] results: Results of the cable test request, one for each requested port.
        :param _builtins.str status: Status of the cable test request.
        :param _builtins.str url: GET this url to check the status of your cable test request.
        """
        pulumi.set(__self__, "cable_test_id", cable_test_id)
        pulumi.set(__self__, "error", error)
        pulumi.set(__self__, "request", request)
        pulumi.set(__self__, "results", results)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="cableTestId")
    def cable_test_id(self) -> _builtins.str:
        """
        Id of the cable test request. Used to check the status of the request.
        """
        return pulumi.get(self, "cable_test_id")

    @_builtins.property
    @pulumi.getter
    def error(self) -> _builtins.str:
        """
        An error message for a failed execution
        """
        return pulumi.get(self, "error")

    @_builtins.property
    @pulumi.getter
    def request(self) -> 'outputs.GetLiveToolsCableTestItemRequestResult':
        """
        Cable test request parameters
        """
        return pulumi.get(self, "request")

    @_builtins.property
    @pulumi.getter
    def results(self) -> Sequence['outputs.GetLiveToolsCableTestItemResultResult']:
        """
        Results of the cable test request, one for each requested port.
        """
        return pulumi.get(self, "results")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        Status of the cable test request.
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        GET this url to check the status of your cable test request.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetLiveToolsCableTestItemRequestResult(dict):
    def __init__(__self__, *,
                 ports: Sequence[_builtins.str],
                 serial: _builtins.str):
        """
        :param Sequence[_builtins.str] ports: A list of ports for which to perform the cable test.
        :param _builtins.str serial: Device serial number
        """
        pulumi.set(__self__, "ports", ports)
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter
    def ports(self) -> Sequence[_builtins.str]:
        """
        A list of ports for which to perform the cable test.
        """
        return pulumi.get(self, "ports")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class GetLiveToolsCableTestItemResultResult(dict):
    def __init__(__self__, *,
                 error: _builtins.str,
                 pairs: Sequence['outputs.GetLiveToolsCableTestItemResultPairResult'],
                 port: _builtins.str,
                 speed_mbps: _builtins.int,
                 status: _builtins.str):
        """
        :param _builtins.str error: If an error occurred during the cable test, the error message will be populated here.
        :param Sequence['GetLiveToolsCableTestItemResultPairArgs'] pairs: Results for each twisted pair within the cable.
        :param _builtins.str port: The port for which the test was performed.
        :param _builtins.int speed_mbps: Speed in Mbps.  A speed of 0 indicates the port is down or the port speed is automatic.
        :param _builtins.str status: The current status of the port. If the cable test is still being performed on the port, "in-progress" is used. If an error occurred during the cable test, "error" is used and the error property will be populated.
        """
        pulumi.set(__self__, "error", error)
        pulumi.set(__self__, "pairs", pairs)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "speed_mbps", speed_mbps)
        pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter
    def error(self) -> _builtins.str:
        """
        If an error occurred during the cable test, the error message will be populated here.
        """
        return pulumi.get(self, "error")

    @_builtins.property
    @pulumi.getter
    def pairs(self) -> Sequence['outputs.GetLiveToolsCableTestItemResultPairResult']:
        """
        Results for each twisted pair within the cable.
        """
        return pulumi.get(self, "pairs")

    @_builtins.property
    @pulumi.getter
    def port(self) -> _builtins.str:
        """
        The port for which the test was performed.
        """
        return pulumi.get(self, "port")

    @_builtins.property
    @pulumi.getter(name="speedMbps")
    def speed_mbps(self) -> _builtins.int:
        """
        Speed in Mbps.  A speed of 0 indicates the port is down or the port speed is automatic.
        """
        return pulumi.get(self, "speed_mbps")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        The current status of the port. If the cable test is still being performed on the port, "in-progress" is used. If an error occurred during the cable test, "error" is used and the error property will be populated.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetLiveToolsCableTestItemResultPairResult(dict):
    def __init__(__self__, *,
                 index: _builtins.int,
                 length_meters: _builtins.int,
                 status: _builtins.str):
        """
        :param _builtins.int index: The index of the twisted pair tested.
        :param _builtins.int length_meters: The detected length of the twisted pair.
        :param _builtins.str status: The test result of the twisted pair tested.
        """
        pulumi.set(__self__, "index", index)
        pulumi.set(__self__, "length_meters", length_meters)
        pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter
    def index(self) -> _builtins.int:
        """
        The index of the twisted pair tested.
        """
        return pulumi.get(self, "index")

    @_builtins.property
    @pulumi.getter(name="lengthMeters")
    def length_meters(self) -> _builtins.int:
        """
        The detected length of the twisted pair.
        """
        return pulumi.get(self, "length_meters")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        The test result of the twisted pair tested.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetLiveToolsPingDeviceItemResult(dict):
    def __init__(__self__, *,
                 callback: 'outputs.GetLiveToolsPingDeviceItemCallbackResult',
                 ping_id: _builtins.str,
                 request: 'outputs.GetLiveToolsPingDeviceItemRequestResult',
                 results: 'outputs.GetLiveToolsPingDeviceItemResultsResult',
                 status: _builtins.str,
                 url: _builtins.str):
        """
        :param 'GetLiveToolsPingDeviceItemCallbackArgs' callback: Information for callback used to send back results
        :param _builtins.str ping_id: Id to check the status of your ping request.
        :param 'GetLiveToolsPingDeviceItemRequestArgs' request: Ping request parameters
        :param 'GetLiveToolsPingDeviceItemResultsArgs' results: Results of the ping request.
        :param _builtins.str status: Status of the ping request.
        :param _builtins.str url: GET this url to check the status of your ping request.
        """
        pulumi.set(__self__, "callback", callback)
        pulumi.set(__self__, "ping_id", ping_id)
        pulumi.set(__self__, "request", request)
        pulumi.set(__self__, "results", results)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter
    def callback(self) -> 'outputs.GetLiveToolsPingDeviceItemCallbackResult':
        """
        Information for callback used to send back results
        """
        return pulumi.get(self, "callback")

    @_builtins.property
    @pulumi.getter(name="pingId")
    def ping_id(self) -> _builtins.str:
        """
        Id to check the status of your ping request.
        """
        return pulumi.get(self, "ping_id")

    @_builtins.property
    @pulumi.getter
    def request(self) -> 'outputs.GetLiveToolsPingDeviceItemRequestResult':
        """
        Ping request parameters
        """
        return pulumi.get(self, "request")

    @_builtins.property
    @pulumi.getter
    def results(self) -> 'outputs.GetLiveToolsPingDeviceItemResultsResult':
        """
        Results of the ping request.
        """
        return pulumi.get(self, "results")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        Status of the ping request.
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        GET this url to check the status of your ping request.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetLiveToolsPingDeviceItemCallbackResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 status: _builtins.str,
                 url: _builtins.str):
        """
        :param _builtins.str id: The ID of the callback. To check the status of the callback, use this ID in a request to /webhooks/callbacks/statuses/{id}
        :param _builtins.str status: The status of the callback
        :param _builtins.str url: The callback URL for the webhook target. This was either provided in the original request or comes from a configured webhook receiver
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        The ID of the callback. To check the status of the callback, use this ID in a request to /webhooks/callbacks/statuses/{id}
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        The status of the callback
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        The callback URL for the webhook target. This was either provided in the original request or comes from a configured webhook receiver
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetLiveToolsPingDeviceItemRequestResult(dict):
    def __init__(__self__, *,
                 count_r: _builtins.int,
                 serial: _builtins.str,
                 target: _builtins.str):
        """
        :param _builtins.int count_r: Number of pings to send
        :param _builtins.str serial: Device serial number
        :param _builtins.str target: IP address or FQDN to ping
        """
        pulumi.set(__self__, "count_r", count_r)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "target", target)

    @_builtins.property
    @pulumi.getter(name="countR")
    def count_r(self) -> _builtins.int:
        """
        Number of pings to send
        """
        return pulumi.get(self, "count_r")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")

    @_builtins.property
    @pulumi.getter
    def target(self) -> _builtins.str:
        """
        IP address or FQDN to ping
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class GetLiveToolsPingDeviceItemResultsResult(dict):
    def __init__(__self__, *,
                 latencies: 'outputs.GetLiveToolsPingDeviceItemResultsLatenciesResult',
                 loss: 'outputs.GetLiveToolsPingDeviceItemResultsLossResult',
                 received: _builtins.int,
                 replies: Sequence['outputs.GetLiveToolsPingDeviceItemResultsReplyResult'],
                 sent: _builtins.int):
        """
        :param 'GetLiveToolsPingDeviceItemResultsLatenciesArgs' latencies: Packet latency stats
        :param 'GetLiveToolsPingDeviceItemResultsLossArgs' loss: Lost packets
        :param _builtins.int received: Number of packets received
        :param Sequence['GetLiveToolsPingDeviceItemResultsReplyArgs'] replies: Received packets
        :param _builtins.int sent: Number of packets sent
        """
        pulumi.set(__self__, "latencies", latencies)
        pulumi.set(__self__, "loss", loss)
        pulumi.set(__self__, "received", received)
        pulumi.set(__self__, "replies", replies)
        pulumi.set(__self__, "sent", sent)

    @_builtins.property
    @pulumi.getter
    def latencies(self) -> 'outputs.GetLiveToolsPingDeviceItemResultsLatenciesResult':
        """
        Packet latency stats
        """
        return pulumi.get(self, "latencies")

    @_builtins.property
    @pulumi.getter
    def loss(self) -> 'outputs.GetLiveToolsPingDeviceItemResultsLossResult':
        """
        Lost packets
        """
        return pulumi.get(self, "loss")

    @_builtins.property
    @pulumi.getter
    def received(self) -> _builtins.int:
        """
        Number of packets received
        """
        return pulumi.get(self, "received")

    @_builtins.property
    @pulumi.getter
    def replies(self) -> Sequence['outputs.GetLiveToolsPingDeviceItemResultsReplyResult']:
        """
        Received packets
        """
        return pulumi.get(self, "replies")

    @_builtins.property
    @pulumi.getter
    def sent(self) -> _builtins.int:
        """
        Number of packets sent
        """
        return pulumi.get(self, "sent")


@pulumi.output_type
class GetLiveToolsPingDeviceItemResultsLatenciesResult(dict):
    def __init__(__self__, *,
                 average: _builtins.float,
                 maximum: _builtins.float,
                 minimum: _builtins.float):
        """
        :param _builtins.float average: Average latency
        :param _builtins.float maximum: Maximum latency
        :param _builtins.float minimum: Minimum latency
        """
        pulumi.set(__self__, "average", average)
        pulumi.set(__self__, "maximum", maximum)
        pulumi.set(__self__, "minimum", minimum)

    @_builtins.property
    @pulumi.getter
    def average(self) -> _builtins.float:
        """
        Average latency
        """
        return pulumi.get(self, "average")

    @_builtins.property
    @pulumi.getter
    def maximum(self) -> _builtins.float:
        """
        Maximum latency
        """
        return pulumi.get(self, "maximum")

    @_builtins.property
    @pulumi.getter
    def minimum(self) -> _builtins.float:
        """
        Minimum latency
        """
        return pulumi.get(self, "minimum")


@pulumi.output_type
class GetLiveToolsPingDeviceItemResultsLossResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of packets lost
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of packets lost
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetLiveToolsPingDeviceItemResultsReplyResult(dict):
    def __init__(__self__, *,
                 latency: _builtins.float,
                 sequence_id: _builtins.int,
                 size: _builtins.int):
        """
        :param _builtins.float latency: Latency of the packet in milliseconds
        :param _builtins.int sequence_id: Sequence ID of the packet
        :param _builtins.int size: Size of the packet in bytes
        """
        pulumi.set(__self__, "latency", latency)
        pulumi.set(__self__, "sequence_id", sequence_id)
        pulumi.set(__self__, "size", size)

    @_builtins.property
    @pulumi.getter
    def latency(self) -> _builtins.float:
        """
        Latency of the packet in milliseconds
        """
        return pulumi.get(self, "latency")

    @_builtins.property
    @pulumi.getter(name="sequenceId")
    def sequence_id(self) -> _builtins.int:
        """
        Sequence ID of the packet
        """
        return pulumi.get(self, "sequence_id")

    @_builtins.property
    @pulumi.getter
    def size(self) -> _builtins.int:
        """
        Size of the packet in bytes
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class GetLiveToolsPingItemResult(dict):
    def __init__(__self__, *,
                 ping_id: _builtins.str,
                 request: 'outputs.GetLiveToolsPingItemRequestResult',
                 results: 'outputs.GetLiveToolsPingItemResultsResult',
                 status: _builtins.str,
                 url: _builtins.str):
        """
        :param _builtins.str ping_id: Id to check the status of your ping request.
        :param 'GetLiveToolsPingItemRequestArgs' request: Ping request parameters
        :param 'GetLiveToolsPingItemResultsArgs' results: Results of the ping request.
        :param _builtins.str status: Status of the ping request.
        :param _builtins.str url: GET this url to check the status of your ping request.
        """
        pulumi.set(__self__, "ping_id", ping_id)
        pulumi.set(__self__, "request", request)
        pulumi.set(__self__, "results", results)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="pingId")
    def ping_id(self) -> _builtins.str:
        """
        Id to check the status of your ping request.
        """
        return pulumi.get(self, "ping_id")

    @_builtins.property
    @pulumi.getter
    def request(self) -> 'outputs.GetLiveToolsPingItemRequestResult':
        """
        Ping request parameters
        """
        return pulumi.get(self, "request")

    @_builtins.property
    @pulumi.getter
    def results(self) -> 'outputs.GetLiveToolsPingItemResultsResult':
        """
        Results of the ping request.
        """
        return pulumi.get(self, "results")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        Status of the ping request.
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        GET this url to check the status of your ping request.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetLiveToolsPingItemRequestResult(dict):
    def __init__(__self__, *,
                 count_r: _builtins.int,
                 serial: _builtins.str,
                 target: _builtins.str):
        """
        :param _builtins.int count_r: Number of pings to send
        :param _builtins.str serial: Device serial number
        :param _builtins.str target: IP address or FQDN to ping
        """
        pulumi.set(__self__, "count_r", count_r)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "target", target)

    @_builtins.property
    @pulumi.getter(name="countR")
    def count_r(self) -> _builtins.int:
        """
        Number of pings to send
        """
        return pulumi.get(self, "count_r")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")

    @_builtins.property
    @pulumi.getter
    def target(self) -> _builtins.str:
        """
        IP address or FQDN to ping
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class GetLiveToolsPingItemResultsResult(dict):
    def __init__(__self__, *,
                 latencies: 'outputs.GetLiveToolsPingItemResultsLatenciesResult',
                 loss: 'outputs.GetLiveToolsPingItemResultsLossResult',
                 received: _builtins.int,
                 replies: Sequence['outputs.GetLiveToolsPingItemResultsReplyResult'],
                 sent: _builtins.int):
        """
        :param 'GetLiveToolsPingItemResultsLatenciesArgs' latencies: Packet latency stats
        :param 'GetLiveToolsPingItemResultsLossArgs' loss: Lost packets
        :param _builtins.int received: Number of packets received
        :param Sequence['GetLiveToolsPingItemResultsReplyArgs'] replies: Received packets
        :param _builtins.int sent: Number of packets sent
        """
        pulumi.set(__self__, "latencies", latencies)
        pulumi.set(__self__, "loss", loss)
        pulumi.set(__self__, "received", received)
        pulumi.set(__self__, "replies", replies)
        pulumi.set(__self__, "sent", sent)

    @_builtins.property
    @pulumi.getter
    def latencies(self) -> 'outputs.GetLiveToolsPingItemResultsLatenciesResult':
        """
        Packet latency stats
        """
        return pulumi.get(self, "latencies")

    @_builtins.property
    @pulumi.getter
    def loss(self) -> 'outputs.GetLiveToolsPingItemResultsLossResult':
        """
        Lost packets
        """
        return pulumi.get(self, "loss")

    @_builtins.property
    @pulumi.getter
    def received(self) -> _builtins.int:
        """
        Number of packets received
        """
        return pulumi.get(self, "received")

    @_builtins.property
    @pulumi.getter
    def replies(self) -> Sequence['outputs.GetLiveToolsPingItemResultsReplyResult']:
        """
        Received packets
        """
        return pulumi.get(self, "replies")

    @_builtins.property
    @pulumi.getter
    def sent(self) -> _builtins.int:
        """
        Number of packets sent
        """
        return pulumi.get(self, "sent")


@pulumi.output_type
class GetLiveToolsPingItemResultsLatenciesResult(dict):
    def __init__(__self__, *,
                 average: _builtins.float,
                 maximum: _builtins.float,
                 minimum: _builtins.float):
        """
        :param _builtins.float average: Average latency
        :param _builtins.float maximum: Maximum latency
        :param _builtins.float minimum: Minimum latency
        """
        pulumi.set(__self__, "average", average)
        pulumi.set(__self__, "maximum", maximum)
        pulumi.set(__self__, "minimum", minimum)

    @_builtins.property
    @pulumi.getter
    def average(self) -> _builtins.float:
        """
        Average latency
        """
        return pulumi.get(self, "average")

    @_builtins.property
    @pulumi.getter
    def maximum(self) -> _builtins.float:
        """
        Maximum latency
        """
        return pulumi.get(self, "maximum")

    @_builtins.property
    @pulumi.getter
    def minimum(self) -> _builtins.float:
        """
        Minimum latency
        """
        return pulumi.get(self, "minimum")


@pulumi.output_type
class GetLiveToolsPingItemResultsLossResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of packets lost
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of packets lost
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetLiveToolsPingItemResultsReplyResult(dict):
    def __init__(__self__, *,
                 latency: _builtins.float,
                 sequence_id: _builtins.int,
                 size: _builtins.int):
        """
        :param _builtins.float latency: Latency of the packet in milliseconds
        :param _builtins.int sequence_id: Sequence ID of the packet
        :param _builtins.int size: Size of the packet in bytes
        """
        pulumi.set(__self__, "latency", latency)
        pulumi.set(__self__, "sequence_id", sequence_id)
        pulumi.set(__self__, "size", size)

    @_builtins.property
    @pulumi.getter
    def latency(self) -> _builtins.float:
        """
        Latency of the packet in milliseconds
        """
        return pulumi.get(self, "latency")

    @_builtins.property
    @pulumi.getter(name="sequenceId")
    def sequence_id(self) -> _builtins.int:
        """
        Sequence ID of the packet
        """
        return pulumi.get(self, "sequence_id")

    @_builtins.property
    @pulumi.getter
    def size(self) -> _builtins.int:
        """
        Size of the packet in bytes
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class GetLiveToolsThroughputTestItemResult(dict):
    def __init__(__self__, *,
                 error: _builtins.str,
                 request: 'outputs.GetLiveToolsThroughputTestItemRequestResult',
                 result: 'outputs.GetLiveToolsThroughputTestItemResultResult',
                 status: _builtins.str,
                 throughput_test_id: _builtins.str,
                 url: _builtins.str):
        """
        :param _builtins.str error: Description of the error.
        :param 'GetLiveToolsThroughputTestItemRequestArgs' request: The parameters of the throughput test request
        :param 'GetLiveToolsThroughputTestItemResultArgs' result: Result of the throughput test request
        :param _builtins.str status: Status of the throughput test request
        :param _builtins.str throughput_test_id: ID of throughput test job
        :param _builtins.str url: GET this url to check the status of your throughput test request
        """
        pulumi.set(__self__, "error", error)
        pulumi.set(__self__, "request", request)
        pulumi.set(__self__, "result", result)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "throughput_test_id", throughput_test_id)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter
    def error(self) -> _builtins.str:
        """
        Description of the error.
        """
        return pulumi.get(self, "error")

    @_builtins.property
    @pulumi.getter
    def request(self) -> 'outputs.GetLiveToolsThroughputTestItemRequestResult':
        """
        The parameters of the throughput test request
        """
        return pulumi.get(self, "request")

    @_builtins.property
    @pulumi.getter
    def result(self) -> 'outputs.GetLiveToolsThroughputTestItemResultResult':
        """
        Result of the throughput test request
        """
        return pulumi.get(self, "result")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        Status of the throughput test request
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter(name="throughputTestId")
    def throughput_test_id(self) -> _builtins.str:
        """
        ID of throughput test job
        """
        return pulumi.get(self, "throughput_test_id")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        GET this url to check the status of your throughput test request
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetLiveToolsThroughputTestItemRequestResult(dict):
    def __init__(__self__, *,
                 serial: _builtins.str):
        """
        :param _builtins.str serial: Device serial number
        """
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class GetLiveToolsThroughputTestItemResultResult(dict):
    def __init__(__self__, *,
                 speeds: 'outputs.GetLiveToolsThroughputTestItemResultSpeedsResult'):
        """
        :param 'GetLiveToolsThroughputTestItemResultSpeedsArgs' speeds: Shows the speeds (Mbps)
        """
        pulumi.set(__self__, "speeds", speeds)

    @_builtins.property
    @pulumi.getter
    def speeds(self) -> 'outputs.GetLiveToolsThroughputTestItemResultSpeedsResult':
        """
        Shows the speeds (Mbps)
        """
        return pulumi.get(self, "speeds")


@pulumi.output_type
class GetLiveToolsThroughputTestItemResultSpeedsResult(dict):
    def __init__(__self__, *,
                 downstream: _builtins.int):
        """
        :param _builtins.int downstream: Shows the download speed from shard (Mbps)
        """
        pulumi.set(__self__, "downstream", downstream)

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> _builtins.int:
        """
        Shows the download speed from shard (Mbps)
        """
        return pulumi.get(self, "downstream")


@pulumi.output_type
class GetLiveToolsWakeOnLanItemResult(dict):
    def __init__(__self__, *,
                 error: _builtins.str,
                 request: 'outputs.GetLiveToolsWakeOnLanItemRequestResult',
                 status: _builtins.str,
                 url: _builtins.str,
                 wake_on_lan_id: _builtins.str):
        """
        :param _builtins.str error: An error message for a failed execution
        :param 'GetLiveToolsWakeOnLanItemRequestArgs' request: The parameters of the Wake-on-LAN request
        :param _builtins.str status: Status of the Wake-on-LAN request
        :param _builtins.str url: GET this url to check the status of your ping request
        :param _builtins.str wake_on_lan_id: ID of the Wake-on-LAN job
        """
        pulumi.set(__self__, "error", error)
        pulumi.set(__self__, "request", request)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "url", url)
        pulumi.set(__self__, "wake_on_lan_id", wake_on_lan_id)

    @_builtins.property
    @pulumi.getter
    def error(self) -> _builtins.str:
        """
        An error message for a failed execution
        """
        return pulumi.get(self, "error")

    @_builtins.property
    @pulumi.getter
    def request(self) -> 'outputs.GetLiveToolsWakeOnLanItemRequestResult':
        """
        The parameters of the Wake-on-LAN request
        """
        return pulumi.get(self, "request")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        Status of the Wake-on-LAN request
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        GET this url to check the status of your ping request
        """
        return pulumi.get(self, "url")

    @_builtins.property
    @pulumi.getter(name="wakeOnLanId")
    def wake_on_lan_id(self) -> _builtins.str:
        """
        ID of the Wake-on-LAN job
        """
        return pulumi.get(self, "wake_on_lan_id")


@pulumi.output_type
class GetLiveToolsWakeOnLanItemRequestResult(dict):
    def __init__(__self__, *,
                 mac: _builtins.str,
                 serial: _builtins.str,
                 vlan_id: _builtins.int):
        """
        :param _builtins.str mac: The target's MAC address
        :param _builtins.str serial: Device serial number
        :param _builtins.int vlan_id: The target's VLAN (1 to 4094)
        """
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "vlan_id", vlan_id)

    @_builtins.property
    @pulumi.getter
    def mac(self) -> _builtins.str:
        """
        The target's MAC address
        """
        return pulumi.get(self, "mac")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        Device serial number
        """
        return pulumi.get(self, "serial")

    @_builtins.property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> _builtins.int:
        """
        The target's VLAN (1 to 4094)
        """
        return pulumi.get(self, "vlan_id")


@pulumi.output_type
class GetLldpCdpItemResult(dict):
    def __init__(__self__, *,
                 ports: 'outputs.GetLldpCdpItemPortsResult',
                 source_mac: _builtins.str):
        """
        :param _builtins.str source_mac: Source MAC address
        """
        pulumi.set(__self__, "ports", ports)
        pulumi.set(__self__, "source_mac", source_mac)

    @_builtins.property
    @pulumi.getter
    def ports(self) -> 'outputs.GetLldpCdpItemPortsResult':
        return pulumi.get(self, "ports")

    @_builtins.property
    @pulumi.getter(name="sourceMac")
    def source_mac(self) -> _builtins.str:
        """
        Source MAC address
        """
        return pulumi.get(self, "source_mac")


@pulumi.output_type
class GetLldpCdpItemPortsResult(dict):
    def __init__(__self__, *,
                 status12: 'outputs.GetLldpCdpItemPortsStatus12Result',
                 status8: 'outputs.GetLldpCdpItemPortsStatus8Result'):
        pulumi.set(__self__, "status12", status12)
        pulumi.set(__self__, "status8", status8)

    @_builtins.property
    @pulumi.getter
    def status12(self) -> 'outputs.GetLldpCdpItemPortsStatus12Result':
        return pulumi.get(self, "status12")

    @_builtins.property
    @pulumi.getter
    def status8(self) -> 'outputs.GetLldpCdpItemPortsStatus8Result':
        return pulumi.get(self, "status8")


@pulumi.output_type
class GetLldpCdpItemPortsStatus12Result(dict):
    def __init__(__self__, *,
                 cdp: 'outputs.GetLldpCdpItemPortsStatus12CdpResult',
                 lldp: 'outputs.GetLldpCdpItemPortsStatus12LldpResult'):
        pulumi.set(__self__, "cdp", cdp)
        pulumi.set(__self__, "lldp", lldp)

    @_builtins.property
    @pulumi.getter
    def cdp(self) -> 'outputs.GetLldpCdpItemPortsStatus12CdpResult':
        return pulumi.get(self, "cdp")

    @_builtins.property
    @pulumi.getter
    def lldp(self) -> 'outputs.GetLldpCdpItemPortsStatus12LldpResult':
        return pulumi.get(self, "lldp")


@pulumi.output_type
class GetLldpCdpItemPortsStatus12CdpResult(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 device_id: _builtins.str,
                 port_id: _builtins.str,
                 source_port: _builtins.str):
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "device_id", device_id)
        pulumi.set(__self__, "port_id", port_id)
        pulumi.set(__self__, "source_port", source_port)

    @_builtins.property
    @pulumi.getter
    def address(self) -> _builtins.str:
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="deviceId")
    def device_id(self) -> _builtins.str:
        return pulumi.get(self, "device_id")

    @_builtins.property
    @pulumi.getter(name="portId")
    def port_id(self) -> _builtins.str:
        return pulumi.get(self, "port_id")

    @_builtins.property
    @pulumi.getter(name="sourcePort")
    def source_port(self) -> _builtins.str:
        return pulumi.get(self, "source_port")


@pulumi.output_type
class GetLldpCdpItemPortsStatus12LldpResult(dict):
    def __init__(__self__, *,
                 management_address: _builtins.str,
                 port_id: _builtins.str,
                 source_port: _builtins.str,
                 system_name: _builtins.str):
        pulumi.set(__self__, "management_address", management_address)
        pulumi.set(__self__, "port_id", port_id)
        pulumi.set(__self__, "source_port", source_port)
        pulumi.set(__self__, "system_name", system_name)

    @_builtins.property
    @pulumi.getter(name="managementAddress")
    def management_address(self) -> _builtins.str:
        return pulumi.get(self, "management_address")

    @_builtins.property
    @pulumi.getter(name="portId")
    def port_id(self) -> _builtins.str:
        return pulumi.get(self, "port_id")

    @_builtins.property
    @pulumi.getter(name="sourcePort")
    def source_port(self) -> _builtins.str:
        return pulumi.get(self, "source_port")

    @_builtins.property
    @pulumi.getter(name="systemName")
    def system_name(self) -> _builtins.str:
        return pulumi.get(self, "system_name")


@pulumi.output_type
class GetLldpCdpItemPortsStatus8Result(dict):
    def __init__(__self__, *,
                 cdp: 'outputs.GetLldpCdpItemPortsStatus8CdpResult'):
        pulumi.set(__self__, "cdp", cdp)

    @_builtins.property
    @pulumi.getter
    def cdp(self) -> 'outputs.GetLldpCdpItemPortsStatus8CdpResult':
        return pulumi.get(self, "cdp")


@pulumi.output_type
class GetLldpCdpItemPortsStatus8CdpResult(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 device_id: _builtins.str,
                 port_id: _builtins.str,
                 source_port: _builtins.str):
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "device_id", device_id)
        pulumi.set(__self__, "port_id", port_id)
        pulumi.set(__self__, "source_port", source_port)

    @_builtins.property
    @pulumi.getter
    def address(self) -> _builtins.str:
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="deviceId")
    def device_id(self) -> _builtins.str:
        return pulumi.get(self, "device_id")

    @_builtins.property
    @pulumi.getter(name="portId")
    def port_id(self) -> _builtins.str:
        return pulumi.get(self, "port_id")

    @_builtins.property
    @pulumi.getter(name="sourcePort")
    def source_port(self) -> _builtins.str:
        return pulumi.get(self, "source_port")


@pulumi.output_type
class GetManagementInterfaceItemResult(dict):
    def __init__(__self__, *,
                 ddns_hostnames: 'outputs.GetManagementInterfaceItemDdnsHostnamesResult',
                 wan1: 'outputs.GetManagementInterfaceItemWan1Result',
                 wan2: 'outputs.GetManagementInterfaceItemWan2Result'):
        """
        :param 'GetManagementInterfaceItemDdnsHostnamesArgs' ddns_hostnames: Dynamic DNS hostnames.
        :param 'GetManagementInterfaceItemWan1Args' wan1: WAN 1 settings
        :param 'GetManagementInterfaceItemWan2Args' wan2: WAN 2 settings (only for MX devices)
        """
        pulumi.set(__self__, "ddns_hostnames", ddns_hostnames)
        pulumi.set(__self__, "wan1", wan1)
        pulumi.set(__self__, "wan2", wan2)

    @_builtins.property
    @pulumi.getter(name="ddnsHostnames")
    def ddns_hostnames(self) -> 'outputs.GetManagementInterfaceItemDdnsHostnamesResult':
        """
        Dynamic DNS hostnames.
        """
        return pulumi.get(self, "ddns_hostnames")

    @_builtins.property
    @pulumi.getter
    def wan1(self) -> 'outputs.GetManagementInterfaceItemWan1Result':
        """
        WAN 1 settings
        """
        return pulumi.get(self, "wan1")

    @_builtins.property
    @pulumi.getter
    def wan2(self) -> 'outputs.GetManagementInterfaceItemWan2Result':
        """
        WAN 2 settings (only for MX devices)
        """
        return pulumi.get(self, "wan2")


@pulumi.output_type
class GetManagementInterfaceItemDdnsHostnamesResult(dict):
    def __init__(__self__, *,
                 active_ddns_hostname: _builtins.str,
                 ddns_hostname_wan1: _builtins.str,
                 ddns_hostname_wan2: _builtins.str):
        """
        :param _builtins.str active_ddns_hostname: Active dynamic DNS hostname.
        :param _builtins.str ddns_hostname_wan1: WAN 1 dynamic DNS hostname.
        :param _builtins.str ddns_hostname_wan2: WAN 2 dynamic DNS hostname.
        """
        pulumi.set(__self__, "active_ddns_hostname", active_ddns_hostname)
        pulumi.set(__self__, "ddns_hostname_wan1", ddns_hostname_wan1)
        pulumi.set(__self__, "ddns_hostname_wan2", ddns_hostname_wan2)

    @_builtins.property
    @pulumi.getter(name="activeDdnsHostname")
    def active_ddns_hostname(self) -> _builtins.str:
        """
        Active dynamic DNS hostname.
        """
        return pulumi.get(self, "active_ddns_hostname")

    @_builtins.property
    @pulumi.getter(name="ddnsHostnameWan1")
    def ddns_hostname_wan1(self) -> _builtins.str:
        """
        WAN 1 dynamic DNS hostname.
        """
        return pulumi.get(self, "ddns_hostname_wan1")

    @_builtins.property
    @pulumi.getter(name="ddnsHostnameWan2")
    def ddns_hostname_wan2(self) -> _builtins.str:
        """
        WAN 2 dynamic DNS hostname.
        """
        return pulumi.get(self, "ddns_hostname_wan2")


@pulumi.output_type
class GetManagementInterfaceItemWan1Result(dict):
    def __init__(__self__, *,
                 static_dns: Sequence[_builtins.str],
                 static_gateway_ip: _builtins.str,
                 static_ip: _builtins.str,
                 static_subnet_mask: _builtins.str,
                 using_static_ip: _builtins.bool,
                 vlan: _builtins.int,
                 wan_enabled: _builtins.str):
        """
        :param Sequence[_builtins.str] static_dns: Up to two DNS IPs.
        :param _builtins.str static_gateway_ip: The IP of the gateway on the WAN.
        :param _builtins.str static_ip: The IP the device should use on the WAN.
        :param _builtins.str static_subnet_mask: The subnet mask for the WAN.
        :param _builtins.bool using_static_ip: Configure the interface to have static IP settings or use DHCP.
        :param _builtins.int vlan: The VLAN that management traffic should be tagged with. Applies whether usingStaticIp is true or false.
        :param _builtins.str wan_enabled: Enable or disable the interface (only for MX devices). Valid values are 'enabled', 'disabled', and 'not configured'.
        """
        pulumi.set(__self__, "static_dns", static_dns)
        pulumi.set(__self__, "static_gateway_ip", static_gateway_ip)
        pulumi.set(__self__, "static_ip", static_ip)
        pulumi.set(__self__, "static_subnet_mask", static_subnet_mask)
        pulumi.set(__self__, "using_static_ip", using_static_ip)
        pulumi.set(__self__, "vlan", vlan)
        pulumi.set(__self__, "wan_enabled", wan_enabled)

    @_builtins.property
    @pulumi.getter(name="staticDns")
    def static_dns(self) -> Sequence[_builtins.str]:
        """
        Up to two DNS IPs.
        """
        return pulumi.get(self, "static_dns")

    @_builtins.property
    @pulumi.getter(name="staticGatewayIp")
    def static_gateway_ip(self) -> _builtins.str:
        """
        The IP of the gateway on the WAN.
        """
        return pulumi.get(self, "static_gateway_ip")

    @_builtins.property
    @pulumi.getter(name="staticIp")
    def static_ip(self) -> _builtins.str:
        """
        The IP the device should use on the WAN.
        """
        return pulumi.get(self, "static_ip")

    @_builtins.property
    @pulumi.getter(name="staticSubnetMask")
    def static_subnet_mask(self) -> _builtins.str:
        """
        The subnet mask for the WAN.
        """
        return pulumi.get(self, "static_subnet_mask")

    @_builtins.property
    @pulumi.getter(name="usingStaticIp")
    def using_static_ip(self) -> _builtins.bool:
        """
        Configure the interface to have static IP settings or use DHCP.
        """
        return pulumi.get(self, "using_static_ip")

    @_builtins.property
    @pulumi.getter
    def vlan(self) -> _builtins.int:
        """
        The VLAN that management traffic should be tagged with. Applies whether usingStaticIp is true or false.
        """
        return pulumi.get(self, "vlan")

    @_builtins.property
    @pulumi.getter(name="wanEnabled")
    def wan_enabled(self) -> _builtins.str:
        """
        Enable or disable the interface (only for MX devices). Valid values are 'enabled', 'disabled', and 'not configured'.
        """
        return pulumi.get(self, "wan_enabled")


@pulumi.output_type
class GetManagementInterfaceItemWan2Result(dict):
    def __init__(__self__, *,
                 static_dns: Sequence[_builtins.str],
                 static_gateway_ip: _builtins.str,
                 static_ip: _builtins.str,
                 static_subnet_mask: _builtins.str,
                 using_static_ip: _builtins.bool,
                 vlan: _builtins.int,
                 wan_enabled: _builtins.str):
        """
        :param Sequence[_builtins.str] static_dns: Up to two DNS IPs.
        :param _builtins.str static_gateway_ip: The IP of the gateway on the WAN.
        :param _builtins.str static_ip: The IP the device should use on the WAN.
        :param _builtins.str static_subnet_mask: The subnet mask for the WAN.
        :param _builtins.bool using_static_ip: Configure the interface to have static IP settings or use DHCP.
        :param _builtins.int vlan: The VLAN that management traffic should be tagged with. Applies whether usingStaticIp is true or false.
        :param _builtins.str wan_enabled: Enable or disable the interface (only for MX devices). Valid values are 'enabled', 'disabled', and 'not configured'.
        """
        pulumi.set(__self__, "static_dns", static_dns)
        pulumi.set(__self__, "static_gateway_ip", static_gateway_ip)
        pulumi.set(__self__, "static_ip", static_ip)
        pulumi.set(__self__, "static_subnet_mask", static_subnet_mask)
        pulumi.set(__self__, "using_static_ip", using_static_ip)
        pulumi.set(__self__, "vlan", vlan)
        pulumi.set(__self__, "wan_enabled", wan_enabled)

    @_builtins.property
    @pulumi.getter(name="staticDns")
    def static_dns(self) -> Sequence[_builtins.str]:
        """
        Up to two DNS IPs.
        """
        return pulumi.get(self, "static_dns")

    @_builtins.property
    @pulumi.getter(name="staticGatewayIp")
    def static_gateway_ip(self) -> _builtins.str:
        """
        The IP of the gateway on the WAN.
        """
        return pulumi.get(self, "static_gateway_ip")

    @_builtins.property
    @pulumi.getter(name="staticIp")
    def static_ip(self) -> _builtins.str:
        """
        The IP the device should use on the WAN.
        """
        return pulumi.get(self, "static_ip")

    @_builtins.property
    @pulumi.getter(name="staticSubnetMask")
    def static_subnet_mask(self) -> _builtins.str:
        """
        The subnet mask for the WAN.
        """
        return pulumi.get(self, "static_subnet_mask")

    @_builtins.property
    @pulumi.getter(name="usingStaticIp")
    def using_static_ip(self) -> _builtins.bool:
        """
        Configure the interface to have static IP settings or use DHCP.
        """
        return pulumi.get(self, "using_static_ip")

    @_builtins.property
    @pulumi.getter
    def vlan(self) -> _builtins.int:
        """
        The VLAN that management traffic should be tagged with. Applies whether usingStaticIp is true or false.
        """
        return pulumi.get(self, "vlan")

    @_builtins.property
    @pulumi.getter(name="wanEnabled")
    def wan_enabled(self) -> _builtins.str:
        """
        Enable or disable the interface (only for MX devices). Valid values are 'enabled', 'disabled', and 'not configured'.
        """
        return pulumi.get(self, "wan_enabled")


@pulumi.output_type
class GetSensorRelationshipsItemResult(dict):
    def __init__(__self__, *,
                 livestream: 'outputs.GetSensorRelationshipsItemLivestreamResult'):
        """
        :param 'GetSensorRelationshipsItemLivestreamArgs' livestream: A role defined between an MT sensor and an MV camera that adds the camera's livestream to the sensor's details page. Snapshots from the camera will also appear in alert notifications that the sensor triggers.
        """
        pulumi.set(__self__, "livestream", livestream)

    @_builtins.property
    @pulumi.getter
    def livestream(self) -> 'outputs.GetSensorRelationshipsItemLivestreamResult':
        """
        A role defined between an MT sensor and an MV camera that adds the camera's livestream to the sensor's details page. Snapshots from the camera will also appear in alert notifications that the sensor triggers.
        """
        return pulumi.get(self, "livestream")


@pulumi.output_type
class GetSensorRelationshipsItemLivestreamResult(dict):
    def __init__(__self__, *,
                 related_devices: Sequence['outputs.GetSensorRelationshipsItemLivestreamRelatedDeviceResult']):
        """
        :param Sequence['GetSensorRelationshipsItemLivestreamRelatedDeviceArgs'] related_devices: An array of the related devices for the role
        """
        pulumi.set(__self__, "related_devices", related_devices)

    @_builtins.property
    @pulumi.getter(name="relatedDevices")
    def related_devices(self) -> Sequence['outputs.GetSensorRelationshipsItemLivestreamRelatedDeviceResult']:
        """
        An array of the related devices for the role
        """
        return pulumi.get(self, "related_devices")


@pulumi.output_type
class GetSensorRelationshipsItemLivestreamRelatedDeviceResult(dict):
    def __init__(__self__, *,
                 product_type: _builtins.str,
                 serial: _builtins.str):
        """
        :param _builtins.str product_type: The product type of the related device
        :param _builtins.str serial: The serial of the related device
        """
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        The product type of the related device
        """
        return pulumi.get(self, "product_type")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        The serial of the related device
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class GetSwitchPortsItemResult(dict):
    def __init__(__self__, *,
                 access_policy_number: _builtins.int,
                 access_policy_type: _builtins.str,
                 adaptive_policy_group_id: _builtins.str,
                 allowed_vlans: _builtins.str,
                 dai_trusted: _builtins.bool,
                 enabled: _builtins.bool,
                 flexible_stacking_enabled: _builtins.bool,
                 isolation_enabled: _builtins.bool,
                 link_negotiation: _builtins.str,
                 link_negotiation_capabilities: Sequence[_builtins.str],
                 mac_allow_lists: Sequence[_builtins.str],
                 mirror: 'outputs.GetSwitchPortsItemMirrorResult',
                 module: 'outputs.GetSwitchPortsItemModuleResult',
                 name: _builtins.str,
                 peer_sgt_capable: _builtins.bool,
                 poe_enabled: _builtins.bool,
                 port_id: _builtins.str,
                 port_schedule_id: _builtins.str,
                 profile: 'outputs.GetSwitchPortsItemProfileResult',
                 rstp_enabled: _builtins.bool,
                 sticky_mac_allow_list_limit: _builtins.int,
                 sticky_mac_allow_lists: Sequence[_builtins.str],
                 storm_control_enabled: _builtins.bool,
                 stp_guard: _builtins.str,
                 tags: Sequence[_builtins.str],
                 type: _builtins.str,
                 udld: _builtins.str,
                 vlan: _builtins.int,
                 voice_vlan: _builtins.int):
        """
        :param _builtins.int access_policy_number: The number of a custom access policy to configure on the switch port. Only applicable when 'accessPolicyType' is 'Custom access policy'.
        :param _builtins.str access_policy_type: The type of the access policy of the switch port. Only applicable to access ports. Can be one of 'Open', 'Custom access policy', 'MAC allow list' or 'Sticky MAC allow list'.
        :param _builtins.str adaptive_policy_group_id: The adaptive policy group ID that will be used to tag traffic through this switch port. This ID must pre-exist during the configuration, else needs to be created using adaptivePolicy/groups API. Cannot be applied to a port on a switch bound to profile.
        :param _builtins.str allowed_vlans: The VLANs allowed on the switch port. Only applicable to trunk ports.
        :param _builtins.bool dai_trusted: If true, ARP packets for this port will be considered trusted, and Dynamic ARP Inspection will allow the traffic.
        :param _builtins.bool enabled: The status of the switch port.
        :param _builtins.bool flexible_stacking_enabled: For supported switches (e.g. MS420/MS425), whether or not the port has flexible stacking enabled.
        :param _builtins.bool isolation_enabled: The isolation status of the switch port.
        :param _builtins.str link_negotiation: The link speed for the switch port.
        :param Sequence[_builtins.str] link_negotiation_capabilities: Available link speeds for the switch port.
        :param Sequence[_builtins.str] mac_allow_lists: Only devices with MAC addresses specified in this list will have access to this port. Up to 20 MAC addresses can be defined. Only applicable when 'accessPolicyType' is 'MAC allow list'.
        :param 'GetSwitchPortsItemMirrorArgs' mirror: Port mirror
        :param 'GetSwitchPortsItemModuleArgs' module: Expansion module
        :param _builtins.str name: The name of the switch port.
        :param _builtins.bool peer_sgt_capable: If true, Peer SGT is enabled for traffic through this switch port. Applicable to trunk port only, not access port. Cannot be applied to a port on a switch bound to profile.
        :param _builtins.bool poe_enabled: The PoE status of the switch port.
        :param _builtins.str port_id: The identifier of the switch port.
        :param _builtins.str port_schedule_id: The ID of the port schedule. A value of null will clear the port schedule.
        :param 'GetSwitchPortsItemProfileArgs' profile: Profile attributes
        :param _builtins.bool rstp_enabled: The rapid spanning tree protocol status.
        :param _builtins.int sticky_mac_allow_list_limit: The maximum number of MAC addresses for sticky MAC allow list. Only applicable when 'accessPolicyType' is 'Sticky MAC allow list'.
        :param Sequence[_builtins.str] sticky_mac_allow_lists: The initial list of MAC addresses for sticky Mac allow list. Only applicable when 'accessPolicyType' is 'Sticky MAC allow list'.
        :param _builtins.bool storm_control_enabled: The storm control status of the switch port.
        :param _builtins.str stp_guard: The state of the STP guard ('disabled', 'root guard', 'bpdu guard' or 'loop guard').
        :param Sequence[_builtins.str] tags: The list of tags of the switch port.
        :param _builtins.str type: The type of the switch port ('trunk' or 'access').
        :param _builtins.str udld: The action to take when Unidirectional Link is detected (Alert only, Enforce). Default configuration is Alert only.
        :param _builtins.int vlan: The VLAN of the switch port. For a trunk port, this is the native VLAN. A null value will clear the value set for trunk ports.
        :param _builtins.int voice_vlan: The voice VLAN of the switch port. Only applicable to access ports.
        """
        pulumi.set(__self__, "access_policy_number", access_policy_number)
        pulumi.set(__self__, "access_policy_type", access_policy_type)
        pulumi.set(__self__, "adaptive_policy_group_id", adaptive_policy_group_id)
        pulumi.set(__self__, "allowed_vlans", allowed_vlans)
        pulumi.set(__self__, "dai_trusted", dai_trusted)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "flexible_stacking_enabled", flexible_stacking_enabled)
        pulumi.set(__self__, "isolation_enabled", isolation_enabled)
        pulumi.set(__self__, "link_negotiation", link_negotiation)
        pulumi.set(__self__, "link_negotiation_capabilities", link_negotiation_capabilities)
        pulumi.set(__self__, "mac_allow_lists", mac_allow_lists)
        pulumi.set(__self__, "mirror", mirror)
        pulumi.set(__self__, "module", module)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "peer_sgt_capable", peer_sgt_capable)
        pulumi.set(__self__, "poe_enabled", poe_enabled)
        pulumi.set(__self__, "port_id", port_id)
        pulumi.set(__self__, "port_schedule_id", port_schedule_id)
        pulumi.set(__self__, "profile", profile)
        pulumi.set(__self__, "rstp_enabled", rstp_enabled)
        pulumi.set(__self__, "sticky_mac_allow_list_limit", sticky_mac_allow_list_limit)
        pulumi.set(__self__, "sticky_mac_allow_lists", sticky_mac_allow_lists)
        pulumi.set(__self__, "storm_control_enabled", storm_control_enabled)
        pulumi.set(__self__, "stp_guard", stp_guard)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "udld", udld)
        pulumi.set(__self__, "vlan", vlan)
        pulumi.set(__self__, "voice_vlan", voice_vlan)

    @_builtins.property
    @pulumi.getter(name="accessPolicyNumber")
    def access_policy_number(self) -> _builtins.int:
        """
        The number of a custom access policy to configure on the switch port. Only applicable when 'accessPolicyType' is 'Custom access policy'.
        """
        return pulumi.get(self, "access_policy_number")

    @_builtins.property
    @pulumi.getter(name="accessPolicyType")
    def access_policy_type(self) -> _builtins.str:
        """
        The type of the access policy of the switch port. Only applicable to access ports. Can be one of 'Open', 'Custom access policy', 'MAC allow list' or 'Sticky MAC allow list'.
        """
        return pulumi.get(self, "access_policy_type")

    @_builtins.property
    @pulumi.getter(name="adaptivePolicyGroupId")
    def adaptive_policy_group_id(self) -> _builtins.str:
        """
        The adaptive policy group ID that will be used to tag traffic through this switch port. This ID must pre-exist during the configuration, else needs to be created using adaptivePolicy/groups API. Cannot be applied to a port on a switch bound to profile.
        """
        return pulumi.get(self, "adaptive_policy_group_id")

    @_builtins.property
    @pulumi.getter(name="allowedVlans")
    def allowed_vlans(self) -> _builtins.str:
        """
        The VLANs allowed on the switch port. Only applicable to trunk ports.
        """
        return pulumi.get(self, "allowed_vlans")

    @_builtins.property
    @pulumi.getter(name="daiTrusted")
    def dai_trusted(self) -> _builtins.bool:
        """
        If true, ARP packets for this port will be considered trusted, and Dynamic ARP Inspection will allow the traffic.
        """
        return pulumi.get(self, "dai_trusted")

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        The status of the switch port.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter(name="flexibleStackingEnabled")
    def flexible_stacking_enabled(self) -> _builtins.bool:
        """
        For supported switches (e.g. MS420/MS425), whether or not the port has flexible stacking enabled.
        """
        return pulumi.get(self, "flexible_stacking_enabled")

    @_builtins.property
    @pulumi.getter(name="isolationEnabled")
    def isolation_enabled(self) -> _builtins.bool:
        """
        The isolation status of the switch port.
        """
        return pulumi.get(self, "isolation_enabled")

    @_builtins.property
    @pulumi.getter(name="linkNegotiation")
    def link_negotiation(self) -> _builtins.str:
        """
        The link speed for the switch port.
        """
        return pulumi.get(self, "link_negotiation")

    @_builtins.property
    @pulumi.getter(name="linkNegotiationCapabilities")
    def link_negotiation_capabilities(self) -> Sequence[_builtins.str]:
        """
        Available link speeds for the switch port.
        """
        return pulumi.get(self, "link_negotiation_capabilities")

    @_builtins.property
    @pulumi.getter(name="macAllowLists")
    def mac_allow_lists(self) -> Sequence[_builtins.str]:
        """
        Only devices with MAC addresses specified in this list will have access to this port. Up to 20 MAC addresses can be defined. Only applicable when 'accessPolicyType' is 'MAC allow list'.
        """
        return pulumi.get(self, "mac_allow_lists")

    @_builtins.property
    @pulumi.getter
    def mirror(self) -> 'outputs.GetSwitchPortsItemMirrorResult':
        """
        Port mirror
        """
        return pulumi.get(self, "mirror")

    @_builtins.property
    @pulumi.getter
    def module(self) -> 'outputs.GetSwitchPortsItemModuleResult':
        """
        Expansion module
        """
        return pulumi.get(self, "module")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        The name of the switch port.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="peerSgtCapable")
    def peer_sgt_capable(self) -> _builtins.bool:
        """
        If true, Peer SGT is enabled for traffic through this switch port. Applicable to trunk port only, not access port. Cannot be applied to a port on a switch bound to profile.
        """
        return pulumi.get(self, "peer_sgt_capable")

    @_builtins.property
    @pulumi.getter(name="poeEnabled")
    def poe_enabled(self) -> _builtins.bool:
        """
        The PoE status of the switch port.
        """
        return pulumi.get(self, "poe_enabled")

    @_builtins.property
    @pulumi.getter(name="portId")
    def port_id(self) -> _builtins.str:
        """
        The identifier of the switch port.
        """
        return pulumi.get(self, "port_id")

    @_builtins.property
    @pulumi.getter(name="portScheduleId")
    def port_schedule_id(self) -> _builtins.str:
        """
        The ID of the port schedule. A value of null will clear the port schedule.
        """
        return pulumi.get(self, "port_schedule_id")

    @_builtins.property
    @pulumi.getter
    def profile(self) -> 'outputs.GetSwitchPortsItemProfileResult':
        """
        Profile attributes
        """
        return pulumi.get(self, "profile")

    @_builtins.property
    @pulumi.getter(name="rstpEnabled")
    def rstp_enabled(self) -> _builtins.bool:
        """
        The rapid spanning tree protocol status.
        """
        return pulumi.get(self, "rstp_enabled")

    @_builtins.property
    @pulumi.getter(name="stickyMacAllowListLimit")
    def sticky_mac_allow_list_limit(self) -> _builtins.int:
        """
        The maximum number of MAC addresses for sticky MAC allow list. Only applicable when 'accessPolicyType' is 'Sticky MAC allow list'.
        """
        return pulumi.get(self, "sticky_mac_allow_list_limit")

    @_builtins.property
    @pulumi.getter(name="stickyMacAllowLists")
    def sticky_mac_allow_lists(self) -> Sequence[_builtins.str]:
        """
        The initial list of MAC addresses for sticky Mac allow list. Only applicable when 'accessPolicyType' is 'Sticky MAC allow list'.
        """
        return pulumi.get(self, "sticky_mac_allow_lists")

    @_builtins.property
    @pulumi.getter(name="stormControlEnabled")
    def storm_control_enabled(self) -> _builtins.bool:
        """
        The storm control status of the switch port.
        """
        return pulumi.get(self, "storm_control_enabled")

    @_builtins.property
    @pulumi.getter(name="stpGuard")
    def stp_guard(self) -> _builtins.str:
        """
        The state of the STP guard ('disabled', 'root guard', 'bpdu guard' or 'loop guard').
        """
        return pulumi.get(self, "stp_guard")

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Sequence[_builtins.str]:
        """
        The list of tags of the switch port.
        """
        return pulumi.get(self, "tags")

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        The type of the switch port ('trunk' or 'access').
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def udld(self) -> _builtins.str:
        """
        The action to take when Unidirectional Link is detected (Alert only, Enforce). Default configuration is Alert only.
        """
        return pulumi.get(self, "udld")

    @_builtins.property
    @pulumi.getter
    def vlan(self) -> _builtins.int:
        """
        The VLAN of the switch port. For a trunk port, this is the native VLAN. A null value will clear the value set for trunk ports.
        """
        return pulumi.get(self, "vlan")

    @_builtins.property
    @pulumi.getter(name="voiceVlan")
    def voice_vlan(self) -> _builtins.int:
        """
        The voice VLAN of the switch port. Only applicable to access ports.
        """
        return pulumi.get(self, "voice_vlan")


@pulumi.output_type
class GetSwitchPortsItemMirrorResult(dict):
    def __init__(__self__, *,
                 mode: _builtins.str):
        """
        :param _builtins.str mode: The port mirror mode. Can be one of ('Destination port', 'Source port' or 'Not mirroring traffic').
        """
        pulumi.set(__self__, "mode", mode)

    @_builtins.property
    @pulumi.getter
    def mode(self) -> _builtins.str:
        """
        The port mirror mode. Can be one of ('Destination port', 'Source port' or 'Not mirroring traffic').
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetSwitchPortsItemModuleResult(dict):
    def __init__(__self__, *,
                 model: _builtins.str):
        """
        :param _builtins.str model: The model of the expansion module.
        """
        pulumi.set(__self__, "model", model)

    @_builtins.property
    @pulumi.getter
    def model(self) -> _builtins.str:
        """
        The model of the expansion module.
        """
        return pulumi.get(self, "model")


@pulumi.output_type
class GetSwitchPortsItemProfileResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 id: _builtins.str,
                 iname: _builtins.str):
        """
        :param _builtins.bool enabled: When enabled, override this port's configuration with a port profile.
        :param _builtins.str id: When enabled, the ID of the port profile used to override the port's configuration.
        :param _builtins.str iname: When enabled, the IName of the profile.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "iname", iname)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        When enabled, override this port's configuration with a port profile.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        When enabled, the ID of the port profile used to override the port's configuration.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def iname(self) -> _builtins.str:
        """
        When enabled, the IName of the profile.
        """
        return pulumi.get(self, "iname")


@pulumi.output_type
class GetSwitchPortsStatusesItemResult(dict):
    def __init__(__self__, *,
                 cdp: 'outputs.GetSwitchPortsStatusesItemCdpResult',
                 client_count: _builtins.int,
                 duplex: _builtins.str,
                 enabled: _builtins.bool,
                 errors: Sequence[_builtins.str],
                 is_uplink: _builtins.bool,
                 lldp: 'outputs.GetSwitchPortsStatusesItemLldpResult',
                 port_id: _builtins.str,
                 power_usage_in_wh: _builtins.float,
                 secure_port: 'outputs.GetSwitchPortsStatusesItemSecurePortResult',
                 spanning_tree: 'outputs.GetSwitchPortsStatusesItemSpanningTreeResult',
                 speed: _builtins.str,
                 status: _builtins.str,
                 traffic_in_kbps: 'outputs.GetSwitchPortsStatusesItemTrafficInKbpsResult',
                 usage_in_kb: 'outputs.GetSwitchPortsStatusesItemUsageInKbResult',
                 warnings: Sequence[_builtins.str]):
        """
        :param 'GetSwitchPortsStatusesItemCdpArgs' cdp: The Cisco Discovery Protocol (CDP) information of the connected device.
        :param _builtins.int client_count: The number of clients connected through this port.
        :param _builtins.str duplex: The current duplex of a connected port.
        :param _builtins.bool enabled: Whether the port is configured to be enabled.
        :param Sequence[_builtins.str] errors: All errors present on the port.
        :param _builtins.bool is_uplink: Whether the port is the switch's uplink.
        :param 'GetSwitchPortsStatusesItemLldpArgs' lldp: The Link Layer Discovery Protocol (LLDP) information of the connected device.
        :param _builtins.str port_id: The string identifier of this port on the switch. This is commonly just the port number but may contain additional identifying information such as the slot and module-type if the port is located on a port module.
        :param _builtins.float power_usage_in_wh: How much power (in watt-hours) has been delivered by this port during the timespan.
        :param 'GetSwitchPortsStatusesItemSecurePortArgs' secure_port: The Secure Port status of the port.
        :param 'GetSwitchPortsStatusesItemSpanningTreeArgs' spanning_tree: The Spanning Tree Protocol (STP) information of the connected device.
        :param _builtins.str speed: The current data transfer rate which the port is operating at.
        :param _builtins.str status: The current connection status of the port.
        :param 'GetSwitchPortsStatusesItemTrafficInKbpsArgs' traffic_in_kbps: A breakdown of the average speed of data that has passed through this port during the timespan.
        :param 'GetSwitchPortsStatusesItemUsageInKbArgs' usage_in_kb: A breakdown of how many kilobytes have passed through this port during the timespan.
        :param Sequence[_builtins.str] warnings: All warnings present on the port.
        """
        pulumi.set(__self__, "cdp", cdp)
        pulumi.set(__self__, "client_count", client_count)
        pulumi.set(__self__, "duplex", duplex)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "errors", errors)
        pulumi.set(__self__, "is_uplink", is_uplink)
        pulumi.set(__self__, "lldp", lldp)
        pulumi.set(__self__, "port_id", port_id)
        pulumi.set(__self__, "power_usage_in_wh", power_usage_in_wh)
        pulumi.set(__self__, "secure_port", secure_port)
        pulumi.set(__self__, "spanning_tree", spanning_tree)
        pulumi.set(__self__, "speed", speed)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "traffic_in_kbps", traffic_in_kbps)
        pulumi.set(__self__, "usage_in_kb", usage_in_kb)
        pulumi.set(__self__, "warnings", warnings)

    @_builtins.property
    @pulumi.getter
    def cdp(self) -> 'outputs.GetSwitchPortsStatusesItemCdpResult':
        """
        The Cisco Discovery Protocol (CDP) information of the connected device.
        """
        return pulumi.get(self, "cdp")

    @_builtins.property
    @pulumi.getter(name="clientCount")
    def client_count(self) -> _builtins.int:
        """
        The number of clients connected through this port.
        """
        return pulumi.get(self, "client_count")

    @_builtins.property
    @pulumi.getter
    def duplex(self) -> _builtins.str:
        """
        The current duplex of a connected port.
        """
        return pulumi.get(self, "duplex")

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Whether the port is configured to be enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def errors(self) -> Sequence[_builtins.str]:
        """
        All errors present on the port.
        """
        return pulumi.get(self, "errors")

    @_builtins.property
    @pulumi.getter(name="isUplink")
    def is_uplink(self) -> _builtins.bool:
        """
        Whether the port is the switch's uplink.
        """
        return pulumi.get(self, "is_uplink")

    @_builtins.property
    @pulumi.getter
    def lldp(self) -> 'outputs.GetSwitchPortsStatusesItemLldpResult':
        """
        The Link Layer Discovery Protocol (LLDP) information of the connected device.
        """
        return pulumi.get(self, "lldp")

    @_builtins.property
    @pulumi.getter(name="portId")
    def port_id(self) -> _builtins.str:
        """
        The string identifier of this port on the switch. This is commonly just the port number but may contain additional identifying information such as the slot and module-type if the port is located on a port module.
        """
        return pulumi.get(self, "port_id")

    @_builtins.property
    @pulumi.getter(name="powerUsageInWh")
    def power_usage_in_wh(self) -> _builtins.float:
        """
        How much power (in watt-hours) has been delivered by this port during the timespan.
        """
        return pulumi.get(self, "power_usage_in_wh")

    @_builtins.property
    @pulumi.getter(name="securePort")
    def secure_port(self) -> 'outputs.GetSwitchPortsStatusesItemSecurePortResult':
        """
        The Secure Port status of the port.
        """
        return pulumi.get(self, "secure_port")

    @_builtins.property
    @pulumi.getter(name="spanningTree")
    def spanning_tree(self) -> 'outputs.GetSwitchPortsStatusesItemSpanningTreeResult':
        """
        The Spanning Tree Protocol (STP) information of the connected device.
        """
        return pulumi.get(self, "spanning_tree")

    @_builtins.property
    @pulumi.getter
    def speed(self) -> _builtins.str:
        """
        The current data transfer rate which the port is operating at.
        """
        return pulumi.get(self, "speed")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        The current connection status of the port.
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter(name="trafficInKbps")
    def traffic_in_kbps(self) -> 'outputs.GetSwitchPortsStatusesItemTrafficInKbpsResult':
        """
        A breakdown of the average speed of data that has passed through this port during the timespan.
        """
        return pulumi.get(self, "traffic_in_kbps")

    @_builtins.property
    @pulumi.getter(name="usageInKb")
    def usage_in_kb(self) -> 'outputs.GetSwitchPortsStatusesItemUsageInKbResult':
        """
        A breakdown of how many kilobytes have passed through this port during the timespan.
        """
        return pulumi.get(self, "usage_in_kb")

    @_builtins.property
    @pulumi.getter
    def warnings(self) -> Sequence[_builtins.str]:
        """
        All warnings present on the port.
        """
        return pulumi.get(self, "warnings")


@pulumi.output_type
class GetSwitchPortsStatusesItemCdpResult(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 capabilities: _builtins.str,
                 device_id: _builtins.str,
                 management_address: _builtins.str,
                 native_vlan: _builtins.int,
                 platform: _builtins.str,
                 port_id: _builtins.str,
                 system_name: _builtins.str,
                 version: _builtins.str,
                 vtp_management_domain: _builtins.str):
        """
        :param _builtins.str address: Contains network addresses of both receiving and sending devices.
        :param _builtins.str capabilities: Identifies the device type, which indicates the functional capabilities of the device.
        :param _builtins.str device_id: Identifies the device name.
        :param _builtins.str management_address: The device's management IP.
        :param _builtins.int native_vlan: Indicates, per interface, the assumed VLAN for untagged packets on the interface.
        :param _builtins.str platform: Identifies the hardware platform of the device.
        :param _builtins.str port_id: Identifies the port from which the CDP packet was sent.
        :param _builtins.str system_name: The system name.
        :param _builtins.str version: Contains the device software release information.
        :param _builtins.str vtp_management_domain: Advertises the configured VLAN Trunking Protocl (VTP)-management-domain name of the system.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "capabilities", capabilities)
        pulumi.set(__self__, "device_id", device_id)
        pulumi.set(__self__, "management_address", management_address)
        pulumi.set(__self__, "native_vlan", native_vlan)
        pulumi.set(__self__, "platform", platform)
        pulumi.set(__self__, "port_id", port_id)
        pulumi.set(__self__, "system_name", system_name)
        pulumi.set(__self__, "version", version)
        pulumi.set(__self__, "vtp_management_domain", vtp_management_domain)

    @_builtins.property
    @pulumi.getter
    def address(self) -> _builtins.str:
        """
        Contains network addresses of both receiving and sending devices.
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter
    def capabilities(self) -> _builtins.str:
        """
        Identifies the device type, which indicates the functional capabilities of the device.
        """
        return pulumi.get(self, "capabilities")

    @_builtins.property
    @pulumi.getter(name="deviceId")
    def device_id(self) -> _builtins.str:
        """
        Identifies the device name.
        """
        return pulumi.get(self, "device_id")

    @_builtins.property
    @pulumi.getter(name="managementAddress")
    def management_address(self) -> _builtins.str:
        """
        The device's management IP.
        """
        return pulumi.get(self, "management_address")

    @_builtins.property
    @pulumi.getter(name="nativeVlan")
    def native_vlan(self) -> _builtins.int:
        """
        Indicates, per interface, the assumed VLAN for untagged packets on the interface.
        """
        return pulumi.get(self, "native_vlan")

    @_builtins.property
    @pulumi.getter
    def platform(self) -> _builtins.str:
        """
        Identifies the hardware platform of the device.
        """
        return pulumi.get(self, "platform")

    @_builtins.property
    @pulumi.getter(name="portId")
    def port_id(self) -> _builtins.str:
        """
        Identifies the port from which the CDP packet was sent.
        """
        return pulumi.get(self, "port_id")

    @_builtins.property
    @pulumi.getter(name="systemName")
    def system_name(self) -> _builtins.str:
        """
        The system name.
        """
        return pulumi.get(self, "system_name")

    @_builtins.property
    @pulumi.getter
    def version(self) -> _builtins.str:
        """
        Contains the device software release information.
        """
        return pulumi.get(self, "version")

    @_builtins.property
    @pulumi.getter(name="vtpManagementDomain")
    def vtp_management_domain(self) -> _builtins.str:
        """
        Advertises the configured VLAN Trunking Protocl (VTP)-management-domain name of the system.
        """
        return pulumi.get(self, "vtp_management_domain")


@pulumi.output_type
class GetSwitchPortsStatusesItemLldpResult(dict):
    def __init__(__self__, *,
                 chassis_id: _builtins.str,
                 management_address: _builtins.str,
                 management_vlan: _builtins.int,
                 port_description: _builtins.str,
                 port_id: _builtins.str,
                 port_vlan: _builtins.int,
                 system_capabilities: _builtins.str,
                 system_description: _builtins.str,
                 system_name: _builtins.str):
        """
        :param _builtins.str chassis_id: The device's chassis ID.
        :param _builtins.str management_address: The device's management IP.
        :param _builtins.int management_vlan: The device's management VLAN.
        :param _builtins.str port_description: Description of the port from which the LLDP packet was sent.
        :param _builtins.str port_id: Identifies the port from which the LLDP packet was sent
        :param _builtins.int port_vlan: The port's VLAN.
        :param _builtins.str system_capabilities: Identifies the device type, which indicates the functional capabilities of the device.
        :param _builtins.str system_description: The device's system description.
        :param _builtins.str system_name: The device's system name.
        """
        pulumi.set(__self__, "chassis_id", chassis_id)
        pulumi.set(__self__, "management_address", management_address)
        pulumi.set(__self__, "management_vlan", management_vlan)
        pulumi.set(__self__, "port_description", port_description)
        pulumi.set(__self__, "port_id", port_id)
        pulumi.set(__self__, "port_vlan", port_vlan)
        pulumi.set(__self__, "system_capabilities", system_capabilities)
        pulumi.set(__self__, "system_description", system_description)
        pulumi.set(__self__, "system_name", system_name)

    @_builtins.property
    @pulumi.getter(name="chassisId")
    def chassis_id(self) -> _builtins.str:
        """
        The device's chassis ID.
        """
        return pulumi.get(self, "chassis_id")

    @_builtins.property
    @pulumi.getter(name="managementAddress")
    def management_address(self) -> _builtins.str:
        """
        The device's management IP.
        """
        return pulumi.get(self, "management_address")

    @_builtins.property
    @pulumi.getter(name="managementVlan")
    def management_vlan(self) -> _builtins.int:
        """
        The device's management VLAN.
        """
        return pulumi.get(self, "management_vlan")

    @_builtins.property
    @pulumi.getter(name="portDescription")
    def port_description(self) -> _builtins.str:
        """
        Description of the port from which the LLDP packet was sent.
        """
        return pulumi.get(self, "port_description")

    @_builtins.property
    @pulumi.getter(name="portId")
    def port_id(self) -> _builtins.str:
        """
        Identifies the port from which the LLDP packet was sent
        """
        return pulumi.get(self, "port_id")

    @_builtins.property
    @pulumi.getter(name="portVlan")
    def port_vlan(self) -> _builtins.int:
        """
        The port's VLAN.
        """
        return pulumi.get(self, "port_vlan")

    @_builtins.property
    @pulumi.getter(name="systemCapabilities")
    def system_capabilities(self) -> _builtins.str:
        """
        Identifies the device type, which indicates the functional capabilities of the device.
        """
        return pulumi.get(self, "system_capabilities")

    @_builtins.property
    @pulumi.getter(name="systemDescription")
    def system_description(self) -> _builtins.str:
        """
        The device's system description.
        """
        return pulumi.get(self, "system_description")

    @_builtins.property
    @pulumi.getter(name="systemName")
    def system_name(self) -> _builtins.str:
        """
        The device's system name.
        """
        return pulumi.get(self, "system_name")


@pulumi.output_type
class GetSwitchPortsStatusesItemSecurePortResult(dict):
    def __init__(__self__, *,
                 active: _builtins.bool,
                 authentication_status: _builtins.str,
                 config_overrides: 'outputs.GetSwitchPortsStatusesItemSecurePortConfigOverridesResult',
                 enabled: _builtins.bool):
        """
        :param _builtins.bool active: Whether Secure Port is currently active for this port.
        :param _builtins.str authentication_status: The current Secure Port status.
        :param 'GetSwitchPortsStatusesItemSecurePortConfigOverridesArgs' config_overrides: The configuration overrides applied to this port when Secure Port is active.
        :param _builtins.bool enabled: Whether Secure Port is turned on for this port.
        """
        pulumi.set(__self__, "active", active)
        pulumi.set(__self__, "authentication_status", authentication_status)
        pulumi.set(__self__, "config_overrides", config_overrides)
        pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def active(self) -> _builtins.bool:
        """
        Whether Secure Port is currently active for this port.
        """
        return pulumi.get(self, "active")

    @_builtins.property
    @pulumi.getter(name="authenticationStatus")
    def authentication_status(self) -> _builtins.str:
        """
        The current Secure Port status.
        """
        return pulumi.get(self, "authentication_status")

    @_builtins.property
    @pulumi.getter(name="configOverrides")
    def config_overrides(self) -> 'outputs.GetSwitchPortsStatusesItemSecurePortConfigOverridesResult':
        """
        The configuration overrides applied to this port when Secure Port is active.
        """
        return pulumi.get(self, "config_overrides")

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Whether Secure Port is turned on for this port.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetSwitchPortsStatusesItemSecurePortConfigOverridesResult(dict):
    def __init__(__self__, *,
                 allowed_vlans: _builtins.str,
                 type: _builtins.str,
                 vlan: _builtins.int,
                 voice_vlan: _builtins.int):
        """
        :param _builtins.str allowed_vlans: The VLANs allowed on the . Only applicable to trunk ports.
        :param _builtins.str type: The type of the  ('trunk' or 'access').
        :param _builtins.int vlan: The VLAN of the . For a trunk port, this is the native VLAN. A null value will clear the value set for trunk ports.
        :param _builtins.int voice_vlan: The voice VLAN of the . Only applicable to access ports.
        """
        pulumi.set(__self__, "allowed_vlans", allowed_vlans)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "vlan", vlan)
        pulumi.set(__self__, "voice_vlan", voice_vlan)

    @_builtins.property
    @pulumi.getter(name="allowedVlans")
    def allowed_vlans(self) -> _builtins.str:
        """
        The VLANs allowed on the . Only applicable to trunk ports.
        """
        return pulumi.get(self, "allowed_vlans")

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        The type of the  ('trunk' or 'access').
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def vlan(self) -> _builtins.int:
        """
        The VLAN of the . For a trunk port, this is the native VLAN. A null value will clear the value set for trunk ports.
        """
        return pulumi.get(self, "vlan")

    @_builtins.property
    @pulumi.getter(name="voiceVlan")
    def voice_vlan(self) -> _builtins.int:
        """
        The voice VLAN of the . Only applicable to access ports.
        """
        return pulumi.get(self, "voice_vlan")


@pulumi.output_type
class GetSwitchPortsStatusesItemSpanningTreeResult(dict):
    def __init__(__self__, *,
                 statuses: Sequence[_builtins.str]):
        """
        :param Sequence[_builtins.str] statuses: The current Spanning Tree Protocol statuses of the port.
        """
        pulumi.set(__self__, "statuses", statuses)

    @_builtins.property
    @pulumi.getter
    def statuses(self) -> Sequence[_builtins.str]:
        """
        The current Spanning Tree Protocol statuses of the port.
        """
        return pulumi.get(self, "statuses")


@pulumi.output_type
class GetSwitchPortsStatusesItemTrafficInKbpsResult(dict):
    def __init__(__self__, *,
                 recv: _builtins.float,
                 sent: _builtins.float,
                 total: _builtins.float):
        """
        :param _builtins.float recv: The average speed of the data received (in kilobits-per-second).
        :param _builtins.float sent: The average speed of the data sent (in kilobits-per-second).
        :param _builtins.float total: The average speed of the data sent and received (in kilobits-per-second).
        """
        pulumi.set(__self__, "recv", recv)
        pulumi.set(__self__, "sent", sent)
        pulumi.set(__self__, "total", total)

    @_builtins.property
    @pulumi.getter
    def recv(self) -> _builtins.float:
        """
        The average speed of the data received (in kilobits-per-second).
        """
        return pulumi.get(self, "recv")

    @_builtins.property
    @pulumi.getter
    def sent(self) -> _builtins.float:
        """
        The average speed of the data sent (in kilobits-per-second).
        """
        return pulumi.get(self, "sent")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.float:
        """
        The average speed of the data sent and received (in kilobits-per-second).
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetSwitchPortsStatusesItemUsageInKbResult(dict):
    def __init__(__self__, *,
                 recv: _builtins.int,
                 sent: _builtins.int,
                 total: _builtins.int):
        """
        :param _builtins.int recv: The amount of data received (in kilobytes).
        :param _builtins.int sent: The amount of data sent (in kilobytes).
        :param _builtins.int total: The total amount of data sent and received (in kilobytes).
        """
        pulumi.set(__self__, "recv", recv)
        pulumi.set(__self__, "sent", sent)
        pulumi.set(__self__, "total", total)

    @_builtins.property
    @pulumi.getter
    def recv(self) -> _builtins.int:
        """
        The amount of data received (in kilobytes).
        """
        return pulumi.get(self, "recv")

    @_builtins.property
    @pulumi.getter
    def sent(self) -> _builtins.int:
        """
        The amount of data sent (in kilobytes).
        """
        return pulumi.get(self, "sent")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        The total amount of data sent and received (in kilobytes).
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetSwitchRoutingInterfacesDhcpItemResult(dict):
    def __init__(__self__, *,
                 boot_file_name: _builtins.str,
                 boot_next_server: _builtins.str,
                 boot_options_enabled: _builtins.bool,
                 dhcp_lease_time: _builtins.str,
                 dhcp_mode: _builtins.str,
                 dhcp_options: Sequence['outputs.GetSwitchRoutingInterfacesDhcpItemDhcpOptionResult'],
                 dhcp_relay_server_ips: Sequence[_builtins.str],
                 dns_custom_nameservers: Sequence[_builtins.str],
                 dns_nameservers_option: _builtins.str,
                 fixed_ip_assignments: Sequence['outputs.GetSwitchRoutingInterfacesDhcpItemFixedIpAssignmentResult'],
                 reserved_ip_ranges: Sequence['outputs.GetSwitchRoutingInterfacesDhcpItemReservedIpRangeResult']):
        """
        :param _builtins.str boot_file_name: The PXE boot server file name for the DHCP server running on the switch stack interface
        :param _builtins.str boot_next_server: The PXE boot server IP for the DHCP server running on the switch stack interface
        :param _builtins.bool boot_options_enabled: Enable DHCP boot options to provide PXE boot options configs for the dhcp server running on the switch stack interface
        :param _builtins.str dhcp_lease_time: The DHCP lease time config for the dhcp server running on the switch stack interface ('30 minutes', '1 hour', '4 hours', '12 hours', '1 day' or '1 week')
        :param _builtins.str dhcp_mode: The DHCP mode options for the switch stack interface ('dhcpDisabled', 'dhcpRelay' or 'dhcpServer')
        :param Sequence['GetSwitchRoutingInterfacesDhcpItemDhcpOptionArgs'] dhcp_options: Array of DHCP options consisting of code, type and value for the DHCP server running on the switch stack interface
        :param Sequence[_builtins.str] dhcp_relay_server_ips: The DHCP relay server IPs to which DHCP packets would get relayed for the switch stack interface
        :param Sequence[_builtins.str] dns_custom_nameservers: The DHCP name server IPs when DHCP name server option is 'custom'
        :param _builtins.str dns_nameservers_option: The DHCP name server option for the dhcp server running on the switch stack interface ('googlePublicDns', 'openDns' or 'custom')
        :param Sequence['GetSwitchRoutingInterfacesDhcpItemFixedIpAssignmentArgs'] fixed_ip_assignments: Array of DHCP reserved IP assignments for the DHCP server running on the switch stack interface
        :param Sequence['GetSwitchRoutingInterfacesDhcpItemReservedIpRangeArgs'] reserved_ip_ranges: Array of DHCP reserved IP assignments for the DHCP server running on the switch stack interface
        """
        pulumi.set(__self__, "boot_file_name", boot_file_name)
        pulumi.set(__self__, "boot_next_server", boot_next_server)
        pulumi.set(__self__, "boot_options_enabled", boot_options_enabled)
        pulumi.set(__self__, "dhcp_lease_time", dhcp_lease_time)
        pulumi.set(__self__, "dhcp_mode", dhcp_mode)
        pulumi.set(__self__, "dhcp_options", dhcp_options)
        pulumi.set(__self__, "dhcp_relay_server_ips", dhcp_relay_server_ips)
        pulumi.set(__self__, "dns_custom_nameservers", dns_custom_nameservers)
        pulumi.set(__self__, "dns_nameservers_option", dns_nameservers_option)
        pulumi.set(__self__, "fixed_ip_assignments", fixed_ip_assignments)
        pulumi.set(__self__, "reserved_ip_ranges", reserved_ip_ranges)

    @_builtins.property
    @pulumi.getter(name="bootFileName")
    def boot_file_name(self) -> _builtins.str:
        """
        The PXE boot server file name for the DHCP server running on the switch stack interface
        """
        return pulumi.get(self, "boot_file_name")

    @_builtins.property
    @pulumi.getter(name="bootNextServer")
    def boot_next_server(self) -> _builtins.str:
        """
        The PXE boot server IP for the DHCP server running on the switch stack interface
        """
        return pulumi.get(self, "boot_next_server")

    @_builtins.property
    @pulumi.getter(name="bootOptionsEnabled")
    def boot_options_enabled(self) -> _builtins.bool:
        """
        Enable DHCP boot options to provide PXE boot options configs for the dhcp server running on the switch stack interface
        """
        return pulumi.get(self, "boot_options_enabled")

    @_builtins.property
    @pulumi.getter(name="dhcpLeaseTime")
    def dhcp_lease_time(self) -> _builtins.str:
        """
        The DHCP lease time config for the dhcp server running on the switch stack interface ('30 minutes', '1 hour', '4 hours', '12 hours', '1 day' or '1 week')
        """
        return pulumi.get(self, "dhcp_lease_time")

    @_builtins.property
    @pulumi.getter(name="dhcpMode")
    def dhcp_mode(self) -> _builtins.str:
        """
        The DHCP mode options for the switch stack interface ('dhcpDisabled', 'dhcpRelay' or 'dhcpServer')
        """
        return pulumi.get(self, "dhcp_mode")

    @_builtins.property
    @pulumi.getter(name="dhcpOptions")
    def dhcp_options(self) -> Sequence['outputs.GetSwitchRoutingInterfacesDhcpItemDhcpOptionResult']:
        """
        Array of DHCP options consisting of code, type and value for the DHCP server running on the switch stack interface
        """
        return pulumi.get(self, "dhcp_options")

    @_builtins.property
    @pulumi.getter(name="dhcpRelayServerIps")
    def dhcp_relay_server_ips(self) -> Sequence[_builtins.str]:
        """
        The DHCP relay server IPs to which DHCP packets would get relayed for the switch stack interface
        """
        return pulumi.get(self, "dhcp_relay_server_ips")

    @_builtins.property
    @pulumi.getter(name="dnsCustomNameservers")
    def dns_custom_nameservers(self) -> Sequence[_builtins.str]:
        """
        The DHCP name server IPs when DHCP name server option is 'custom'
        """
        return pulumi.get(self, "dns_custom_nameservers")

    @_builtins.property
    @pulumi.getter(name="dnsNameserversOption")
    def dns_nameservers_option(self) -> _builtins.str:
        """
        The DHCP name server option for the dhcp server running on the switch stack interface ('googlePublicDns', 'openDns' or 'custom')
        """
        return pulumi.get(self, "dns_nameservers_option")

    @_builtins.property
    @pulumi.getter(name="fixedIpAssignments")
    def fixed_ip_assignments(self) -> Sequence['outputs.GetSwitchRoutingInterfacesDhcpItemFixedIpAssignmentResult']:
        """
        Array of DHCP reserved IP assignments for the DHCP server running on the switch stack interface
        """
        return pulumi.get(self, "fixed_ip_assignments")

    @_builtins.property
    @pulumi.getter(name="reservedIpRanges")
    def reserved_ip_ranges(self) -> Sequence['outputs.GetSwitchRoutingInterfacesDhcpItemReservedIpRangeResult']:
        """
        Array of DHCP reserved IP assignments for the DHCP server running on the switch stack interface
        """
        return pulumi.get(self, "reserved_ip_ranges")


@pulumi.output_type
class GetSwitchRoutingInterfacesDhcpItemDhcpOptionResult(dict):
    def __init__(__self__, *,
                 code: _builtins.str,
                 type: _builtins.str,
                 value: _builtins.str):
        """
        :param _builtins.str code: The code for DHCP option which should be from 2 to 254
        :param _builtins.str type: The type of the DHCP option which should be one of ('text', 'ip', 'integer' or 'hex')
        :param _builtins.str value: The value of the DHCP option
        """
        pulumi.set(__self__, "code", code)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def code(self) -> _builtins.str:
        """
        The code for DHCP option which should be from 2 to 254
        """
        return pulumi.get(self, "code")

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        The type of the DHCP option which should be one of ('text', 'ip', 'integer' or 'hex')
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def value(self) -> _builtins.str:
        """
        The value of the DHCP option
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetSwitchRoutingInterfacesDhcpItemFixedIpAssignmentResult(dict):
    def __init__(__self__, *,
                 ip: _builtins.str,
                 mac: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str ip: The IP address of the client which has fixed IP address assigned to it
        :param _builtins.str mac: The MAC address of the client which has fixed IP address
        :param _builtins.str name: The name of the client which has fixed IP address
        """
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def ip(self) -> _builtins.str:
        """
        The IP address of the client which has fixed IP address assigned to it
        """
        return pulumi.get(self, "ip")

    @_builtins.property
    @pulumi.getter
    def mac(self) -> _builtins.str:
        """
        The MAC address of the client which has fixed IP address
        """
        return pulumi.get(self, "mac")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        The name of the client which has fixed IP address
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetSwitchRoutingInterfacesDhcpItemReservedIpRangeResult(dict):
    def __init__(__self__, *,
                 comment: _builtins.str,
                 end: _builtins.str,
                 start: _builtins.str):
        """
        :param _builtins.str comment: The comment for the reserved IP range
        :param _builtins.str end: The ending IP address of the reserved IP range
        :param _builtins.str start: The starting IP address of the reserved IP range
        """
        pulumi.set(__self__, "comment", comment)
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @_builtins.property
    @pulumi.getter
    def comment(self) -> _builtins.str:
        """
        The comment for the reserved IP range
        """
        return pulumi.get(self, "comment")

    @_builtins.property
    @pulumi.getter
    def end(self) -> _builtins.str:
        """
        The ending IP address of the reserved IP range
        """
        return pulumi.get(self, "end")

    @_builtins.property
    @pulumi.getter
    def start(self) -> _builtins.str:
        """
        The starting IP address of the reserved IP range
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class GetSwitchRoutingInterfacesItemResult(dict):
    def __init__(__self__, *,
                 default_gateway: _builtins.str,
                 interface_id: _builtins.str,
                 interface_ip: _builtins.str,
                 ipv6: 'outputs.GetSwitchRoutingInterfacesItemIpv6Result',
                 multicast_routing: _builtins.str,
                 name: _builtins.str,
                 ospf_settings: 'outputs.GetSwitchRoutingInterfacesItemOspfSettingsResult',
                 ospf_v3: 'outputs.GetSwitchRoutingInterfacesItemOspfV3Result',
                 subnet: _builtins.str,
                 vlan_id: _builtins.int):
        """
        :param _builtins.str default_gateway: IPv4 default gateway
        :param _builtins.str interface_id: The id
        :param _builtins.str interface_ip: IPv4 address
        :param 'GetSwitchRoutingInterfacesItemIpv6Args' ipv6: IPv6 addressing
        :param _builtins.str multicast_routing: Multicast routing status
        :param _builtins.str name: The name
        :param 'GetSwitchRoutingInterfacesItemOspfSettingsArgs' ospf_settings: IPv4 OSPF Settings
        :param 'GetSwitchRoutingInterfacesItemOspfV3Args' ospf_v3: IPv6 OSPF Settings
        :param _builtins.str subnet: IPv4 subnet
        :param _builtins.int vlan_id: VLAN id
        """
        pulumi.set(__self__, "default_gateway", default_gateway)
        pulumi.set(__self__, "interface_id", interface_id)
        pulumi.set(__self__, "interface_ip", interface_ip)
        pulumi.set(__self__, "ipv6", ipv6)
        pulumi.set(__self__, "multicast_routing", multicast_routing)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "ospf_settings", ospf_settings)
        pulumi.set(__self__, "ospf_v3", ospf_v3)
        pulumi.set(__self__, "subnet", subnet)
        pulumi.set(__self__, "vlan_id", vlan_id)

    @_builtins.property
    @pulumi.getter(name="defaultGateway")
    def default_gateway(self) -> _builtins.str:
        """
        IPv4 default gateway
        """
        return pulumi.get(self, "default_gateway")

    @_builtins.property
    @pulumi.getter(name="interfaceId")
    def interface_id(self) -> _builtins.str:
        """
        The id
        """
        return pulumi.get(self, "interface_id")

    @_builtins.property
    @pulumi.getter(name="interfaceIp")
    def interface_ip(self) -> _builtins.str:
        """
        IPv4 address
        """
        return pulumi.get(self, "interface_ip")

    @_builtins.property
    @pulumi.getter
    def ipv6(self) -> 'outputs.GetSwitchRoutingInterfacesItemIpv6Result':
        """
        IPv6 addressing
        """
        return pulumi.get(self, "ipv6")

    @_builtins.property
    @pulumi.getter(name="multicastRouting")
    def multicast_routing(self) -> _builtins.str:
        """
        Multicast routing status
        """
        return pulumi.get(self, "multicast_routing")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        The name
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="ospfSettings")
    def ospf_settings(self) -> 'outputs.GetSwitchRoutingInterfacesItemOspfSettingsResult':
        """
        IPv4 OSPF Settings
        """
        return pulumi.get(self, "ospf_settings")

    @_builtins.property
    @pulumi.getter(name="ospfV3")
    def ospf_v3(self) -> 'outputs.GetSwitchRoutingInterfacesItemOspfV3Result':
        """
        IPv6 OSPF Settings
        """
        return pulumi.get(self, "ospf_v3")

    @_builtins.property
    @pulumi.getter
    def subnet(self) -> _builtins.str:
        """
        IPv4 subnet
        """
        return pulumi.get(self, "subnet")

    @_builtins.property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> _builtins.int:
        """
        VLAN id
        """
        return pulumi.get(self, "vlan_id")


@pulumi.output_type
class GetSwitchRoutingInterfacesItemIpv6Result(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 assignment_mode: _builtins.str,
                 gateway: _builtins.str,
                 prefix: _builtins.str):
        """
        :param _builtins.str address: IPv6 address
        :param _builtins.str assignment_mode: Assignment mode
        :param _builtins.str gateway: IPv6 gateway
        :param _builtins.str prefix: IPv6 subnet
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "assignment_mode", assignment_mode)
        pulumi.set(__self__, "gateway", gateway)
        pulumi.set(__self__, "prefix", prefix)

    @_builtins.property
    @pulumi.getter
    def address(self) -> _builtins.str:
        """
        IPv6 address
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> _builtins.str:
        """
        Assignment mode
        """
        return pulumi.get(self, "assignment_mode")

    @_builtins.property
    @pulumi.getter
    def gateway(self) -> _builtins.str:
        """
        IPv6 gateway
        """
        return pulumi.get(self, "gateway")

    @_builtins.property
    @pulumi.getter
    def prefix(self) -> _builtins.str:
        """
        IPv6 subnet
        """
        return pulumi.get(self, "prefix")


@pulumi.output_type
class GetSwitchRoutingInterfacesItemOspfSettingsResult(dict):
    def __init__(__self__, *,
                 area: _builtins.str,
                 cost: _builtins.int,
                 is_passive_enabled: _builtins.bool):
        """
        :param _builtins.str area: Area id
        :param _builtins.int cost: OSPF Cost
        :param _builtins.bool is_passive_enabled: Disable sending Hello packets on this interface's IPv4 area
        """
        pulumi.set(__self__, "area", area)
        pulumi.set(__self__, "cost", cost)
        pulumi.set(__self__, "is_passive_enabled", is_passive_enabled)

    @_builtins.property
    @pulumi.getter
    def area(self) -> _builtins.str:
        """
        Area id
        """
        return pulumi.get(self, "area")

    @_builtins.property
    @pulumi.getter
    def cost(self) -> _builtins.int:
        """
        OSPF Cost
        """
        return pulumi.get(self, "cost")

    @_builtins.property
    @pulumi.getter(name="isPassiveEnabled")
    def is_passive_enabled(self) -> _builtins.bool:
        """
        Disable sending Hello packets on this interface's IPv4 area
        """
        return pulumi.get(self, "is_passive_enabled")


@pulumi.output_type
class GetSwitchRoutingInterfacesItemOspfV3Result(dict):
    def __init__(__self__, *,
                 area: _builtins.str,
                 cost: _builtins.int,
                 is_passive_enabled: _builtins.bool):
        """
        :param _builtins.str area: Area id
        :param _builtins.int cost: OSPF Cost
        :param _builtins.bool is_passive_enabled: Disable sending Hello packets on this interface's IPv6 area
        """
        pulumi.set(__self__, "area", area)
        pulumi.set(__self__, "cost", cost)
        pulumi.set(__self__, "is_passive_enabled", is_passive_enabled)

    @_builtins.property
    @pulumi.getter
    def area(self) -> _builtins.str:
        """
        Area id
        """
        return pulumi.get(self, "area")

    @_builtins.property
    @pulumi.getter
    def cost(self) -> _builtins.int:
        """
        OSPF Cost
        """
        return pulumi.get(self, "cost")

    @_builtins.property
    @pulumi.getter(name="isPassiveEnabled")
    def is_passive_enabled(self) -> _builtins.bool:
        """
        Disable sending Hello packets on this interface's IPv6 area
        """
        return pulumi.get(self, "is_passive_enabled")


@pulumi.output_type
class GetSwitchRoutingStaticRoutesItemResult(dict):
    def __init__(__self__, *,
                 advertise_via_ospf_enabled: _builtins.bool,
                 name: _builtins.str,
                 next_hop_ip: _builtins.str,
                 prefer_over_ospf_routes_enabled: _builtins.bool,
                 static_route_id: _builtins.str,
                 subnet: _builtins.str):
        """
        :param _builtins.bool advertise_via_ospf_enabled: Option to advertise static routes via OSPF
        :param _builtins.str name: The name or description of the layer 3 static route
        :param _builtins.str next_hop_ip: The IP address of the router to which traffic for this destination network should be sent
        :param _builtins.bool prefer_over_ospf_routes_enabled: Option to prefer static routes over OSPF routes
        :param _builtins.str static_route_id: The identifier of a layer 3 static route
        :param _builtins.str subnet: The IP address of the subnetwork specified in CIDR notation (ex. 1.2.3.0/24)
        """
        pulumi.set(__self__, "advertise_via_ospf_enabled", advertise_via_ospf_enabled)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "next_hop_ip", next_hop_ip)
        pulumi.set(__self__, "prefer_over_ospf_routes_enabled", prefer_over_ospf_routes_enabled)
        pulumi.set(__self__, "static_route_id", static_route_id)
        pulumi.set(__self__, "subnet", subnet)

    @_builtins.property
    @pulumi.getter(name="advertiseViaOspfEnabled")
    def advertise_via_ospf_enabled(self) -> _builtins.bool:
        """
        Option to advertise static routes via OSPF
        """
        return pulumi.get(self, "advertise_via_ospf_enabled")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        The name or description of the layer 3 static route
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="nextHopIp")
    def next_hop_ip(self) -> _builtins.str:
        """
        The IP address of the router to which traffic for this destination network should be sent
        """
        return pulumi.get(self, "next_hop_ip")

    @_builtins.property
    @pulumi.getter(name="preferOverOspfRoutesEnabled")
    def prefer_over_ospf_routes_enabled(self) -> _builtins.bool:
        """
        Option to prefer static routes over OSPF routes
        """
        return pulumi.get(self, "prefer_over_ospf_routes_enabled")

    @_builtins.property
    @pulumi.getter(name="staticRouteId")
    def static_route_id(self) -> _builtins.str:
        """
        The identifier of a layer 3 static route
        """
        return pulumi.get(self, "static_route_id")

    @_builtins.property
    @pulumi.getter
    def subnet(self) -> _builtins.str:
        """
        The IP address of the subnetwork specified in CIDR notation (ex. 1.2.3.0/24)
        """
        return pulumi.get(self, "subnet")


@pulumi.output_type
class GetSwitchWarmSpareItemResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 primary_serial: _builtins.str,
                 spare_serial: _builtins.str):
        """
        :param _builtins.bool enabled: Enable or disable warm spare for a switch
        :param _builtins.str primary_serial: Serial number of the primary switch
        :param _builtins.str spare_serial: Serial number of the warm spare switch
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "primary_serial", primary_serial)
        pulumi.set(__self__, "spare_serial", spare_serial)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Enable or disable warm spare for a switch
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter(name="primarySerial")
    def primary_serial(self) -> _builtins.str:
        """
        Serial number of the primary switch
        """
        return pulumi.get(self, "primary_serial")

    @_builtins.property
    @pulumi.getter(name="spareSerial")
    def spare_serial(self) -> _builtins.str:
        """
        Serial number of the warm spare switch
        """
        return pulumi.get(self, "spare_serial")


@pulumi.output_type
class GetWirelessBluetoothSettingsItemResult(dict):
    def __init__(__self__, *,
                 major: _builtins.int,
                 minor: _builtins.int,
                 uuid: _builtins.str):
        """
        :param _builtins.int major: Desired major value of the beacon. If the value is set to null it will reset to Dashboard's automatically generated value.
        :param _builtins.int minor: Desired minor value of the beacon. If the value is set to null it will reset to Dashboard's automatically generated value.
        :param _builtins.str uuid: Desired UUID of the beacon. If the value is set to null it will reset to Dashboard's automatically generated value.
        """
        pulumi.set(__self__, "major", major)
        pulumi.set(__self__, "minor", minor)
        pulumi.set(__self__, "uuid", uuid)

    @_builtins.property
    @pulumi.getter
    def major(self) -> _builtins.int:
        """
        Desired major value of the beacon. If the value is set to null it will reset to Dashboard's automatically generated value.
        """
        return pulumi.get(self, "major")

    @_builtins.property
    @pulumi.getter
    def minor(self) -> _builtins.int:
        """
        Desired minor value of the beacon. If the value is set to null it will reset to Dashboard's automatically generated value.
        """
        return pulumi.get(self, "minor")

    @_builtins.property
    @pulumi.getter
    def uuid(self) -> _builtins.str:
        """
        Desired UUID of the beacon. If the value is set to null it will reset to Dashboard's automatically generated value.
        """
        return pulumi.get(self, "uuid")


@pulumi.output_type
class GetWirelessConnectionStatsItemResult(dict):
    def __init__(__self__, *,
                 connection_stats: 'outputs.GetWirelessConnectionStatsItemConnectionStatsResult',
                 serial: _builtins.str):
        """
        :param 'GetWirelessConnectionStatsItemConnectionStatsArgs' connection_stats: The connection stats of the device
        :param _builtins.str serial: The serial number for the device
        """
        pulumi.set(__self__, "connection_stats", connection_stats)
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter(name="connectionStats")
    def connection_stats(self) -> 'outputs.GetWirelessConnectionStatsItemConnectionStatsResult':
        """
        The connection stats of the device
        """
        return pulumi.get(self, "connection_stats")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        The serial number for the device
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class GetWirelessConnectionStatsItemConnectionStatsResult(dict):
    def __init__(__self__, *,
                 assoc: _builtins.int,
                 auth: _builtins.int,
                 dhcp: _builtins.int,
                 dns: _builtins.int,
                 success: _builtins.int):
        """
        :param _builtins.int assoc: The number of failed association attempts
        :param _builtins.int auth: The number of failed authentication attempts
        :param _builtins.int dhcp: The number of failed DHCP attempts
        :param _builtins.int dns: The number of failed DNS attempts
        :param _builtins.int success: The number of successful connection attempts
        """
        pulumi.set(__self__, "assoc", assoc)
        pulumi.set(__self__, "auth", auth)
        pulumi.set(__self__, "dhcp", dhcp)
        pulumi.set(__self__, "dns", dns)
        pulumi.set(__self__, "success", success)

    @_builtins.property
    @pulumi.getter
    def assoc(self) -> _builtins.int:
        """
        The number of failed association attempts
        """
        return pulumi.get(self, "assoc")

    @_builtins.property
    @pulumi.getter
    def auth(self) -> _builtins.int:
        """
        The number of failed authentication attempts
        """
        return pulumi.get(self, "auth")

    @_builtins.property
    @pulumi.getter
    def dhcp(self) -> _builtins.int:
        """
        The number of failed DHCP attempts
        """
        return pulumi.get(self, "dhcp")

    @_builtins.property
    @pulumi.getter
    def dns(self) -> _builtins.int:
        """
        The number of failed DNS attempts
        """
        return pulumi.get(self, "dns")

    @_builtins.property
    @pulumi.getter
    def success(self) -> _builtins.int:
        """
        The number of successful connection attempts
        """
        return pulumi.get(self, "success")


@pulumi.output_type
class GetWirelessLatencyStatsItemResult(dict):
    def __init__(__self__, *,
                 latency_stats: 'outputs.GetWirelessLatencyStatsItemLatencyStatsResult',
                 serial: _builtins.str):
        pulumi.set(__self__, "latency_stats", latency_stats)
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter(name="latencyStats")
    def latency_stats(self) -> 'outputs.GetWirelessLatencyStatsItemLatencyStatsResult':
        return pulumi.get(self, "latency_stats")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        return pulumi.get(self, "serial")


@pulumi.output_type
class GetWirelessLatencyStatsItemLatencyStatsResult(dict):
    def __init__(__self__, *,
                 background_traffic: 'outputs.GetWirelessLatencyStatsItemLatencyStatsBackgroundTrafficResult',
                 best_effort_traffic: _builtins.str,
                 video_traffic: _builtins.str,
                 voice_traffic: _builtins.str):
        pulumi.set(__self__, "background_traffic", background_traffic)
        pulumi.set(__self__, "best_effort_traffic", best_effort_traffic)
        pulumi.set(__self__, "video_traffic", video_traffic)
        pulumi.set(__self__, "voice_traffic", voice_traffic)

    @_builtins.property
    @pulumi.getter(name="backgroundTraffic")
    def background_traffic(self) -> 'outputs.GetWirelessLatencyStatsItemLatencyStatsBackgroundTrafficResult':
        return pulumi.get(self, "background_traffic")

    @_builtins.property
    @pulumi.getter(name="bestEffortTraffic")
    def best_effort_traffic(self) -> _builtins.str:
        return pulumi.get(self, "best_effort_traffic")

    @_builtins.property
    @pulumi.getter(name="videoTraffic")
    def video_traffic(self) -> _builtins.str:
        return pulumi.get(self, "video_traffic")

    @_builtins.property
    @pulumi.getter(name="voiceTraffic")
    def voice_traffic(self) -> _builtins.str:
        return pulumi.get(self, "voice_traffic")


@pulumi.output_type
class GetWirelessLatencyStatsItemLatencyStatsBackgroundTrafficResult(dict):
    def __init__(__self__, *,
                 avg: _builtins.float,
                 raw_distribution: 'outputs.GetWirelessLatencyStatsItemLatencyStatsBackgroundTrafficRawDistributionResult'):
        pulumi.set(__self__, "avg", avg)
        pulumi.set(__self__, "raw_distribution", raw_distribution)

    @_builtins.property
    @pulumi.getter
    def avg(self) -> _builtins.float:
        return pulumi.get(self, "avg")

    @_builtins.property
    @pulumi.getter(name="rawDistribution")
    def raw_distribution(self) -> 'outputs.GetWirelessLatencyStatsItemLatencyStatsBackgroundTrafficRawDistributionResult':
        return pulumi.get(self, "raw_distribution")


@pulumi.output_type
class GetWirelessLatencyStatsItemLatencyStatsBackgroundTrafficRawDistributionResult(dict):
    def __init__(__self__, *,
                 status0: _builtins.int,
                 status1: _builtins.int,
                 status1024: _builtins.int,
                 status128: _builtins.int,
                 status16: _builtins.int,
                 status2: _builtins.int,
                 status2048: _builtins.int,
                 status256: _builtins.int,
                 status32: _builtins.int,
                 status4: _builtins.int,
                 status512: _builtins.int,
                 status64: _builtins.int,
                 status8: _builtins.int):
        pulumi.set(__self__, "status0", status0)
        pulumi.set(__self__, "status1", status1)
        pulumi.set(__self__, "status1024", status1024)
        pulumi.set(__self__, "status128", status128)
        pulumi.set(__self__, "status16", status16)
        pulumi.set(__self__, "status2", status2)
        pulumi.set(__self__, "status2048", status2048)
        pulumi.set(__self__, "status256", status256)
        pulumi.set(__self__, "status32", status32)
        pulumi.set(__self__, "status4", status4)
        pulumi.set(__self__, "status512", status512)
        pulumi.set(__self__, "status64", status64)
        pulumi.set(__self__, "status8", status8)

    @_builtins.property
    @pulumi.getter
    def status0(self) -> _builtins.int:
        return pulumi.get(self, "status0")

    @_builtins.property
    @pulumi.getter
    def status1(self) -> _builtins.int:
        return pulumi.get(self, "status1")

    @_builtins.property
    @pulumi.getter
    def status1024(self) -> _builtins.int:
        return pulumi.get(self, "status1024")

    @_builtins.property
    @pulumi.getter
    def status128(self) -> _builtins.int:
        return pulumi.get(self, "status128")

    @_builtins.property
    @pulumi.getter
    def status16(self) -> _builtins.int:
        return pulumi.get(self, "status16")

    @_builtins.property
    @pulumi.getter
    def status2(self) -> _builtins.int:
        return pulumi.get(self, "status2")

    @_builtins.property
    @pulumi.getter
    def status2048(self) -> _builtins.int:
        return pulumi.get(self, "status2048")

    @_builtins.property
    @pulumi.getter
    def status256(self) -> _builtins.int:
        return pulumi.get(self, "status256")

    @_builtins.property
    @pulumi.getter
    def status32(self) -> _builtins.int:
        return pulumi.get(self, "status32")

    @_builtins.property
    @pulumi.getter
    def status4(self) -> _builtins.int:
        return pulumi.get(self, "status4")

    @_builtins.property
    @pulumi.getter
    def status512(self) -> _builtins.int:
        return pulumi.get(self, "status512")

    @_builtins.property
    @pulumi.getter
    def status64(self) -> _builtins.int:
        return pulumi.get(self, "status64")

    @_builtins.property
    @pulumi.getter
    def status8(self) -> _builtins.int:
        return pulumi.get(self, "status8")


@pulumi.output_type
class GetWirelessRadioSettingsItemResult(dict):
    def __init__(__self__, *,
                 five_ghz_settings: 'outputs.GetWirelessRadioSettingsItemFiveGhzSettingsResult',
                 rf_profile_id: _builtins.str,
                 serial: _builtins.str,
                 two_four_ghz_settings: 'outputs.GetWirelessRadioSettingsItemTwoFourGhzSettingsResult'):
        pulumi.set(__self__, "five_ghz_settings", five_ghz_settings)
        pulumi.set(__self__, "rf_profile_id", rf_profile_id)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "two_four_ghz_settings", two_four_ghz_settings)

    @_builtins.property
    @pulumi.getter(name="fiveGhzSettings")
    def five_ghz_settings(self) -> 'outputs.GetWirelessRadioSettingsItemFiveGhzSettingsResult':
        return pulumi.get(self, "five_ghz_settings")

    @_builtins.property
    @pulumi.getter(name="rfProfileId")
    def rf_profile_id(self) -> _builtins.str:
        return pulumi.get(self, "rf_profile_id")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        return pulumi.get(self, "serial")

    @_builtins.property
    @pulumi.getter(name="twoFourGhzSettings")
    def two_four_ghz_settings(self) -> 'outputs.GetWirelessRadioSettingsItemTwoFourGhzSettingsResult':
        return pulumi.get(self, "two_four_ghz_settings")


@pulumi.output_type
class GetWirelessRadioSettingsItemFiveGhzSettingsResult(dict):
    def __init__(__self__, *,
                 channel: _builtins.int,
                 channel_width: _builtins.str,
                 target_power: _builtins.int):
        pulumi.set(__self__, "channel", channel)
        pulumi.set(__self__, "channel_width", channel_width)
        pulumi.set(__self__, "target_power", target_power)

    @_builtins.property
    @pulumi.getter
    def channel(self) -> _builtins.int:
        return pulumi.get(self, "channel")

    @_builtins.property
    @pulumi.getter(name="channelWidth")
    def channel_width(self) -> _builtins.str:
        return pulumi.get(self, "channel_width")

    @_builtins.property
    @pulumi.getter(name="targetPower")
    def target_power(self) -> _builtins.int:
        return pulumi.get(self, "target_power")


@pulumi.output_type
class GetWirelessRadioSettingsItemTwoFourGhzSettingsResult(dict):
    def __init__(__self__, *,
                 channel: _builtins.int,
                 target_power: _builtins.int):
        pulumi.set(__self__, "channel", channel)
        pulumi.set(__self__, "target_power", target_power)

    @_builtins.property
    @pulumi.getter
    def channel(self) -> _builtins.int:
        return pulumi.get(self, "channel")

    @_builtins.property
    @pulumi.getter(name="targetPower")
    def target_power(self) -> _builtins.int:
        return pulumi.get(self, "target_power")


@pulumi.output_type
class GetWirelessStatusItemResult(dict):
    def __init__(__self__, *,
                 basic_service_sets: Sequence['outputs.GetWirelessStatusItemBasicServiceSetResult']):
        """
        :param Sequence['GetWirelessStatusItemBasicServiceSetArgs'] basic_service_sets: SSID status list
        """
        pulumi.set(__self__, "basic_service_sets", basic_service_sets)

    @_builtins.property
    @pulumi.getter(name="basicServiceSets")
    def basic_service_sets(self) -> Sequence['outputs.GetWirelessStatusItemBasicServiceSetResult']:
        """
        SSID status list
        """
        return pulumi.get(self, "basic_service_sets")


@pulumi.output_type
class GetWirelessStatusItemBasicServiceSetResult(dict):
    def __init__(__self__, *,
                 band: _builtins.str,
                 broadcasting: _builtins.bool,
                 bssid: _builtins.str,
                 channel: _builtins.int,
                 channel_width: _builtins.str,
                 enabled: _builtins.bool,
                 power: _builtins.str,
                 ssid_name: _builtins.str,
                 ssid_number: _builtins.int,
                 visible: _builtins.bool):
        """
        :param _builtins.str band: Frequency range used by wireless network
        :param _builtins.bool broadcasting: Whether the SSID is broadcasting based on an availability schedule
        :param _builtins.str bssid: Unique identifier of wireless access point
        :param _builtins.int channel: Frequency channel used by wireless network
        :param _builtins.str channel_width: Width of frequency channel used by wireless network
        :param _builtins.bool enabled: Status of wireless network
        :param _builtins.str power: Strength of wireless signal
        :param _builtins.str ssid_name: Name of wireless network
        :param _builtins.int ssid_number: Unique identifier of wireless network
        :param _builtins.bool visible: Whether the SSID is advertised or hidden
        """
        pulumi.set(__self__, "band", band)
        pulumi.set(__self__, "broadcasting", broadcasting)
        pulumi.set(__self__, "bssid", bssid)
        pulumi.set(__self__, "channel", channel)
        pulumi.set(__self__, "channel_width", channel_width)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "power", power)
        pulumi.set(__self__, "ssid_name", ssid_name)
        pulumi.set(__self__, "ssid_number", ssid_number)
        pulumi.set(__self__, "visible", visible)

    @_builtins.property
    @pulumi.getter
    def band(self) -> _builtins.str:
        """
        Frequency range used by wireless network
        """
        return pulumi.get(self, "band")

    @_builtins.property
    @pulumi.getter
    def broadcasting(self) -> _builtins.bool:
        """
        Whether the SSID is broadcasting based on an availability schedule
        """
        return pulumi.get(self, "broadcasting")

    @_builtins.property
    @pulumi.getter
    def bssid(self) -> _builtins.str:
        """
        Unique identifier of wireless access point
        """
        return pulumi.get(self, "bssid")

    @_builtins.property
    @pulumi.getter
    def channel(self) -> _builtins.int:
        """
        Frequency channel used by wireless network
        """
        return pulumi.get(self, "channel")

    @_builtins.property
    @pulumi.getter(name="channelWidth")
    def channel_width(self) -> _builtins.str:
        """
        Width of frequency channel used by wireless network
        """
        return pulumi.get(self, "channel_width")

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Status of wireless network
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def power(self) -> _builtins.str:
        """
        Strength of wireless signal
        """
        return pulumi.get(self, "power")

    @_builtins.property
    @pulumi.getter(name="ssidName")
    def ssid_name(self) -> _builtins.str:
        """
        Name of wireless network
        """
        return pulumi.get(self, "ssid_name")

    @_builtins.property
    @pulumi.getter(name="ssidNumber")
    def ssid_number(self) -> _builtins.int:
        """
        Unique identifier of wireless network
        """
        return pulumi.get(self, "ssid_number")

    @_builtins.property
    @pulumi.getter
    def visible(self) -> _builtins.bool:
        """
        Whether the SSID is advertised or hidden
        """
        return pulumi.get(self, "visible")


