# 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__ = [
    'ActionBatchesAction',
    'ActionBatchesCallback',
    'ActionBatchesCallbackHttpServer',
    'ActionBatchesCallbackPayloadTemplate',
    'ActionBatchesStatus',
    'ActionBatchesStatusCreatedResource',
    'AdaptivePolicyAclsRule',
    'AdaptivePolicyGroupsPolicyObject',
    'AdaptivePolicyPoliciesAcl',
    'AdaptivePolicyPoliciesDestinationGroup',
    'AdaptivePolicyPoliciesSourceGroup',
    'AdminsNetwork',
    'AdminsTag',
    'AlertsProfilesAlertCondition',
    'AlertsProfilesRecipients',
    'ApplianceSecurityIntrusionAllowedRule',
    'ApplianceVpnThirdPartyVpnpeersPeer',
    'ApplianceVpnThirdPartyVpnpeersPeerIpsecPolicies',
    'ApplianceVpnThirdPartyVpnpeersPeersResponse',
    'ApplianceVpnThirdPartyVpnpeersPeersResponseIpsecPolicies',
    'ApplianceVpnVpnFirewallRulesRule',
    'BrandingPoliciesAdminSettings',
    'BrandingPoliciesCustomLogo',
    'BrandingPoliciesCustomLogoImage',
    'BrandingPoliciesCustomLogoImagePreview',
    'BrandingPoliciesHelpSettings',
    'CameraCustomAnalyticsArtifactsStatus',
    'CameraRolesAppliedOnDevice',
    'CameraRolesAppliedOnNetwork',
    'CameraRolesAppliedOrgWide',
    'ClaimItem',
    'ClaimItemLicense',
    'ClaimParameters',
    'ClaimParametersLicense',
    'CloneItem',
    'CloneItemApi',
    'CloneItemCloud',
    'CloneItemCloudRegion',
    'CloneItemLicensing',
    'CloneItemManagement',
    'CloneItemManagementDetail',
    'CloneParameters',
    'ConfigTemplatesSwitchProfilesPortsMirror',
    'ConfigTemplatesSwitchProfilesPortsModule',
    'ConfigTemplatesSwitchProfilesPortsProfile',
    'InventoryClaimItem',
    'InventoryClaimItemLicense',
    'InventoryClaimParameters',
    'InventoryClaimParametersLicense',
    'InventoryOnboardingCloudMonitoringExportEventsParameters',
    'InventoryOnboardingCloudMonitoringImportsParameters',
    'InventoryOnboardingCloudMonitoringImportsParametersDevice',
    'InventoryOnboardingCloudMonitoringImportsParametersItem',
    'InventoryOnboardingCloudMonitoringImportsParametersItemItem',
    'InventoryOnboardingCloudMonitoringPrepareItem',
    'InventoryOnboardingCloudMonitoringPrepareItemConfigParams',
    'InventoryOnboardingCloudMonitoringPrepareItemConfigParamsTunnel',
    'InventoryOnboardingCloudMonitoringPrepareItemConfigParamsTunnelRootCertificate',
    'InventoryOnboardingCloudMonitoringPrepareItemConfigParamsUser',
    'InventoryOnboardingCloudMonitoringPrepareItemConfigParamsUserSecret',
    'InventoryOnboardingCloudMonitoringPrepareParameters',
    'InventoryOnboardingCloudMonitoringPrepareParametersDevice',
    'InventoryOnboardingCloudMonitoringPrepareParametersDeviceTunnel',
    'InventoryOnboardingCloudMonitoringPrepareParametersDeviceUser',
    'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVty',
    'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessList',
    'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessListVtyIn',
    'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessListVtyOut',
    'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthentication',
    'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthenticationGroup',
    'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthorization',
    'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthorizationGroup',
    'InventoryReleaseItem',
    'InventoryReleaseParameters',
    'LicensesAssignSeatsItem',
    'LicensesAssignSeatsItemResultingLicense',
    'LicensesAssignSeatsItemResultingLicensePermanentlyQueuedLicense',
    'LicensesAssignSeatsParameters',
    'LicensesMoveItem',
    'LicensesMoveParameters',
    'LicensesMoveSeatsItem',
    'LicensesMoveSeatsParameters',
    'LicensesPermanentlyQueuedLicense',
    'LicensesRenewSeatsItem',
    'LicensesRenewSeatsItemResultingLicense',
    'LicensesRenewSeatsItemResultingLicensePermanentlyQueuedLicense',
    'LicensesRenewSeatsParameters',
    'LicensingCotermLicensesMoveItem',
    'LicensingCotermLicensesMoveItemMovedLicense',
    'LicensingCotermLicensesMoveItemMovedLicenseCount',
    'LicensingCotermLicensesMoveItemMovedLicenseEdition',
    'LicensingCotermLicensesMoveItemRemainderLicense',
    'LicensingCotermLicensesMoveItemRemainderLicenseCount',
    'LicensingCotermLicensesMoveItemRemainderLicenseEdition',
    'LicensingCotermLicensesMoveParameters',
    'LicensingCotermLicensesMoveParametersDestination',
    'LicensingCotermLicensesMoveParametersLicense',
    'LicensingCotermLicensesMoveParametersLicenseCount',
    'LoginSecurityApiAuthentication',
    'LoginSecurityApiAuthenticationIpRestrictionsForKeys',
    'NetworksCombineItem',
    'NetworksCombineItemResultingNetwork',
    'NetworksCombineParameters',
    'SamlRolesCamera',
    'SamlRolesNetwork',
    'SamlRolesTag',
    'SmSentryPoliciesAssignmentsItem',
    'SmSentryPoliciesAssignmentsItemItem',
    'SmSentryPoliciesAssignmentsItemItemPolicy',
    'SmSentryPoliciesAssignmentsParameters',
    'SmSentryPoliciesAssignmentsParametersItem',
    'SmSentryPoliciesAssignmentsParametersItemPolicy',
    'SwitchDevicesCloneParameters',
    'BaseApi',
    'BaseCloud',
    'BaseCloudRegion',
    'BaseLicensing',
    'BaseManagement',
    'BaseManagementDetail',
    'GetActionBatchesItemResult',
    'GetActionBatchesItemActionResult',
    'GetActionBatchesItemStatusResult',
    'GetActionBatchesItemStatusCreatedResourceResult',
    'GetAdaptivePolicyAclsItemResult',
    'GetAdaptivePolicyAclsItemRuleResult',
    'GetAdaptivePolicyGroupsItemResult',
    'GetAdaptivePolicyGroupsItemPolicyObjectResult',
    'GetAdaptivePolicyOverviewItemResult',
    'GetAdaptivePolicyOverviewItemCountsResult',
    'GetAdaptivePolicyOverviewItemLimitsResult',
    'GetAdaptivePolicyPoliciesItemResult',
    'GetAdaptivePolicyPoliciesItemAclResult',
    'GetAdaptivePolicyPoliciesItemDestinationGroupResult',
    'GetAdaptivePolicyPoliciesItemSourceGroupResult',
    'GetAdaptivePolicySettingsItemResult',
    'GetAdminsItemResult',
    'GetAdminsItemNetworkResult',
    'GetAdminsItemTagResult',
    'GetAlertsProfilesItemResult',
    'GetAlertsProfilesItemAlertConditionResult',
    'GetAlertsProfilesItemRecipientsResult',
    'GetApiRequestsItemResult',
    'GetApiRequestsOverviewItemResult',
    'GetApiRequestsOverviewItemResponseCodeCountsResult',
    'GetApiRequestsOverviewResponseCodesByIntervalItemResult',
    'GetApiRequestsOverviewResponseCodesByIntervalItemCountResult',
    'GetApplianceSecurityIntrusionItemResult',
    'GetApplianceSecurityIntrusionItemAllowedRuleResult',
    'GetApplianceTrafficShapingVpnExclusionsByNetworkItemResult',
    'GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemResult',
    'GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemCustomResult',
    'GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemMajorApplicationResult',
    'GetApplianceUplinksStatusesOverviewItemResult',
    'GetApplianceUplinksStatusesOverviewItemCountsResult',
    'GetApplianceUplinksStatusesOverviewItemCountsByStatusResult',
    'GetApplianceUplinksUsageByNetworkItemResult',
    'GetApplianceUplinksUsageByNetworkItemByUplinkResult',
    'GetApplianceVpnThirdPartyVpnpeersItemResult',
    'GetApplianceVpnThirdPartyVpnpeersItemPeerResult',
    'GetApplianceVpnThirdPartyVpnpeersItemPeerIpsecPoliciesResult',
    'GetApplianceVpnVpnFirewallRulesItemResult',
    'GetApplianceVpnVpnFirewallRulesItemRuleResult',
    'GetBrandingPoliciesItemResult',
    'GetBrandingPoliciesItemAdminSettingsResult',
    'GetBrandingPoliciesItemCustomLogoResult',
    'GetBrandingPoliciesItemCustomLogoImageResult',
    'GetBrandingPoliciesItemCustomLogoImagePreviewResult',
    'GetBrandingPoliciesItemHelpSettingsResult',
    'GetBrandingPoliciesPrioritiesItemResult',
    'GetCameraBoundariesAreasByDeviceItemResult',
    'GetCameraBoundariesAreasByDeviceItemBoundariesResult',
    'GetCameraBoundariesAreasByDeviceItemBoundariesVertexResult',
    'GetCameraBoundariesLinesByDeviceItemResult',
    'GetCameraBoundariesLinesByDeviceItemBoundariesResult',
    'GetCameraBoundariesLinesByDeviceItemBoundariesDirectionVertexResult',
    'GetCameraBoundariesLinesByDeviceItemBoundariesVertexResult',
    'GetCameraCustomAnalyticsArtifactsItemResult',
    'GetCameraCustomAnalyticsArtifactsItemStatusResult',
    'GetCameraDetectionsHistoryByBoundaryByIntervalItemResult',
    'GetCameraDetectionsHistoryByBoundaryByIntervalItemResultsResult',
    'GetCameraPermissionsItemResult',
    'GetCameraRolesItemResult',
    'GetCameraRolesItemAppliedOnDeviceResult',
    'GetCameraRolesItemAppliedOnNetworkResult',
    'GetCameraRolesItemAppliedOrgWideResult',
    'GetCellularGatewayUplinkStatusesItemResult',
    'GetCellularGatewayUplinkStatusesItemUplinkResult',
    'GetCellularGatewayUplinkStatusesItemUplinkSignalStatResult',
    'GetClientsBandwidthUsageHistoryItemResult',
    'GetClientsOverviewItemResult',
    'GetClientsOverviewItemCountsResult',
    'GetClientsOverviewItemUsageResult',
    'GetClientsOverviewItemUsageOverallResult',
    'GetClientsSearchItemResult',
    'GetClientsSearchItemRecordResult',
    'GetClientsSearchItemRecordClientVpnConnectionResult',
    'GetClientsSearchItemRecordNetworkResult',
    'GetConfigTemplatesItemResult',
    'GetConfigTemplatesSwitchProfilesItemResult',
    'GetConfigTemplatesSwitchProfilesPortsItemResult',
    'GetConfigTemplatesSwitchProfilesPortsItemMirrorResult',
    'GetConfigTemplatesSwitchProfilesPortsItemModuleResult',
    'GetConfigTemplatesSwitchProfilesPortsItemProfileResult',
    'GetDevicesAvailabilitiesChangeHistoryItemResult',
    'GetDevicesAvailabilitiesChangeHistoryItemDetailsResult',
    'GetDevicesAvailabilitiesChangeHistoryItemDetailsNewsResult',
    'GetDevicesAvailabilitiesChangeHistoryItemDetailsOldResult',
    'GetDevicesAvailabilitiesChangeHistoryItemDeviceResult',
    'GetDevicesAvailabilitiesChangeHistoryItemNetworkResult',
    'GetDevicesAvailabilitiesItemResult',
    'GetDevicesAvailabilitiesItemNetworkResult',
    'GetDevicesBootsHistoryItemResult',
    'GetDevicesBootsHistoryItemNetworkResult',
    'GetDevicesBootsHistoryItemStartResult',
    'GetDevicesItemResult',
    'GetDevicesItemDetailResult',
    'GetDevicesPowerModulesStatusesByDeviceItemResult',
    'GetDevicesPowerModulesStatusesByDeviceItemNetworkResult',
    'GetDevicesPowerModulesStatusesByDeviceItemSlotResult',
    'GetDevicesProvisioningStatusesItemResult',
    'GetDevicesProvisioningStatusesItemNetworkResult',
    'GetDevicesStatusesItemResult',
    'GetDevicesStatusesItemComponentsResult',
    'GetDevicesStatusesItemComponentsPowerSupplyResult',
    'GetDevicesStatusesItemComponentsPowerSupplyPoeResult',
    'GetDevicesStatusesOverviewItemResult',
    'GetDevicesStatusesOverviewItemCountsResult',
    'GetDevicesStatusesOverviewItemCountsByStatusResult',
    'GetDevicesUplinksAddressesByDeviceItemResult',
    'GetDevicesUplinksAddressesByDeviceItemNetworkResult',
    'GetDevicesUplinksAddressesByDeviceItemUplinkResult',
    'GetDevicesUplinksAddressesByDeviceItemUplinkAddressResult',
    'GetDevicesUplinksAddressesByDeviceItemUplinkAddressPublicResult',
    'GetDevicesUplinksLossAndLatencyItemResult',
    'GetDevicesUplinksLossAndLatencyItemTimeSeriesResult',
    'GetEarlyAccessFeaturesItemResult',
    'GetEarlyAccessFeaturesItemDescriptionsResult',
    'GetEarlyAccessFeaturesOptInsItemResult',
    'GetEarlyAccessFeaturesOptInsItemLimitScopeToNetworkResult',
    'GetFirmwareUpgradesByDeviceItemResult',
    'GetFirmwareUpgradesByDeviceItemUpgradeResult',
    'GetFirmwareUpgradesByDeviceItemUpgradeFromVersionResult',
    'GetFirmwareUpgradesByDeviceItemUpgradeStagedResult',
    'GetFirmwareUpgradesByDeviceItemUpgradeStagedGroupResult',
    'GetFirmwareUpgradesByDeviceItemUpgradeToVersionResult',
    'GetFirmwareUpgradesItemResult',
    'GetFirmwareUpgradesItemFromVersionResult',
    'GetFirmwareUpgradesItemNetworkResult',
    'GetFirmwareUpgradesItemToVersionResult',
    'GetInsightApplicationsItemResult',
    'GetInsightApplicationsItemThresholdsResult',
    'GetInsightApplicationsItemThresholdsByNetworkResult',
    'GetInsightMonitoredMediaServersItemResult',
    'GetInventoryDevicesItemResult',
    'GetInventoryDevicesItemDetailResult',
    'GetInventoryOnboardingCloudMonitoringImportsItemResult',
    'GetInventoryOnboardingCloudMonitoringImportsItemDeviceResult',
    'GetInventoryOnboardingCloudMonitoringNetworksItemResult',
    'GetLicensesItemResult',
    'GetLicensesItemPermanentlyQueuedLicenseResult',
    'GetLicensesOverviewItemResult',
    'GetLicensesOverviewItemLicenseTypeResult',
    'GetLicensesOverviewItemLicenseTypeCountsResult',
    'GetLicensesOverviewItemStatesResult',
    'GetLicensesOverviewItemStatesActiveResult',
    'GetLicensesOverviewItemStatesExpiredResult',
    'GetLicensesOverviewItemStatesExpiringResult',
    'GetLicensesOverviewItemStatesExpiringCriticalResult',
    'GetLicensesOverviewItemStatesExpiringWarningResult',
    'GetLicensesOverviewItemStatesRecentlyQueuedResult',
    'GetLicensesOverviewItemStatesUnusedResult',
    'GetLicensesOverviewItemStatesUnusedActiveResult',
    'GetLicensesOverviewItemStatesUnusedActiveOldestActivationResult',
    'GetLicensesOverviewItemStatesUnusedSoonestActivationResult',
    'GetLicensesOverviewItemSystemsManagerResult',
    'GetLicensesOverviewItemSystemsManagerCountsResult',
    'GetLicensingCotermLicensesItemResult',
    'GetLicensingCotermLicensesItemCountResult',
    'GetLicensingCotermLicensesItemEditionResult',
    'GetLoginSecurityItemResult',
    'GetLoginSecurityItemApiAuthenticationResult',
    'GetLoginSecurityItemApiAuthenticationIpRestrictionsForKeysResult',
    'GetOpenapiSpecItemResult',
    'GetOpenapiSpecItemInfoResult',
    'GetOpenapiSpecItemPathsResult',
    'GetOpenapiSpecItemPathsOrganizationsResult',
    'GetOpenapiSpecItemPathsOrganizationsGetResult',
    'GetOpenapiSpecItemPathsOrganizationsGetResponsesResult',
    'GetOpenapiSpecItemPathsOrganizationsGetResponsesStatus200Result',
    'GetOpenapiSpecItemPathsOrganizationsGetResponsesStatus200ExamplesResult',
    'GetOpenapiSpecItemPathsOrganizationsGetResponsesStatus200ExamplesApplicationJsonResult',
    'GetPolicyObjectsGroupsItemResult',
    'GetPolicyObjectsItemResult',
    'GetSamlIdpsItemResult',
    'GetSamlItemResult',
    'GetSamlRolesItemResult',
    'GetSamlRolesItemCameraResult',
    'GetSamlRolesItemNetworkResult',
    'GetSamlRolesItemTagResult',
    'GetSensorReadingsHistoryItemResult',
    'GetSensorReadingsHistoryItemApparentPowerResult',
    'GetSensorReadingsHistoryItemBatteryResult',
    'GetSensorReadingsHistoryItemButtonResult',
    'GetSensorReadingsHistoryItemCo2Result',
    'GetSensorReadingsHistoryItemCurrentResult',
    'GetSensorReadingsHistoryItemDoorResult',
    'GetSensorReadingsHistoryItemDownstreamPowerResult',
    'GetSensorReadingsHistoryItemFrequencyResult',
    'GetSensorReadingsHistoryItemHumidityResult',
    'GetSensorReadingsHistoryItemIndoorAirQualityResult',
    'GetSensorReadingsHistoryItemNetworkResult',
    'GetSensorReadingsHistoryItemNoiseResult',
    'GetSensorReadingsHistoryItemNoiseAmbientResult',
    'GetSensorReadingsHistoryItemPm25Result',
    'GetSensorReadingsHistoryItemPowerFactorResult',
    'GetSensorReadingsHistoryItemRealPowerResult',
    'GetSensorReadingsHistoryItemRemoteLockoutSwitchResult',
    'GetSensorReadingsHistoryItemTemperatureResult',
    'GetSensorReadingsHistoryItemTvocResult',
    'GetSensorReadingsHistoryItemVoltageResult',
    'GetSensorReadingsHistoryItemWaterResult',
    'GetSensorReadingsLatestItemResult',
    'GetSensorReadingsLatestItemNetworkResult',
    'GetSensorReadingsLatestItemReadingResult',
    'GetSensorReadingsLatestItemReadingApparentPowerResult',
    'GetSensorReadingsLatestItemReadingBatteryResult',
    'GetSensorReadingsLatestItemReadingButtonResult',
    'GetSensorReadingsLatestItemReadingCo2Result',
    'GetSensorReadingsLatestItemReadingCurrentResult',
    'GetSensorReadingsLatestItemReadingDoorResult',
    'GetSensorReadingsLatestItemReadingDownstreamPowerResult',
    'GetSensorReadingsLatestItemReadingFrequencyResult',
    'GetSensorReadingsLatestItemReadingHumidityResult',
    'GetSensorReadingsLatestItemReadingIndoorAirQualityResult',
    'GetSensorReadingsLatestItemReadingNoiseResult',
    'GetSensorReadingsLatestItemReadingNoiseAmbientResult',
    'GetSensorReadingsLatestItemReadingPm25Result',
    'GetSensorReadingsLatestItemReadingPowerFactorResult',
    'GetSensorReadingsLatestItemReadingRealPowerResult',
    'GetSensorReadingsLatestItemReadingRemoteLockoutSwitchResult',
    'GetSensorReadingsLatestItemReadingTemperatureResult',
    'GetSensorReadingsLatestItemReadingTvocResult',
    'GetSensorReadingsLatestItemReadingVoltageResult',
    'GetSensorReadingsLatestItemReadingWaterResult',
    'GetSmAdminsRolesItemResult',
    'GetSmApnsCertItemResult',
    'GetSmSentryPoliciesAssignmentsByNetworkItemResult',
    'GetSmSentryPoliciesAssignmentsByNetworkItemItemResult',
    'GetSmSentryPoliciesAssignmentsByNetworkItemItemPolicyResult',
    'GetSmSentryPoliciesAssignmentsByNetworkItemMetaResult',
    'GetSmSentryPoliciesAssignmentsByNetworkItemMetaCountsResult',
    'GetSmSentryPoliciesAssignmentsByNetworkItemMetaCountsItemsResult',
    'GetSmVppAccountsItemResult',
    'GetSmVppAccountsItemParsedTokenResult',
    'GetSnmpItemResult',
    'GetSummaryTopAppliancesByUtilizationItemResult',
    'GetSummaryTopAppliancesByUtilizationItemNetworkResult',
    'GetSummaryTopAppliancesByUtilizationItemUtilizationResult',
    'GetSummaryTopAppliancesByUtilizationItemUtilizationAverageResult',
    'GetSummaryTopClientsByUsageItemResult',
    'GetSummaryTopClientsByUsageItemNetworkResult',
    'GetSummaryTopClientsByUsageItemUsageResult',
    'GetSummaryTopClientsManufacturersByUsageItemResult',
    'GetSummaryTopClientsManufacturersByUsageItemClientsResult',
    'GetSummaryTopClientsManufacturersByUsageItemClientsCountsResult',
    'GetSummaryTopClientsManufacturersByUsageItemUsageResult',
    'GetSummaryTopDevicesByUsageItemResult',
    'GetSummaryTopDevicesByUsageItemClientsResult',
    'GetSummaryTopDevicesByUsageItemClientsCountsResult',
    'GetSummaryTopDevicesByUsageItemNetworkResult',
    'GetSummaryTopDevicesByUsageItemUsageResult',
    'GetSummaryTopDevicesModelsByUsageItemResult',
    'GetSummaryTopDevicesModelsByUsageItemUsageResult',
    'GetSummaryTopNetworksByStatusItemResult',
    'GetSummaryTopNetworksByStatusItemClientsResult',
    'GetSummaryTopNetworksByStatusItemClientsCountsResult',
    'GetSummaryTopNetworksByStatusItemClientsUsageResult',
    'GetSummaryTopNetworksByStatusItemDevicesResult',
    'GetSummaryTopNetworksByStatusItemDevicesByProductTypeResult',
    'GetSummaryTopNetworksByStatusItemStatusesResult',
    'GetSummaryTopNetworksByStatusItemStatusesByProductTypeResult',
    'GetSummaryTopNetworksByStatusItemStatusesByProductTypeCountsResult',
    'GetSummaryTopSsidsByUsageItemResult',
    'GetSummaryTopSsidsByUsageItemClientsResult',
    'GetSummaryTopSsidsByUsageItemClientsCountsResult',
    'GetSummaryTopSsidsByUsageItemUsageResult',
    'GetSummaryTopSwitchesByEnergyUsageItemResult',
    'GetSummaryTopSwitchesByEnergyUsageItemNetworkResult',
    'GetSummaryTopSwitchesByEnergyUsageItemUsageResult',
    'GetSwitchPortsBySwitchItemResult',
    'GetSwitchPortsBySwitchItemNetworkResult',
    'GetSwitchPortsBySwitchItemPortResult',
    'GetUplinksStatusesItemResult',
    'GetUplinksStatusesItemHighAvailabilityResult',
    'GetUplinksStatusesItemUplinkResult',
    'GetUplinksStatusesItemUplinkSignalStatResult',
    'GetWebhooksCallbacksStatusesItemResult',
    'GetWebhooksCallbacksStatusesItemCreatedByResult',
    'GetWebhooksCallbacksStatusesItemWebhookResult',
    'GetWebhooksCallbacksStatusesItemWebhookHttpServerResult',
    'GetWebhooksCallbacksStatusesItemWebhookPayloadTemplateResult',
    'GetWebhooksLogsItemResult',
    'GetWirelessDevicesChannelUtilizationByDeviceItemResult',
    'GetWirelessDevicesChannelUtilizationByDeviceItemByBandResult',
    'GetWirelessDevicesChannelUtilizationByDeviceItemByBandNonWifiResult',
    'GetWirelessDevicesChannelUtilizationByDeviceItemByBandTotalResult',
    'GetWirelessDevicesChannelUtilizationByDeviceItemByBandWifiResult',
    'GetWirelessDevicesChannelUtilizationByDeviceItemNetworkResult',
    'GetWirelessDevicesChannelUtilizationByNetworkItemResult',
    'GetWirelessDevicesChannelUtilizationByNetworkItemByBandResult',
    'GetWirelessDevicesChannelUtilizationByNetworkItemByBandNonWifiResult',
    'GetWirelessDevicesChannelUtilizationByNetworkItemByBandTotalResult',
    'GetWirelessDevicesChannelUtilizationByNetworkItemByBandWifiResult',
    'GetWirelessDevicesChannelUtilizationByNetworkItemNetworkResult',
    'GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemResult',
    'GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandResult',
    'GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandNonWifiResult',
    'GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandTotalResult',
    'GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandWifiResult',
    'GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemNetworkResult',
    'GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemResult',
    'GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandResult',
    'GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandNonWifiResult',
    'GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandTotalResult',
    'GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandWifiResult',
    'GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemNetworkResult',
    'GetWirelessDevicesEthernetStatusesItemResult',
    'GetWirelessDevicesEthernetStatusesItemAggregationResult',
    'GetWirelessDevicesEthernetStatusesItemNetworkResult',
    'GetWirelessDevicesEthernetStatusesItemPortResult',
    'GetWirelessDevicesEthernetStatusesItemPortLinkNegotiationResult',
    'GetWirelessDevicesEthernetStatusesItemPortPoeResult',
    'GetWirelessDevicesEthernetStatusesItemPowerResult',
    'GetWirelessDevicesEthernetStatusesItemPowerAcResult',
    'GetWirelessDevicesEthernetStatusesItemPowerPoeResult',
    'GetWirelessDevicesPacketLossByClientItemResult',
    'GetWirelessDevicesPacketLossByClientItemClientResult',
    'GetWirelessDevicesPacketLossByClientItemDownstreamResult',
    'GetWirelessDevicesPacketLossByClientItemNetworkResult',
    'GetWirelessDevicesPacketLossByClientItemUpstreamResult',
    'GetWirelessDevicesPacketLossByDeviceItemResult',
    'GetWirelessDevicesPacketLossByDeviceItemDeviceResult',
    'GetWirelessDevicesPacketLossByDeviceItemDownstreamResult',
    'GetWirelessDevicesPacketLossByDeviceItemNetworkResult',
    'GetWirelessDevicesPacketLossByDeviceItemUpstreamResult',
    'GetWirelessDevicesPacketLossByNetworkItemResult',
    'GetWirelessDevicesPacketLossByNetworkItemDownstreamResult',
    'GetWirelessDevicesPacketLossByNetworkItemNetworkResult',
    'GetWirelessDevicesPacketLossByNetworkItemUpstreamResult',
]

@pulumi.output_type
class ActionBatchesAction(dict):
    def __init__(__self__, *,
                 body: Optional[_builtins.str] = None,
                 operation: Optional[_builtins.str] = None,
                 resource: Optional[_builtins.str] = None):
        """
        :param _builtins.str body: Data provided in the body of the Action. Contents depend on the Action type
        :param _builtins.str operation: The operation to be used by this action
        :param _builtins.str resource: Unique identifier for the resource to be acted on
        """
        if body is not None:
            pulumi.set(__self__, "body", body)
        if operation is not None:
            pulumi.set(__self__, "operation", operation)
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

    @_builtins.property
    @pulumi.getter
    def body(self) -> Optional[_builtins.str]:
        """
        Data provided in the body of the Action. Contents depend on the Action type
        """
        return pulumi.get(self, "body")

    @_builtins.property
    @pulumi.getter
    def operation(self) -> Optional[_builtins.str]:
        """
        The operation to be used by this action
        """
        return pulumi.get(self, "operation")

    @_builtins.property
    @pulumi.getter
    def resource(self) -> Optional[_builtins.str]:
        """
        Unique identifier for the resource to be acted on
        """
        return pulumi.get(self, "resource")


@pulumi.output_type
class ActionBatchesCallback(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 ActionBatchesCallback. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 http_server: Optional['outputs.ActionBatchesCallbackHttpServer'] = None,
                 id: Optional[_builtins.str] = None,
                 payload_template: Optional['outputs.ActionBatchesCallbackPayloadTemplate'] = None,
                 shared_secret: Optional[_builtins.str] = None,
                 status: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param 'ActionBatchesCallbackHttpServerArgs' http_server: The webhook receiver used for the callback webhook.
        :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 'ActionBatchesCallbackPayloadTemplateArgs' 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 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 http_server is not None:
            pulumi.set(__self__, "http_server", http_server)
        if id is not None:
            pulumi.set(__self__, "id", id)
        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 status is not None:
            pulumi.set(__self__, "status", status)
        if url is not None:
            pulumi.set(__self__, "url", url)

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

    @_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(name="payloadTemplate")
    def payload_template(self) -> Optional['outputs.ActionBatchesCallbackPayloadTemplate']:
        """
        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 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 ActionBatchesCallbackHttpServer(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 ActionBatchesCallbackPayloadTemplate(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 ActionBatchesStatus(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "createdResources":
            suggest = "created_resources"

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

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

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

    def __init__(__self__, *,
                 completed: Optional[_builtins.bool] = None,
                 created_resources: Optional[Sequence['outputs.ActionBatchesStatusCreatedResource']] = None,
                 errors: Optional[Sequence[_builtins.str]] = None,
                 failed: Optional[_builtins.bool] = None):
        """
        :param _builtins.bool completed: Flag describing whether all actions in the action batch have completed
        :param Sequence['ActionBatchesStatusCreatedResourceArgs'] created_resources: Resources created as a result of this action batch
        :param Sequence[_builtins.str] errors: List of errors encountered when running actions in the action batch
        :param _builtins.bool failed: Flag describing whether any actions in the action batch failed
        """
        if completed is not None:
            pulumi.set(__self__, "completed", completed)
        if created_resources is not None:
            pulumi.set(__self__, "created_resources", created_resources)
        if errors is not None:
            pulumi.set(__self__, "errors", errors)
        if failed is not None:
            pulumi.set(__self__, "failed", failed)

    @_builtins.property
    @pulumi.getter
    def completed(self) -> Optional[_builtins.bool]:
        """
        Flag describing whether all actions in the action batch have completed
        """
        return pulumi.get(self, "completed")

    @_builtins.property
    @pulumi.getter(name="createdResources")
    def created_resources(self) -> Optional[Sequence['outputs.ActionBatchesStatusCreatedResource']]:
        """
        Resources created as a result of this action batch
        """
        return pulumi.get(self, "created_resources")

    @_builtins.property
    @pulumi.getter
    def errors(self) -> Optional[Sequence[_builtins.str]]:
        """
        List of errors encountered when running actions in the action batch
        """
        return pulumi.get(self, "errors")

    @_builtins.property
    @pulumi.getter
    def failed(self) -> Optional[_builtins.bool]:
        """
        Flag describing whether any actions in the action batch failed
        """
        return pulumi.get(self, "failed")


@pulumi.output_type
class ActionBatchesStatusCreatedResource(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None,
                 uri: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: ID of the created resource
        :param _builtins.str uri: URI, not including base, of the created resource
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if uri is not None:
            pulumi.set(__self__, "uri", uri)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        ID of the created resource
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def uri(self) -> Optional[_builtins.str]:
        """
        URI, not including base, of the created resource
        """
        return pulumi.get(self, "uri")


@pulumi.output_type
class AdaptivePolicyAclsRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dstPort":
            suggest = "dst_port"
        elif key == "srcPort":
            suggest = "src_port"

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

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

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

    def __init__(__self__, *,
                 dst_port: Optional[_builtins.str] = None,
                 policy: Optional[_builtins.str] = None,
                 protocol: Optional[_builtins.str] = None,
                 src_port: Optional[_builtins.str] = None):
        """
        :param _builtins.str dst_port: Destination port
        :param _builtins.str policy: 'allow' or 'deny' traffic specified by this rule
        :param _builtins.str protocol: The type of protocol
        :param _builtins.str src_port: Source port
        """
        if dst_port is not None:
            pulumi.set(__self__, "dst_port", dst_port)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if src_port is not None:
            pulumi.set(__self__, "src_port", src_port)

    @_builtins.property
    @pulumi.getter(name="dstPort")
    def dst_port(self) -> Optional[_builtins.str]:
        """
        Destination port
        """
        return pulumi.get(self, "dst_port")

    @_builtins.property
    @pulumi.getter
    def policy(self) -> Optional[_builtins.str]:
        """
        'allow' or 'deny' traffic specified by this rule
        """
        return pulumi.get(self, "policy")

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

    @_builtins.property
    @pulumi.getter(name="srcPort")
    def src_port(self) -> Optional[_builtins.str]:
        """
        Source port
        """
        return pulumi.get(self, "src_port")


@pulumi.output_type
class AdaptivePolicyGroupsPolicyObject(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The ID of the policy object
        :param _builtins.str name: The name of the policy object
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class AdaptivePolicyPoliciesAcl(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: The ID of the adaptive policy ACL
        :param _builtins.str name: The name of the adaptive policy ACL
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the adaptive policy ACL
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class AdaptivePolicyPoliciesDestinationGroup(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 sgt: Optional[_builtins.int] = None):
        """
        :param _builtins.str id: The ID of the destination adaptive policy group
        :param _builtins.str name: The name of the destination adaptive policy group
        :param _builtins.int sgt: The SGT of the destination adaptive policy group
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if sgt is not None:
            pulumi.set(__self__, "sgt", sgt)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the destination adaptive policy group
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        The name of the destination adaptive policy group
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter
    def sgt(self) -> Optional[_builtins.int]:
        """
        The SGT of the destination adaptive policy group
        """
        return pulumi.get(self, "sgt")


@pulumi.output_type
class AdaptivePolicyPoliciesSourceGroup(dict):
    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 sgt: Optional[_builtins.int] = None):
        """
        :param _builtins.str id: The ID of the source adaptive policy group
        :param _builtins.str name: The name of the source adaptive policy group
        :param _builtins.int sgt: The SGT of the source adaptive policy group
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if sgt is not None:
            pulumi.set(__self__, "sgt", sgt)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the source adaptive policy group
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        The name of the source adaptive policy group
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter
    def sgt(self) -> Optional[_builtins.int]:
        """
        The SGT of the source adaptive policy group
        """
        return pulumi.get(self, "sgt")


@pulumi.output_type
class AdminsNetwork(dict):
    def __init__(__self__, *,
                 access: Optional[_builtins.str] = None,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str access: Admin's level of access to the network
        :param _builtins.str id: Network ID
        """
        if access is not None:
            pulumi.set(__self__, "access", access)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def access(self) -> Optional[_builtins.str]:
        """
        Admin's level of access to the network
        """
        return pulumi.get(self, "access")

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


@pulumi.output_type
class AdminsTag(dict):
    def __init__(__self__, *,
                 access: Optional[_builtins.str] = None,
                 tag: Optional[_builtins.str] = None):
        """
        :param _builtins.str access: Access level for the tag
        :param _builtins.str tag: Tag value
        """
        if access is not None:
            pulumi.set(__self__, "access", access)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)

    @_builtins.property
    @pulumi.getter
    def access(self) -> Optional[_builtins.str]:
        """
        Access level for the tag
        """
        return pulumi.get(self, "access")

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


@pulumi.output_type
class AlertsProfilesAlertCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bitRateBps":
            suggest = "bit_rate_bps"
        elif key == "jitterMs":
            suggest = "jitter_ms"
        elif key == "latencyMs":
            suggest = "latency_ms"
        elif key == "lossRatio":
            suggest = "loss_ratio"

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

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

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

    def __init__(__self__, *,
                 bit_rate_bps: Optional[_builtins.int] = None,
                 duration: Optional[_builtins.int] = None,
                 interface: Optional[_builtins.str] = None,
                 jitter_ms: Optional[_builtins.int] = None,
                 latency_ms: Optional[_builtins.int] = None,
                 loss_ratio: Optional[_builtins.float] = None,
                 mos: Optional[_builtins.float] = None,
                 window: Optional[_builtins.int] = None):
        """
        :param _builtins.int bit_rate_bps: The threshold the metric must cross to be valid for alerting. Used only for WAN Utilization alerts.
        :param _builtins.int duration: The total duration in seconds that the threshold should be crossed before alerting
        :param _builtins.str interface: The uplink observed for the alert
        :param _builtins.int jitter_ms: The threshold the metric must cross to be valid for alerting. Used only for VoIP Jitter alerts.
        :param _builtins.int latency_ms: The threshold the metric must cross to be valid for alerting. Used only for WAN Latency alerts.
        :param _builtins.float loss_ratio: The threshold the metric must cross to be valid for alerting. Used only for Packet Loss alerts.
        :param _builtins.float mos: The threshold the metric must drop below to be valid for alerting. Used only for VoIP MOS alerts.
        :param _builtins.int window: The look back period in seconds for sensing the alert
        """
        if bit_rate_bps is not None:
            pulumi.set(__self__, "bit_rate_bps", bit_rate_bps)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if interface is not None:
            pulumi.set(__self__, "interface", interface)
        if jitter_ms is not None:
            pulumi.set(__self__, "jitter_ms", jitter_ms)
        if latency_ms is not None:
            pulumi.set(__self__, "latency_ms", latency_ms)
        if loss_ratio is not None:
            pulumi.set(__self__, "loss_ratio", loss_ratio)
        if mos is not None:
            pulumi.set(__self__, "mos", mos)
        if window is not None:
            pulumi.set(__self__, "window", window)

    @_builtins.property
    @pulumi.getter(name="bitRateBps")
    def bit_rate_bps(self) -> Optional[_builtins.int]:
        """
        The threshold the metric must cross to be valid for alerting. Used only for WAN Utilization alerts.
        """
        return pulumi.get(self, "bit_rate_bps")

    @_builtins.property
    @pulumi.getter
    def duration(self) -> Optional[_builtins.int]:
        """
        The total duration in seconds that the threshold should be crossed before alerting
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def interface(self) -> Optional[_builtins.str]:
        """
        The uplink observed for the alert
        """
        return pulumi.get(self, "interface")

    @_builtins.property
    @pulumi.getter(name="jitterMs")
    def jitter_ms(self) -> Optional[_builtins.int]:
        """
        The threshold the metric must cross to be valid for alerting. Used only for VoIP Jitter alerts.
        """
        return pulumi.get(self, "jitter_ms")

    @_builtins.property
    @pulumi.getter(name="latencyMs")
    def latency_ms(self) -> Optional[_builtins.int]:
        """
        The threshold the metric must cross to be valid for alerting. Used only for WAN Latency alerts.
        """
        return pulumi.get(self, "latency_ms")

    @_builtins.property
    @pulumi.getter(name="lossRatio")
    def loss_ratio(self) -> Optional[_builtins.float]:
        """
        The threshold the metric must cross to be valid for alerting. Used only for Packet Loss alerts.
        """
        return pulumi.get(self, "loss_ratio")

    @_builtins.property
    @pulumi.getter
    def mos(self) -> Optional[_builtins.float]:
        """
        The threshold the metric must drop below to be valid for alerting. Used only for VoIP MOS alerts.
        """
        return pulumi.get(self, "mos")

    @_builtins.property
    @pulumi.getter
    def window(self) -> Optional[_builtins.int]:
        """
        The look back period in seconds for sensing the alert
        """
        return pulumi.get(self, "window")


@pulumi.output_type
class AlertsProfilesRecipients(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpServerIds":
            suggest = "http_server_ids"

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

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

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

    def __init__(__self__, *,
                 emails: Optional[Sequence[_builtins.str]] = None,
                 http_server_ids: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] emails: A list of emails that will receive information about the alert
        :param Sequence[_builtins.str] http_server_ids: A list base64 encoded urls of webhook endpoints that will receive information about the alert
        """
        if emails is not None:
            pulumi.set(__self__, "emails", emails)
        if http_server_ids is not None:
            pulumi.set(__self__, "http_server_ids", http_server_ids)

    @_builtins.property
    @pulumi.getter
    def emails(self) -> Optional[Sequence[_builtins.str]]:
        """
        A list of emails that will receive information about the alert
        """
        return pulumi.get(self, "emails")

    @_builtins.property
    @pulumi.getter(name="httpServerIds")
    def http_server_ids(self) -> Optional[Sequence[_builtins.str]]:
        """
        A list base64 encoded urls of webhook endpoints that will receive information about the alert
        """
        return pulumi.get(self, "http_server_ids")


@pulumi.output_type
class ApplianceSecurityIntrusionAllowedRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ruleId":
            suggest = "rule_id"

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

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

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

    def __init__(__self__, *,
                 message: Optional[_builtins.str] = None,
                 rule_id: Optional[_builtins.str] = None):
        """
        :param _builtins.str message: Message is optional and is ignored on a PUT call. It is allowed in order for PUT to be compatible with GET
        :param _builtins.str rule_id: A rule identifier of the format meraki:intrusion/snort/GID/\\n\\n/SID/\\n\\n. gid and sid can be obtained from either https://www.snort.org/rule-docs or as ruleIds from the security events in /organization/[orgId]/securityEvents
        """
        if message is not None:
            pulumi.set(__self__, "message", message)
        if rule_id is not None:
            pulumi.set(__self__, "rule_id", rule_id)

    @_builtins.property
    @pulumi.getter
    def message(self) -> Optional[_builtins.str]:
        """
        Message is optional and is ignored on a PUT call. It is allowed in order for PUT to be compatible with GET
        """
        return pulumi.get(self, "message")

    @_builtins.property
    @pulumi.getter(name="ruleId")
    def rule_id(self) -> Optional[_builtins.str]:
        """
        A rule identifier of the format meraki:intrusion/snort/GID/\\n\\n/SID/\\n\\n. gid and sid can be obtained from either https://www.snort.org/rule-docs or as ruleIds from the security events in /organization/[orgId]/securityEvents
        """
        return pulumi.get(self, "rule_id")


@pulumi.output_type
class ApplianceVpnThirdPartyVpnpeersPeer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ikeVersion":
            suggest = "ike_version"
        elif key == "ipsecPolicies":
            suggest = "ipsec_policies"
        elif key == "ipsecPoliciesPreset":
            suggest = "ipsec_policies_preset"
        elif key == "localId":
            suggest = "local_id"
        elif key == "networkTags":
            suggest = "network_tags"
        elif key == "privateSubnets":
            suggest = "private_subnets"
        elif key == "publicIp":
            suggest = "public_ip"
        elif key == "remoteId":
            suggest = "remote_id"

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

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

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

    def __init__(__self__, *,
                 ike_version: Optional[_builtins.str] = None,
                 ipsec_policies: Optional['outputs.ApplianceVpnThirdPartyVpnpeersPeerIpsecPolicies'] = None,
                 ipsec_policies_preset: Optional[_builtins.str] = None,
                 local_id: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 network_tags: Optional[Sequence[_builtins.str]] = None,
                 private_subnets: Optional[Sequence[_builtins.str]] = None,
                 public_ip: Optional[_builtins.str] = None,
                 remote_id: Optional[_builtins.str] = None,
                 secret: Optional[_builtins.str] = None):
        """
        :param _builtins.str ike_version: [optional] The IKE version to be used for the IPsec VPN peer configuration. Defaults to '1' when omitted.
        :param 'ApplianceVpnThirdPartyVpnpeersPeerIpsecPoliciesArgs' ipsec_policies: Custom IPSec policies for the VPN peer. If not included and a preset has not been chosen, the default preset for IPSec policies will be used.
        :param _builtins.str ipsec_policies_preset: One of the following available presets: 'default', 'aws', 'azure'. If this is provided, the 'ipsecPolicies' parameter is ignored.
        :param _builtins.str local_id: [optional] The local ID is used to identify the MX to the peer. This will apply to all MXs this peer applies to.
        :param _builtins.str name: The name of the VPN peer
        :param Sequence[_builtins.str] network_tags: A list of network tags that will connect with this peer. Use ['all'] for all networks. Use ['none'] for no networks. If not included, the default is ['all'].
        :param Sequence[_builtins.str] private_subnets: The list of the private subnets of the VPN peer
        :param _builtins.str public_ip: [optional] The public IP of the VPN peer
        :param _builtins.str remote_id: [optional] The remote ID is used to identify the connecting VPN peer. This can either be a valid IPv4 Address, FQDN or User FQDN.
        :param _builtins.str secret: The shared secret with the VPN peer
        """
        if ike_version is not None:
            pulumi.set(__self__, "ike_version", ike_version)
        if ipsec_policies is not None:
            pulumi.set(__self__, "ipsec_policies", ipsec_policies)
        if ipsec_policies_preset is not None:
            pulumi.set(__self__, "ipsec_policies_preset", ipsec_policies_preset)
        if local_id is not None:
            pulumi.set(__self__, "local_id", local_id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network_tags is not None:
            pulumi.set(__self__, "network_tags", network_tags)
        if private_subnets is not None:
            pulumi.set(__self__, "private_subnets", private_subnets)
        if public_ip is not None:
            pulumi.set(__self__, "public_ip", public_ip)
        if remote_id is not None:
            pulumi.set(__self__, "remote_id", remote_id)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @_builtins.property
    @pulumi.getter(name="ikeVersion")
    def ike_version(self) -> Optional[_builtins.str]:
        """
        [optional] The IKE version to be used for the IPsec VPN peer configuration. Defaults to '1' when omitted.
        """
        return pulumi.get(self, "ike_version")

    @_builtins.property
    @pulumi.getter(name="ipsecPolicies")
    def ipsec_policies(self) -> Optional['outputs.ApplianceVpnThirdPartyVpnpeersPeerIpsecPolicies']:
        """
        Custom IPSec policies for the VPN peer. If not included and a preset has not been chosen, the default preset for IPSec policies will be used.
        """
        return pulumi.get(self, "ipsec_policies")

    @_builtins.property
    @pulumi.getter(name="ipsecPoliciesPreset")
    def ipsec_policies_preset(self) -> Optional[_builtins.str]:
        """
        One of the following available presets: 'default', 'aws', 'azure'. If this is provided, the 'ipsecPolicies' parameter is ignored.
        """
        return pulumi.get(self, "ipsec_policies_preset")

    @_builtins.property
    @pulumi.getter(name="localId")
    def local_id(self) -> Optional[_builtins.str]:
        """
        [optional] The local ID is used to identify the MX to the peer. This will apply to all MXs this peer applies to.
        """
        return pulumi.get(self, "local_id")

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

    @_builtins.property
    @pulumi.getter(name="networkTags")
    def network_tags(self) -> Optional[Sequence[_builtins.str]]:
        """
        A list of network tags that will connect with this peer. Use ['all'] for all networks. Use ['none'] for no networks. If not included, the default is ['all'].
        """
        return pulumi.get(self, "network_tags")

    @_builtins.property
    @pulumi.getter(name="privateSubnets")
    def private_subnets(self) -> Optional[Sequence[_builtins.str]]:
        """
        The list of the private subnets of the VPN peer
        """
        return pulumi.get(self, "private_subnets")

    @_builtins.property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> Optional[_builtins.str]:
        """
        [optional] The public IP of the VPN peer
        """
        return pulumi.get(self, "public_ip")

    @_builtins.property
    @pulumi.getter(name="remoteId")
    def remote_id(self) -> Optional[_builtins.str]:
        """
        [optional] The remote ID is used to identify the connecting VPN peer. This can either be a valid IPv4 Address, FQDN or User FQDN.
        """
        return pulumi.get(self, "remote_id")

    @_builtins.property
    @pulumi.getter
    def secret(self) -> Optional[_builtins.str]:
        """
        The shared secret with the VPN peer
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class ApplianceVpnThirdPartyVpnpeersPeerIpsecPolicies(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "childAuthAlgos":
            suggest = "child_auth_algos"
        elif key == "childCipherAlgos":
            suggest = "child_cipher_algos"
        elif key == "childLifetime":
            suggest = "child_lifetime"
        elif key == "childPfsGroups":
            suggest = "child_pfs_groups"
        elif key == "ikeAuthAlgos":
            suggest = "ike_auth_algos"
        elif key == "ikeCipherAlgos":
            suggest = "ike_cipher_algos"
        elif key == "ikeDiffieHellmanGroups":
            suggest = "ike_diffie_hellman_groups"
        elif key == "ikeLifetime":
            suggest = "ike_lifetime"
        elif key == "ikePrfAlgos":
            suggest = "ike_prf_algos"

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

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

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

    def __init__(__self__, *,
                 child_auth_algos: Optional[Sequence[_builtins.str]] = None,
                 child_cipher_algos: Optional[Sequence[_builtins.str]] = None,
                 child_lifetime: Optional[_builtins.int] = None,
                 child_pfs_groups: Optional[Sequence[_builtins.str]] = None,
                 ike_auth_algos: Optional[Sequence[_builtins.str]] = None,
                 ike_cipher_algos: Optional[Sequence[_builtins.str]] = None,
                 ike_diffie_hellman_groups: Optional[Sequence[_builtins.str]] = None,
                 ike_lifetime: Optional[_builtins.int] = None,
                 ike_prf_algos: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] child_auth_algos: This is the authentication algorithms to be used in Phase 2. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        :param Sequence[_builtins.str] child_cipher_algos: This is the cipher algorithms to be used in Phase 2. The value should be an array with one or more of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des', 'null'
        :param _builtins.int child_lifetime: The lifetime of the Phase 2 SA in seconds.
        :param Sequence[_builtins.str] child_pfs_groups: This is the Diffie-Hellman group to be used for Perfect Forward Secrecy in Phase 2. The value should be an array with one of the following values: 'disabled','group14', 'group5', 'group2', 'group1'
        :param Sequence[_builtins.str] ike_auth_algos: This is the authentication algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        :param Sequence[_builtins.str] ike_cipher_algos: This is the cipher algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des'
        :param Sequence[_builtins.str] ike_diffie_hellman_groups: This is the Diffie-Hellman group to be used in Phase 1. The value should be an array with one of the following algorithms: 'group14', 'group5', 'group2', 'group1'
        :param _builtins.int ike_lifetime: The lifetime of the Phase 1 SA in seconds.
        :param Sequence[_builtins.str] ike_prf_algos: [optional] This is the pseudo-random function to be used in IKE_SA. The value should be an array with one of the following algorithms: 'prfsha256', 'prfsha1', 'prfmd5', 'default'. The 'default' option can be used to default to the Authentication algorithm.
        """
        if child_auth_algos is not None:
            pulumi.set(__self__, "child_auth_algos", child_auth_algos)
        if child_cipher_algos is not None:
            pulumi.set(__self__, "child_cipher_algos", child_cipher_algos)
        if child_lifetime is not None:
            pulumi.set(__self__, "child_lifetime", child_lifetime)
        if child_pfs_groups is not None:
            pulumi.set(__self__, "child_pfs_groups", child_pfs_groups)
        if ike_auth_algos is not None:
            pulumi.set(__self__, "ike_auth_algos", ike_auth_algos)
        if ike_cipher_algos is not None:
            pulumi.set(__self__, "ike_cipher_algos", ike_cipher_algos)
        if ike_diffie_hellman_groups is not None:
            pulumi.set(__self__, "ike_diffie_hellman_groups", ike_diffie_hellman_groups)
        if ike_lifetime is not None:
            pulumi.set(__self__, "ike_lifetime", ike_lifetime)
        if ike_prf_algos is not None:
            pulumi.set(__self__, "ike_prf_algos", ike_prf_algos)

    @_builtins.property
    @pulumi.getter(name="childAuthAlgos")
    def child_auth_algos(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the authentication algorithms to be used in Phase 2. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        """
        return pulumi.get(self, "child_auth_algos")

    @_builtins.property
    @pulumi.getter(name="childCipherAlgos")
    def child_cipher_algos(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the cipher algorithms to be used in Phase 2. The value should be an array with one or more of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des', 'null'
        """
        return pulumi.get(self, "child_cipher_algos")

    @_builtins.property
    @pulumi.getter(name="childLifetime")
    def child_lifetime(self) -> Optional[_builtins.int]:
        """
        The lifetime of the Phase 2 SA in seconds.
        """
        return pulumi.get(self, "child_lifetime")

    @_builtins.property
    @pulumi.getter(name="childPfsGroups")
    def child_pfs_groups(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the Diffie-Hellman group to be used for Perfect Forward Secrecy in Phase 2. The value should be an array with one of the following values: 'disabled','group14', 'group5', 'group2', 'group1'
        """
        return pulumi.get(self, "child_pfs_groups")

    @_builtins.property
    @pulumi.getter(name="ikeAuthAlgos")
    def ike_auth_algos(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the authentication algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        """
        return pulumi.get(self, "ike_auth_algos")

    @_builtins.property
    @pulumi.getter(name="ikeCipherAlgos")
    def ike_cipher_algos(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the cipher algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des'
        """
        return pulumi.get(self, "ike_cipher_algos")

    @_builtins.property
    @pulumi.getter(name="ikeDiffieHellmanGroups")
    def ike_diffie_hellman_groups(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the Diffie-Hellman group to be used in Phase 1. The value should be an array with one of the following algorithms: 'group14', 'group5', 'group2', 'group1'
        """
        return pulumi.get(self, "ike_diffie_hellman_groups")

    @_builtins.property
    @pulumi.getter(name="ikeLifetime")
    def ike_lifetime(self) -> Optional[_builtins.int]:
        """
        The lifetime of the Phase 1 SA in seconds.
        """
        return pulumi.get(self, "ike_lifetime")

    @_builtins.property
    @pulumi.getter(name="ikePrfAlgos")
    def ike_prf_algos(self) -> Optional[Sequence[_builtins.str]]:
        """
        [optional] This is the pseudo-random function to be used in IKE_SA. The value should be an array with one of the following algorithms: 'prfsha256', 'prfsha1', 'prfmd5', 'default'. The 'default' option can be used to default to the Authentication algorithm.
        """
        return pulumi.get(self, "ike_prf_algos")


@pulumi.output_type
class ApplianceVpnThirdPartyVpnpeersPeersResponse(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ikeVersion":
            suggest = "ike_version"
        elif key == "ipsecPolicies":
            suggest = "ipsec_policies"
        elif key == "ipsecPoliciesPreset":
            suggest = "ipsec_policies_preset"
        elif key == "localId":
            suggest = "local_id"
        elif key == "networkTags":
            suggest = "network_tags"
        elif key == "privateSubnets":
            suggest = "private_subnets"
        elif key == "publicIp":
            suggest = "public_ip"
        elif key == "remoteId":
            suggest = "remote_id"

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

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

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

    def __init__(__self__, *,
                 ike_version: Optional[_builtins.str] = None,
                 ipsec_policies: Optional['outputs.ApplianceVpnThirdPartyVpnpeersPeersResponseIpsecPolicies'] = None,
                 ipsec_policies_preset: Optional[_builtins.str] = None,
                 local_id: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 network_tags: Optional[Sequence[_builtins.str]] = None,
                 private_subnets: Optional[Sequence[_builtins.str]] = None,
                 public_ip: Optional[_builtins.str] = None,
                 remote_id: Optional[_builtins.str] = None,
                 secret: Optional[_builtins.str] = None):
        """
        :param _builtins.str ike_version: [optional] The IKE version to be used for the IPsec VPN peer configuration. Defaults to '1' when omitted.
        :param 'ApplianceVpnThirdPartyVpnpeersPeersResponseIpsecPoliciesArgs' ipsec_policies: Custom IPSec policies for the VPN peer. If not included and a preset has not been chosen, the default preset for IPSec policies will be used.
        :param _builtins.str ipsec_policies_preset: One of the following available presets: 'default', 'aws', 'azure'. If this is provided, the 'ipsecPolicies' parameter is ignored.
        :param _builtins.str local_id: [optional] The local ID is used to identify the MX to the peer. This will apply to all MXs this peer applies to.
        :param _builtins.str name: The name of the VPN peer
        :param Sequence[_builtins.str] network_tags: A list of network tags that will connect with this peer. Use ['all'] for all networks. Use ['none'] for no networks. If not included, the default is ['all'].
        :param Sequence[_builtins.str] private_subnets: The list of the private subnets of the VPN peer
        :param _builtins.str public_ip: [optional] The public IP of the VPN peer
        :param _builtins.str remote_id: [optional] The remote ID is used to identify the connecting VPN peer. This can either be a valid IPv4 Address, FQDN or User FQDN.
        :param _builtins.str secret: The shared secret with the VPN peer
        """
        if ike_version is not None:
            pulumi.set(__self__, "ike_version", ike_version)
        if ipsec_policies is not None:
            pulumi.set(__self__, "ipsec_policies", ipsec_policies)
        if ipsec_policies_preset is not None:
            pulumi.set(__self__, "ipsec_policies_preset", ipsec_policies_preset)
        if local_id is not None:
            pulumi.set(__self__, "local_id", local_id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network_tags is not None:
            pulumi.set(__self__, "network_tags", network_tags)
        if private_subnets is not None:
            pulumi.set(__self__, "private_subnets", private_subnets)
        if public_ip is not None:
            pulumi.set(__self__, "public_ip", public_ip)
        if remote_id is not None:
            pulumi.set(__self__, "remote_id", remote_id)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @_builtins.property
    @pulumi.getter(name="ikeVersion")
    def ike_version(self) -> Optional[_builtins.str]:
        """
        [optional] The IKE version to be used for the IPsec VPN peer configuration. Defaults to '1' when omitted.
        """
        return pulumi.get(self, "ike_version")

    @_builtins.property
    @pulumi.getter(name="ipsecPolicies")
    def ipsec_policies(self) -> Optional['outputs.ApplianceVpnThirdPartyVpnpeersPeersResponseIpsecPolicies']:
        """
        Custom IPSec policies for the VPN peer. If not included and a preset has not been chosen, the default preset for IPSec policies will be used.
        """
        return pulumi.get(self, "ipsec_policies")

    @_builtins.property
    @pulumi.getter(name="ipsecPoliciesPreset")
    def ipsec_policies_preset(self) -> Optional[_builtins.str]:
        """
        One of the following available presets: 'default', 'aws', 'azure'. If this is provided, the 'ipsecPolicies' parameter is ignored.
        """
        return pulumi.get(self, "ipsec_policies_preset")

    @_builtins.property
    @pulumi.getter(name="localId")
    def local_id(self) -> Optional[_builtins.str]:
        """
        [optional] The local ID is used to identify the MX to the peer. This will apply to all MXs this peer applies to.
        """
        return pulumi.get(self, "local_id")

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

    @_builtins.property
    @pulumi.getter(name="networkTags")
    def network_tags(self) -> Optional[Sequence[_builtins.str]]:
        """
        A list of network tags that will connect with this peer. Use ['all'] for all networks. Use ['none'] for no networks. If not included, the default is ['all'].
        """
        return pulumi.get(self, "network_tags")

    @_builtins.property
    @pulumi.getter(name="privateSubnets")
    def private_subnets(self) -> Optional[Sequence[_builtins.str]]:
        """
        The list of the private subnets of the VPN peer
        """
        return pulumi.get(self, "private_subnets")

    @_builtins.property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> Optional[_builtins.str]:
        """
        [optional] The public IP of the VPN peer
        """
        return pulumi.get(self, "public_ip")

    @_builtins.property
    @pulumi.getter(name="remoteId")
    def remote_id(self) -> Optional[_builtins.str]:
        """
        [optional] The remote ID is used to identify the connecting VPN peer. This can either be a valid IPv4 Address, FQDN or User FQDN.
        """
        return pulumi.get(self, "remote_id")

    @_builtins.property
    @pulumi.getter
    def secret(self) -> Optional[_builtins.str]:
        """
        The shared secret with the VPN peer
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class ApplianceVpnThirdPartyVpnpeersPeersResponseIpsecPolicies(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "childAuthAlgos":
            suggest = "child_auth_algos"
        elif key == "childCipherAlgos":
            suggest = "child_cipher_algos"
        elif key == "childLifetime":
            suggest = "child_lifetime"
        elif key == "childPfsGroups":
            suggest = "child_pfs_groups"
        elif key == "ikeAuthAlgos":
            suggest = "ike_auth_algos"
        elif key == "ikeCipherAlgos":
            suggest = "ike_cipher_algos"
        elif key == "ikeDiffieHellmanGroups":
            suggest = "ike_diffie_hellman_groups"
        elif key == "ikeLifetime":
            suggest = "ike_lifetime"
        elif key == "ikePrfAlgos":
            suggest = "ike_prf_algos"

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

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

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

    def __init__(__self__, *,
                 child_auth_algos: Optional[Sequence[_builtins.str]] = None,
                 child_cipher_algos: Optional[Sequence[_builtins.str]] = None,
                 child_lifetime: Optional[_builtins.int] = None,
                 child_pfs_groups: Optional[Sequence[_builtins.str]] = None,
                 ike_auth_algos: Optional[Sequence[_builtins.str]] = None,
                 ike_cipher_algos: Optional[Sequence[_builtins.str]] = None,
                 ike_diffie_hellman_groups: Optional[Sequence[_builtins.str]] = None,
                 ike_lifetime: Optional[_builtins.int] = None,
                 ike_prf_algos: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] child_auth_algos: This is the authentication algorithms to be used in Phase 2. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        :param Sequence[_builtins.str] child_cipher_algos: This is the cipher algorithms to be used in Phase 2. The value should be an array with one or more of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des', 'null'
        :param _builtins.int child_lifetime: The lifetime of the Phase 2 SA in seconds.
        :param Sequence[_builtins.str] child_pfs_groups: This is the Diffie-Hellman group to be used for Perfect Forward Secrecy in Phase 2. The value should be an array with one of the following values: 'disabled','group14', 'group5', 'group2', 'group1'
        :param Sequence[_builtins.str] ike_auth_algos: This is the authentication algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        :param Sequence[_builtins.str] ike_cipher_algos: This is the cipher algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des'
        :param Sequence[_builtins.str] ike_diffie_hellman_groups: This is the Diffie-Hellman group to be used in Phase 1. The value should be an array with one of the following algorithms: 'group14', 'group5', 'group2', 'group1'
        :param _builtins.int ike_lifetime: The lifetime of the Phase 1 SA in seconds.
        :param Sequence[_builtins.str] ike_prf_algos: [optional] This is the pseudo-random function to be used in IKE_SA. The value should be an array with one of the following algorithms: 'prfsha256', 'prfsha1', 'prfmd5', 'default'. The 'default' option can be used to default to the Authentication algorithm.
        """
        if child_auth_algos is not None:
            pulumi.set(__self__, "child_auth_algos", child_auth_algos)
        if child_cipher_algos is not None:
            pulumi.set(__self__, "child_cipher_algos", child_cipher_algos)
        if child_lifetime is not None:
            pulumi.set(__self__, "child_lifetime", child_lifetime)
        if child_pfs_groups is not None:
            pulumi.set(__self__, "child_pfs_groups", child_pfs_groups)
        if ike_auth_algos is not None:
            pulumi.set(__self__, "ike_auth_algos", ike_auth_algos)
        if ike_cipher_algos is not None:
            pulumi.set(__self__, "ike_cipher_algos", ike_cipher_algos)
        if ike_diffie_hellman_groups is not None:
            pulumi.set(__self__, "ike_diffie_hellman_groups", ike_diffie_hellman_groups)
        if ike_lifetime is not None:
            pulumi.set(__self__, "ike_lifetime", ike_lifetime)
        if ike_prf_algos is not None:
            pulumi.set(__self__, "ike_prf_algos", ike_prf_algos)

    @_builtins.property
    @pulumi.getter(name="childAuthAlgos")
    def child_auth_algos(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the authentication algorithms to be used in Phase 2. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        """
        return pulumi.get(self, "child_auth_algos")

    @_builtins.property
    @pulumi.getter(name="childCipherAlgos")
    def child_cipher_algos(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the cipher algorithms to be used in Phase 2. The value should be an array with one or more of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des', 'null'
        """
        return pulumi.get(self, "child_cipher_algos")

    @_builtins.property
    @pulumi.getter(name="childLifetime")
    def child_lifetime(self) -> Optional[_builtins.int]:
        """
        The lifetime of the Phase 2 SA in seconds.
        """
        return pulumi.get(self, "child_lifetime")

    @_builtins.property
    @pulumi.getter(name="childPfsGroups")
    def child_pfs_groups(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the Diffie-Hellman group to be used for Perfect Forward Secrecy in Phase 2. The value should be an array with one of the following values: 'disabled','group14', 'group5', 'group2', 'group1'
        """
        return pulumi.get(self, "child_pfs_groups")

    @_builtins.property
    @pulumi.getter(name="ikeAuthAlgos")
    def ike_auth_algos(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the authentication algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        """
        return pulumi.get(self, "ike_auth_algos")

    @_builtins.property
    @pulumi.getter(name="ikeCipherAlgos")
    def ike_cipher_algos(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the cipher algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des'
        """
        return pulumi.get(self, "ike_cipher_algos")

    @_builtins.property
    @pulumi.getter(name="ikeDiffieHellmanGroups")
    def ike_diffie_hellman_groups(self) -> Optional[Sequence[_builtins.str]]:
        """
        This is the Diffie-Hellman group to be used in Phase 1. The value should be an array with one of the following algorithms: 'group14', 'group5', 'group2', 'group1'
        """
        return pulumi.get(self, "ike_diffie_hellman_groups")

    @_builtins.property
    @pulumi.getter(name="ikeLifetime")
    def ike_lifetime(self) -> Optional[_builtins.int]:
        """
        The lifetime of the Phase 1 SA in seconds.
        """
        return pulumi.get(self, "ike_lifetime")

    @_builtins.property
    @pulumi.getter(name="ikePrfAlgos")
    def ike_prf_algos(self) -> Optional[Sequence[_builtins.str]]:
        """
        [optional] This is the pseudo-random function to be used in IKE_SA. The value should be an array with one of the following algorithms: 'prfsha256', 'prfsha1', 'prfmd5', 'default'. The 'default' option can be used to default to the Authentication algorithm.
        """
        return pulumi.get(self, "ike_prf_algos")


@pulumi.output_type
class ApplianceVpnVpnFirewallRulesRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destCidr":
            suggest = "dest_cidr"
        elif key == "destPort":
            suggest = "dest_port"
        elif key == "srcCidr":
            suggest = "src_cidr"
        elif key == "srcPort":
            suggest = "src_port"
        elif key == "syslogEnabled":
            suggest = "syslog_enabled"

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

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

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

    def __init__(__self__, *,
                 comment: Optional[_builtins.str] = None,
                 dest_cidr: Optional[_builtins.str] = None,
                 dest_port: Optional[_builtins.str] = None,
                 policy: Optional[_builtins.str] = None,
                 protocol: Optional[_builtins.str] = None,
                 src_cidr: Optional[_builtins.str] = None,
                 src_port: Optional[_builtins.str] = None,
                 syslog_enabled: Optional[_builtins.bool] = None):
        """
        :param _builtins.str comment: Description of the rule (optional)
        :param _builtins.str dest_cidr: Comma-separated list of destination IP address(es) (in IP or CIDR notation), fully-qualified domain names (FQDN) or 'any'
        :param _builtins.str dest_port: Comma-separated list of destination port(s) (integer in the range 1-65535), or 'any'
        :param _builtins.str policy: 'allow' or 'deny' traffic specified by this rule
        :param _builtins.str protocol: The type of protocol (must be 'tcp', 'udp', 'icmp', 'icmp6' or 'any')
        :param _builtins.str src_cidr: Comma-separated list of source IP address(es) (in IP or CIDR notation), or 'any' (note: FQDN not supported for source addresses)
        :param _builtins.str src_port: Comma-separated list of source port(s) (integer in the range 1-65535), or 'any'
        :param _builtins.bool syslog_enabled: Log this rule to syslog (true or false, boolean value) - only applicable if a syslog has been configured (optional)
        """
        if comment is not None:
            pulumi.set(__self__, "comment", comment)
        if dest_cidr is not None:
            pulumi.set(__self__, "dest_cidr", dest_cidr)
        if dest_port is not None:
            pulumi.set(__self__, "dest_port", dest_port)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if src_cidr is not None:
            pulumi.set(__self__, "src_cidr", src_cidr)
        if src_port is not None:
            pulumi.set(__self__, "src_port", src_port)
        if syslog_enabled is not None:
            pulumi.set(__self__, "syslog_enabled", syslog_enabled)

    @_builtins.property
    @pulumi.getter
    def comment(self) -> Optional[_builtins.str]:
        """
        Description of the rule (optional)
        """
        return pulumi.get(self, "comment")

    @_builtins.property
    @pulumi.getter(name="destCidr")
    def dest_cidr(self) -> Optional[_builtins.str]:
        """
        Comma-separated list of destination IP address(es) (in IP or CIDR notation), fully-qualified domain names (FQDN) or 'any'
        """
        return pulumi.get(self, "dest_cidr")

    @_builtins.property
    @pulumi.getter(name="destPort")
    def dest_port(self) -> Optional[_builtins.str]:
        """
        Comma-separated list of destination port(s) (integer in the range 1-65535), or 'any'
        """
        return pulumi.get(self, "dest_port")

    @_builtins.property
    @pulumi.getter
    def policy(self) -> Optional[_builtins.str]:
        """
        'allow' or 'deny' traffic specified by this rule
        """
        return pulumi.get(self, "policy")

    @_builtins.property
    @pulumi.getter
    def protocol(self) -> Optional[_builtins.str]:
        """
        The type of protocol (must be 'tcp', 'udp', 'icmp', 'icmp6' or 'any')
        """
        return pulumi.get(self, "protocol")

    @_builtins.property
    @pulumi.getter(name="srcCidr")
    def src_cidr(self) -> Optional[_builtins.str]:
        """
        Comma-separated list of source IP address(es) (in IP or CIDR notation), or 'any' (note: FQDN not supported for source addresses)
        """
        return pulumi.get(self, "src_cidr")

    @_builtins.property
    @pulumi.getter(name="srcPort")
    def src_port(self) -> Optional[_builtins.str]:
        """
        Comma-separated list of source port(s) (integer in the range 1-65535), or 'any'
        """
        return pulumi.get(self, "src_port")

    @_builtins.property
    @pulumi.getter(name="syslogEnabled")
    def syslog_enabled(self) -> Optional[_builtins.bool]:
        """
        Log this rule to syslog (true or false, boolean value) - only applicable if a syslog has been configured (optional)
        """
        return pulumi.get(self, "syslog_enabled")


@pulumi.output_type
class BrandingPoliciesAdminSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appliesTo":
            suggest = "applies_to"

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

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

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

    def __init__(__self__, *,
                 applies_to: Optional[_builtins.str] = None,
                 values: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.str applies_to: Which kinds of admins this policy applies to. Can be one of 'All organization admins', 'All enterprise admins', 'All network admins', 'All admins of networks...', 'All admins of networks tagged...', 'Specific admins...', 'All admins' or 'All SAML admins'.
        :param Sequence[_builtins.str] values: If 'appliesTo' is set to one of 'Specific admins...', 'All admins of networks...' or 'All admins of networks tagged...', then you must specify this 'values' property to provide the set of
                 entities to apply the branding policy to. For 'Specific admins...', specify an array of admin IDs. For 'All admins of
                 networks...', specify an array of network IDs and/or configuration template IDs. For 'All admins of networks tagged...',
                 specify an array of tag names.
        """
        if applies_to is not None:
            pulumi.set(__self__, "applies_to", applies_to)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @_builtins.property
    @pulumi.getter(name="appliesTo")
    def applies_to(self) -> Optional[_builtins.str]:
        """
        Which kinds of admins this policy applies to. Can be one of 'All organization admins', 'All enterprise admins', 'All network admins', 'All admins of networks...', 'All admins of networks tagged...', 'Specific admins...', 'All admins' or 'All SAML admins'.
        """
        return pulumi.get(self, "applies_to")

    @_builtins.property
    @pulumi.getter
    def values(self) -> Optional[Sequence[_builtins.str]]:
        """
        If 'appliesTo' is set to one of 'Specific admins...', 'All admins of networks...' or 'All admins of networks tagged...', then you must specify this 'values' property to provide the set of
          entities to apply the branding policy to. For 'Specific admins...', specify an array of admin IDs. For 'All admins of
          networks...', specify an array of network IDs and/or configuration template IDs. For 'All admins of networks tagged...',
          specify an array of tag names.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class BrandingPoliciesCustomLogo(dict):
    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None,
                 image: Optional['outputs.BrandingPoliciesCustomLogoImage'] = None):
        """
        :param _builtins.bool enabled: Whether or not there is a custom logo enabled.
        :param 'BrandingPoliciesCustomLogoImageArgs' image: Properties of the image.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if image is not None:
            pulumi.set(__self__, "image", image)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Whether or not there is a custom logo enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def image(self) -> Optional['outputs.BrandingPoliciesCustomLogoImage']:
        """
        Properties of the image.
        """
        return pulumi.get(self, "image")


@pulumi.output_type
class BrandingPoliciesCustomLogoImage(dict):
    def __init__(__self__, *,
                 contents: Optional[_builtins.str] = None,
                 format: Optional[_builtins.str] = None,
                 preview: Optional['outputs.BrandingPoliciesCustomLogoImagePreview'] = None):
        """
        :param _builtins.str contents: The file contents (a base 64 encoded string) of your new logo.
        :param _builtins.str format: The format of the encoded contents.  Supported formats are 'png', 'gif', and jpg'.
        :param 'BrandingPoliciesCustomLogoImagePreviewArgs' preview: Preview of the image
        """
        if contents is not None:
            pulumi.set(__self__, "contents", contents)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if preview is not None:
            pulumi.set(__self__, "preview", preview)

    @_builtins.property
    @pulumi.getter
    def contents(self) -> Optional[_builtins.str]:
        """
        The file contents (a base 64 encoded string) of your new logo.
        """
        return pulumi.get(self, "contents")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        The format of the encoded contents.  Supported formats are 'png', 'gif', and jpg'.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def preview(self) -> Optional['outputs.BrandingPoliciesCustomLogoImagePreview']:
        """
        Preview of the image
        """
        return pulumi.get(self, "preview")


@pulumi.output_type
class BrandingPoliciesCustomLogoImagePreview(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 BrandingPoliciesCustomLogoImagePreview. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 expires_at: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param _builtins.str expires_at: Timestamp of the preview image
        :param _builtins.str url: Url of the preview image
        """
        if expires_at is not None:
            pulumi.set(__self__, "expires_at", expires_at)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="expiresAt")
    def expires_at(self) -> Optional[_builtins.str]:
        """
        Timestamp of the preview image
        """
        return pulumi.get(self, "expires_at")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        Url of the preview image
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class BrandingPoliciesHelpSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiDocsSubtab":
            suggest = "api_docs_subtab"
        elif key == "casesSubtab":
            suggest = "cases_subtab"
        elif key == "ciscoMerakiProductDocumentation":
            suggest = "cisco_meraki_product_documentation"
        elif key == "communitySubtab":
            suggest = "community_subtab"
        elif key == "dataProtectionRequestsSubtab":
            suggest = "data_protection_requests_subtab"
        elif key == "firewallInfoSubtab":
            suggest = "firewall_info_subtab"
        elif key == "getHelpSubtab":
            suggest = "get_help_subtab"
        elif key == "getHelpSubtabKnowledgeBaseSearch":
            suggest = "get_help_subtab_knowledge_base_search"
        elif key == "hardwareReplacementsSubtab":
            suggest = "hardware_replacements_subtab"
        elif key == "helpTab":
            suggest = "help_tab"
        elif key == "helpWidget":
            suggest = "help_widget"
        elif key == "newFeaturesSubtab":
            suggest = "new_features_subtab"
        elif key == "smForums":
            suggest = "sm_forums"
        elif key == "supportContactInfo":
            suggest = "support_contact_info"
        elif key == "universalSearchKnowledgeBaseSearch":
            suggest = "universal_search_knowledge_base_search"

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

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

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

    def __init__(__self__, *,
                 api_docs_subtab: Optional[_builtins.str] = None,
                 cases_subtab: Optional[_builtins.str] = None,
                 cisco_meraki_product_documentation: Optional[_builtins.str] = None,
                 community_subtab: Optional[_builtins.str] = None,
                 data_protection_requests_subtab: Optional[_builtins.str] = None,
                 firewall_info_subtab: Optional[_builtins.str] = None,
                 get_help_subtab: Optional[_builtins.str] = None,
                 get_help_subtab_knowledge_base_search: Optional[_builtins.str] = None,
                 hardware_replacements_subtab: Optional[_builtins.str] = None,
                 help_tab: Optional[_builtins.str] = None,
                 help_widget: Optional[_builtins.str] = None,
                 new_features_subtab: Optional[_builtins.str] = None,
                 sm_forums: Optional[_builtins.str] = None,
                 support_contact_info: Optional[_builtins.str] = None,
                 universal_search_knowledge_base_search: Optional[_builtins.str] = None):
        """
        :param _builtins.str api_docs_subtab: The 'Help > API docs' subtab where a detailed description of the Dashboard API is listed. Can be one of
                 'default or inherit', 'hide' or 'show'.
        :param _builtins.str cases_subtab: The 'Help > Cases' Dashboard subtab on which Cisco Meraki support cases for this organization can be managed. Can be one
                 of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str cisco_meraki_product_documentation: The 'Product Manuals' section of the 'Help > Get Help' subtab. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        :param _builtins.str community_subtab: The 'Help > Community' subtab which provides a link to Meraki Community. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str data_protection_requests_subtab: The 'Help > Data protection requests' Dashboard subtab on which requests to delete, restrict, or export end-user data can
                 be audited. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str firewall_info_subtab: The 'Help > Firewall info' subtab where necessary upstream firewall rules for communication to the Cisco Meraki cloud are
                 listed. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str get_help_subtab: The 'Help > Get Help' subtab on which Cisco Meraki KB, Product Manuals, and Support/Case Information are displayed. Note
                 that if this subtab is hidden, branding customizations for the KB on 'Get help', Cisco Meraki product documentation,
                 and support contact info will not be visible. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str get_help_subtab_knowledge_base_search: The KB search box which appears on the Help page. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        :param _builtins.str hardware_replacements_subtab: The 'Help > Replacement info' subtab where important information regarding device replacements is detailed. Can be one of
                 'default or inherit', 'hide' or 'show'.
        :param _builtins.str help_tab: The Help tab, under which all support information resides. If this tab is hidden, no other 'Help' branding
                 customizations will be visible. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str help_widget: The 'Help Widget' is a support widget which provides access to live chat, documentation links, Sales contact info,
                 and other contact avenues to reach Meraki Support. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str new_features_subtab: The 'Help > New features' subtab where new Dashboard features are detailed. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str sm_forums: The 'SM Forums' subtab which links to community-based support for Cisco Meraki Systems Manager. Only configurable for
                 organizations that contain Systems Manager networks. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str support_contact_info: The 'Contact Meraki Support' section of the 'Help > Get Help' subtab. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        :param _builtins.str universal_search_knowledge_base_search: The universal search box always visible on Dashboard will, by default, present results from the Meraki KB. This configures
                 whether these Meraki KB results should be returned. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        if api_docs_subtab is not None:
            pulumi.set(__self__, "api_docs_subtab", api_docs_subtab)
        if cases_subtab is not None:
            pulumi.set(__self__, "cases_subtab", cases_subtab)
        if cisco_meraki_product_documentation is not None:
            pulumi.set(__self__, "cisco_meraki_product_documentation", cisco_meraki_product_documentation)
        if community_subtab is not None:
            pulumi.set(__self__, "community_subtab", community_subtab)
        if data_protection_requests_subtab is not None:
            pulumi.set(__self__, "data_protection_requests_subtab", data_protection_requests_subtab)
        if firewall_info_subtab is not None:
            pulumi.set(__self__, "firewall_info_subtab", firewall_info_subtab)
        if get_help_subtab is not None:
            pulumi.set(__self__, "get_help_subtab", get_help_subtab)
        if get_help_subtab_knowledge_base_search is not None:
            pulumi.set(__self__, "get_help_subtab_knowledge_base_search", get_help_subtab_knowledge_base_search)
        if hardware_replacements_subtab is not None:
            pulumi.set(__self__, "hardware_replacements_subtab", hardware_replacements_subtab)
        if help_tab is not None:
            pulumi.set(__self__, "help_tab", help_tab)
        if help_widget is not None:
            pulumi.set(__self__, "help_widget", help_widget)
        if new_features_subtab is not None:
            pulumi.set(__self__, "new_features_subtab", new_features_subtab)
        if sm_forums is not None:
            pulumi.set(__self__, "sm_forums", sm_forums)
        if support_contact_info is not None:
            pulumi.set(__self__, "support_contact_info", support_contact_info)
        if universal_search_knowledge_base_search is not None:
            pulumi.set(__self__, "universal_search_knowledge_base_search", universal_search_knowledge_base_search)

    @_builtins.property
    @pulumi.getter(name="apiDocsSubtab")
    def api_docs_subtab(self) -> Optional[_builtins.str]:
        """
        The 'Help > API docs' subtab where a detailed description of the Dashboard API is listed. Can be one of
          'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "api_docs_subtab")

    @_builtins.property
    @pulumi.getter(name="casesSubtab")
    def cases_subtab(self) -> Optional[_builtins.str]:
        """
        The 'Help > Cases' Dashboard subtab on which Cisco Meraki support cases for this organization can be managed. Can be one
          of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "cases_subtab")

    @_builtins.property
    @pulumi.getter(name="ciscoMerakiProductDocumentation")
    def cisco_meraki_product_documentation(self) -> Optional[_builtins.str]:
        """
        The 'Product Manuals' section of the 'Help > Get Help' subtab. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        """
        return pulumi.get(self, "cisco_meraki_product_documentation")

    @_builtins.property
    @pulumi.getter(name="communitySubtab")
    def community_subtab(self) -> Optional[_builtins.str]:
        """
        The 'Help > Community' subtab which provides a link to Meraki Community. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "community_subtab")

    @_builtins.property
    @pulumi.getter(name="dataProtectionRequestsSubtab")
    def data_protection_requests_subtab(self) -> Optional[_builtins.str]:
        """
        The 'Help > Data protection requests' Dashboard subtab on which requests to delete, restrict, or export end-user data can
          be audited. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "data_protection_requests_subtab")

    @_builtins.property
    @pulumi.getter(name="firewallInfoSubtab")
    def firewall_info_subtab(self) -> Optional[_builtins.str]:
        """
        The 'Help > Firewall info' subtab where necessary upstream firewall rules for communication to the Cisco Meraki cloud are
          listed. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "firewall_info_subtab")

    @_builtins.property
    @pulumi.getter(name="getHelpSubtab")
    def get_help_subtab(self) -> Optional[_builtins.str]:
        """
        The 'Help > Get Help' subtab on which Cisco Meraki KB, Product Manuals, and Support/Case Information are displayed. Note
          that if this subtab is hidden, branding customizations for the KB on 'Get help', Cisco Meraki product documentation,
          and support contact info will not be visible. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "get_help_subtab")

    @_builtins.property
    @pulumi.getter(name="getHelpSubtabKnowledgeBaseSearch")
    def get_help_subtab_knowledge_base_search(self) -> Optional[_builtins.str]:
        """
        The KB search box which appears on the Help page. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        """
        return pulumi.get(self, "get_help_subtab_knowledge_base_search")

    @_builtins.property
    @pulumi.getter(name="hardwareReplacementsSubtab")
    def hardware_replacements_subtab(self) -> Optional[_builtins.str]:
        """
        The 'Help > Replacement info' subtab where important information regarding device replacements is detailed. Can be one of
          'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "hardware_replacements_subtab")

    @_builtins.property
    @pulumi.getter(name="helpTab")
    def help_tab(self) -> Optional[_builtins.str]:
        """
        The Help tab, under which all support information resides. If this tab is hidden, no other 'Help' branding
          customizations will be visible. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "help_tab")

    @_builtins.property
    @pulumi.getter(name="helpWidget")
    def help_widget(self) -> Optional[_builtins.str]:
        """
        The 'Help Widget' is a support widget which provides access to live chat, documentation links, Sales contact info,
          and other contact avenues to reach Meraki Support. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "help_widget")

    @_builtins.property
    @pulumi.getter(name="newFeaturesSubtab")
    def new_features_subtab(self) -> Optional[_builtins.str]:
        """
        The 'Help > New features' subtab where new Dashboard features are detailed. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "new_features_subtab")

    @_builtins.property
    @pulumi.getter(name="smForums")
    def sm_forums(self) -> Optional[_builtins.str]:
        """
        The 'SM Forums' subtab which links to community-based support for Cisco Meraki Systems Manager. Only configurable for
          organizations that contain Systems Manager networks. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "sm_forums")

    @_builtins.property
    @pulumi.getter(name="supportContactInfo")
    def support_contact_info(self) -> Optional[_builtins.str]:
        """
        The 'Contact Meraki Support' section of the 'Help > Get Help' subtab. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        """
        return pulumi.get(self, "support_contact_info")

    @_builtins.property
    @pulumi.getter(name="universalSearchKnowledgeBaseSearch")
    def universal_search_knowledge_base_search(self) -> Optional[_builtins.str]:
        """
        The universal search box always visible on Dashboard will, by default, present results from the Meraki KB. This configures
          whether these Meraki KB results should be returned. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "universal_search_knowledge_base_search")


@pulumi.output_type
class CameraCustomAnalyticsArtifactsStatus(dict):
    def __init__(__self__, *,
                 message: Optional[_builtins.str] = None,
                 type: Optional[_builtins.str] = None):
        """
        :param _builtins.str message: Status message
        :param _builtins.str type: Status type
        """
        if message is not None:
            pulumi.set(__self__, "message", message)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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


@pulumi.output_type
class CameraRolesAppliedOnDevice(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inNetworksWithId":
            suggest = "in_networks_with_id"
        elif key == "inNetworksWithTag":
            suggest = "in_networks_with_tag"
        elif key == "permissionLevel":
            suggest = "permission_level"
        elif key == "permissionScope":
            suggest = "permission_scope"
        elif key == "permissionScopeId":
            suggest = "permission_scope_id"

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

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

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

    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None,
                 in_networks_with_id: Optional[_builtins.str] = None,
                 in_networks_with_tag: Optional[_builtins.str] = None,
                 permission_level: Optional[_builtins.str] = None,
                 permission_scope: Optional[_builtins.str] = None,
                 permission_scope_id: Optional[_builtins.str] = None,
                 tag: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: Device id.
        :param _builtins.str in_networks_with_id: Network id scope
        :param _builtins.str in_networks_with_tag: Network tag scope
        :param _builtins.str permission_scope_id: Permission scope id
        :param _builtins.str tag: Device tag.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if in_networks_with_id is not None:
            pulumi.set(__self__, "in_networks_with_id", in_networks_with_id)
        if in_networks_with_tag is not None:
            pulumi.set(__self__, "in_networks_with_tag", in_networks_with_tag)
        if permission_level is not None:
            pulumi.set(__self__, "permission_level", permission_level)
        if permission_scope is not None:
            pulumi.set(__self__, "permission_scope", permission_scope)
        if permission_scope_id is not None:
            pulumi.set(__self__, "permission_scope_id", permission_scope_id)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)

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

    @_builtins.property
    @pulumi.getter(name="inNetworksWithId")
    def in_networks_with_id(self) -> Optional[_builtins.str]:
        """
        Network id scope
        """
        return pulumi.get(self, "in_networks_with_id")

    @_builtins.property
    @pulumi.getter(name="inNetworksWithTag")
    def in_networks_with_tag(self) -> Optional[_builtins.str]:
        """
        Network tag scope
        """
        return pulumi.get(self, "in_networks_with_tag")

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

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

    @_builtins.property
    @pulumi.getter(name="permissionScopeId")
    def permission_scope_id(self) -> Optional[_builtins.str]:
        """
        Permission scope id
        """
        return pulumi.get(self, "permission_scope_id")

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


@pulumi.output_type
class CameraRolesAppliedOnNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "permissionLevel":
            suggest = "permission_level"
        elif key == "permissionScope":
            suggest = "permission_scope"
        elif key == "permissionScopeId":
            suggest = "permission_scope_id"

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

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

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

    def __init__(__self__, *,
                 id: Optional[_builtins.str] = None,
                 permission_level: Optional[_builtins.str] = None,
                 permission_scope: Optional[_builtins.str] = None,
                 permission_scope_id: Optional[_builtins.str] = None,
                 tag: Optional[_builtins.str] = None):
        """
        :param _builtins.str id: Network id.
        :param _builtins.str permission_scope_id: Permission scope id
        :param _builtins.str tag: Network tag
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if permission_level is not None:
            pulumi.set(__self__, "permission_level", permission_level)
        if permission_scope is not None:
            pulumi.set(__self__, "permission_scope", permission_scope)
        if permission_scope_id is not None:
            pulumi.set(__self__, "permission_scope_id", permission_scope_id)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)

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

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

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

    @_builtins.property
    @pulumi.getter(name="permissionScopeId")
    def permission_scope_id(self) -> Optional[_builtins.str]:
        """
        Permission scope id
        """
        return pulumi.get(self, "permission_scope_id")

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


@pulumi.output_type
class CameraRolesAppliedOrgWide(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "permissionLevel":
            suggest = "permission_level"
        elif key == "permissionScope":
            suggest = "permission_scope"
        elif key == "permissionScopeId":
            suggest = "permission_scope_id"

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

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

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

    def __init__(__self__, *,
                 permission_level: Optional[_builtins.str] = None,
                 permission_scope: Optional[_builtins.str] = None,
                 permission_scope_id: Optional[_builtins.str] = None,
                 tag: Optional[_builtins.str] = None):
        """
        :param _builtins.str permission_scope_id: Permission scope id
        """
        if permission_level is not None:
            pulumi.set(__self__, "permission_level", permission_level)
        if permission_scope is not None:
            pulumi.set(__self__, "permission_scope", permission_scope)
        if permission_scope_id is not None:
            pulumi.set(__self__, "permission_scope_id", permission_scope_id)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)

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

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

    @_builtins.property
    @pulumi.getter(name="permissionScopeId")
    def permission_scope_id(self) -> Optional[_builtins.str]:
        """
        Permission scope id
        """
        return pulumi.get(self, "permission_scope_id")

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


@pulumi.output_type
class ClaimItem(dict):
    def __init__(__self__, *,
                 licenses: Optional[Sequence['outputs.ClaimItemLicense']] = None,
                 orders: Optional[Sequence[_builtins.str]] = None,
                 serials: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence['ClaimItemLicenseArgs'] licenses: The licenses claimed
        :param Sequence[_builtins.str] orders: The numbers of the orders claimed
        :param Sequence[_builtins.str] serials: The serials of the devices claimed
        """
        if licenses is not None:
            pulumi.set(__self__, "licenses", licenses)
        if orders is not None:
            pulumi.set(__self__, "orders", orders)
        if serials is not None:
            pulumi.set(__self__, "serials", serials)

    @_builtins.property
    @pulumi.getter
    def licenses(self) -> Optional[Sequence['outputs.ClaimItemLicense']]:
        """
        The licenses claimed
        """
        return pulumi.get(self, "licenses")

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

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


@pulumi.output_type
class ClaimItemLicense(dict):
    def __init__(__self__, *,
                 key: Optional[_builtins.str] = None,
                 mode: Optional[_builtins.str] = None):
        """
        :param _builtins.str key: The key of the license
        :param _builtins.str mode: The mode of the license
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

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

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


@pulumi.output_type
class ClaimParameters(dict):
    def __init__(__self__, *,
                 licenses: Optional[Sequence['outputs.ClaimParametersLicense']] = None,
                 orders: Optional[Sequence[_builtins.str]] = None,
                 serials: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence['ClaimParametersLicenseArgs'] licenses: The licenses that should be claimed
        :param Sequence[_builtins.str] orders: The numbers of the orders that should be claimed
        :param Sequence[_builtins.str] serials: The serials of the devices that should be claimed
        """
        if licenses is not None:
            pulumi.set(__self__, "licenses", licenses)
        if orders is not None:
            pulumi.set(__self__, "orders", orders)
        if serials is not None:
            pulumi.set(__self__, "serials", serials)

    @_builtins.property
    @pulumi.getter
    def licenses(self) -> Optional[Sequence['outputs.ClaimParametersLicense']]:
        """
        The licenses that should be claimed
        """
        return pulumi.get(self, "licenses")

    @_builtins.property
    @pulumi.getter
    def orders(self) -> Optional[Sequence[_builtins.str]]:
        """
        The numbers of the orders that should be claimed
        """
        return pulumi.get(self, "orders")

    @_builtins.property
    @pulumi.getter
    def serials(self) -> Optional[Sequence[_builtins.str]]:
        """
        The serials of the devices that should be claimed
        """
        return pulumi.get(self, "serials")


@pulumi.output_type
class ClaimParametersLicense(dict):
    def __init__(__self__, *,
                 key: Optional[_builtins.str] = None,
                 mode: Optional[_builtins.str] = None):
        """
        :param _builtins.str key: The key of the license
        :param _builtins.str mode: Either 'renew' or 'addDevices'. 'addDevices' will increase the license limit, while 'renew' will extend the amount of time until expiration. Defaults to 'addDevices'. All licenses must be claimed with the same mode, and at most one renewal can be claimed at a time. This parameter is legacy and does not apply to organizations with per-device licensing enabled.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

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

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional[_builtins.str]:
        """
        Either 'renew' or 'addDevices'. 'addDevices' will increase the license limit, while 'renew' will extend the amount of time until expiration. Defaults to 'addDevices'. All licenses must be claimed with the same mode, and at most one renewal can be claimed at a time. This parameter is legacy and does not apply to organizations with per-device licensing enabled.
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class CloneItem(dict):
    def __init__(__self__, *,
                 api: Optional['outputs.CloneItemApi'] = None,
                 cloud: Optional['outputs.CloneItemCloud'] = None,
                 id: Optional[_builtins.str] = None,
                 licensing: Optional['outputs.CloneItemLicensing'] = None,
                 management: Optional['outputs.CloneItemManagement'] = None,
                 name: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param 'CloneItemApiArgs' api: API related settings
        :param 'CloneItemCloudArgs' cloud: Data for this organization
        :param _builtins.str id: Organization ID
        :param 'CloneItemLicensingArgs' licensing: Licensing related settings
        :param 'CloneItemManagementArgs' management: Information about the organization's management system
        :param _builtins.str name: Organization name
        :param _builtins.str url: Organization URL
        """
        if api is not None:
            pulumi.set(__self__, "api", api)
        if cloud is not None:
            pulumi.set(__self__, "cloud", cloud)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if licensing is not None:
            pulumi.set(__self__, "licensing", licensing)
        if management is not None:
            pulumi.set(__self__, "management", management)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter
    def api(self) -> Optional['outputs.CloneItemApi']:
        """
        API related settings
        """
        return pulumi.get(self, "api")

    @_builtins.property
    @pulumi.getter
    def cloud(self) -> Optional['outputs.CloneItemCloud']:
        """
        Data for this organization
        """
        return pulumi.get(self, "cloud")

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

    @_builtins.property
    @pulumi.getter
    def licensing(self) -> Optional['outputs.CloneItemLicensing']:
        """
        Licensing related settings
        """
        return pulumi.get(self, "licensing")

    @_builtins.property
    @pulumi.getter
    def management(self) -> Optional['outputs.CloneItemManagement']:
        """
        Information about the organization's management system
        """
        return pulumi.get(self, "management")

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

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


@pulumi.output_type
class CloneItemApi(dict):
    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None):
        """
        :param _builtins.bool enabled: Enable API access
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Enable API access
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class CloneItemCloud(dict):
    def __init__(__self__, *,
                 region: Optional['outputs.CloneItemCloudRegion'] = None):
        """
        :param 'CloneItemCloudRegionArgs' region: Region info
        """
        if region is not None:
            pulumi.set(__self__, "region", region)

    @_builtins.property
    @pulumi.getter
    def region(self) -> Optional['outputs.CloneItemCloudRegion']:
        """
        Region info
        """
        return pulumi.get(self, "region")


@pulumi.output_type
class CloneItemCloudRegion(dict):
    def __init__(__self__, *,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.str name: Name of region
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class CloneItemLicensing(dict):
    def __init__(__self__, *,
                 model: Optional[_builtins.str] = None):
        """
        :param _builtins.str model: Organization licensing model. Can be 'co-term', 'per-device', or 'subscription'.
        """
        if model is not None:
            pulumi.set(__self__, "model", model)

    @_builtins.property
    @pulumi.getter
    def model(self) -> Optional[_builtins.str]:
        """
        Organization licensing model. Can be 'co-term', 'per-device', or 'subscription'.
        """
        return pulumi.get(self, "model")


@pulumi.output_type
class CloneItemManagement(dict):
    def __init__(__self__, *,
                 details: Optional[Sequence['outputs.CloneItemManagementDetail']] = None):
        """
        :param Sequence['CloneItemManagementDetailArgs'] details: Details related to organization management, possibly empty. Details may be named 'MSP ID', 'IP restriction mode for API', or 'IP restriction mode for dashboard', if the organization admin has configured any.
        """
        if details is not None:
            pulumi.set(__self__, "details", details)

    @_builtins.property
    @pulumi.getter
    def details(self) -> Optional[Sequence['outputs.CloneItemManagementDetail']]:
        """
        Details related to organization management, possibly empty. Details may be named 'MSP ID', 'IP restriction mode for API', or 'IP restriction mode for dashboard', if the organization admin has configured any.
        """
        return pulumi.get(self, "details")


@pulumi.output_type
class CloneItemManagementDetail(dict):
    def __init__(__self__, *,
                 name: Optional[_builtins.str] = None,
                 value: Optional[_builtins.str] = None):
        """
        :param _builtins.str name: Name of management data
        :param _builtins.str value: Value of management data
        """
        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 management data
        """
        return pulumi.get(self, "name")

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


@pulumi.output_type
class CloneParameters(dict):
    def __init__(__self__, *,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.str name: The name of the new organization
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class ConfigTemplatesSwitchProfilesPortsMirror(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 ConfigTemplatesSwitchProfilesPortsModule(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 ConfigTemplatesSwitchProfilesPortsProfile(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 InventoryClaimItem(dict):
    def __init__(__self__, *,
                 licenses: Optional[Sequence['outputs.InventoryClaimItemLicense']] = None,
                 orders: Optional[Sequence[_builtins.str]] = None,
                 serials: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence['InventoryClaimItemLicenseArgs'] licenses: The licenses claimed
        :param Sequence[_builtins.str] orders: The numbers of the orders claimed
        :param Sequence[_builtins.str] serials: The serials of the devices claimed
        """
        if licenses is not None:
            pulumi.set(__self__, "licenses", licenses)
        if orders is not None:
            pulumi.set(__self__, "orders", orders)
        if serials is not None:
            pulumi.set(__self__, "serials", serials)

    @_builtins.property
    @pulumi.getter
    def licenses(self) -> Optional[Sequence['outputs.InventoryClaimItemLicense']]:
        """
        The licenses claimed
        """
        return pulumi.get(self, "licenses")

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

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


@pulumi.output_type
class InventoryClaimItemLicense(dict):
    def __init__(__self__, *,
                 key: Optional[_builtins.str] = None,
                 mode: Optional[_builtins.str] = None):
        """
        :param _builtins.str key: The key of the license
        :param _builtins.str mode: The mode of the license
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

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

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


@pulumi.output_type
class InventoryClaimParameters(dict):
    def __init__(__self__, *,
                 licenses: Optional[Sequence['outputs.InventoryClaimParametersLicense']] = None,
                 orders: Optional[Sequence[_builtins.str]] = None,
                 serials: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence['InventoryClaimParametersLicenseArgs'] licenses: The licenses that should be claimed
        :param Sequence[_builtins.str] orders: The numbers of the orders that should be claimed
        :param Sequence[_builtins.str] serials: The serials of the devices that should be claimed
        """
        if licenses is not None:
            pulumi.set(__self__, "licenses", licenses)
        if orders is not None:
            pulumi.set(__self__, "orders", orders)
        if serials is not None:
            pulumi.set(__self__, "serials", serials)

    @_builtins.property
    @pulumi.getter
    def licenses(self) -> Optional[Sequence['outputs.InventoryClaimParametersLicense']]:
        """
        The licenses that should be claimed
        """
        return pulumi.get(self, "licenses")

    @_builtins.property
    @pulumi.getter
    def orders(self) -> Optional[Sequence[_builtins.str]]:
        """
        The numbers of the orders that should be claimed
        """
        return pulumi.get(self, "orders")

    @_builtins.property
    @pulumi.getter
    def serials(self) -> Optional[Sequence[_builtins.str]]:
        """
        The serials of the devices that should be claimed
        """
        return pulumi.get(self, "serials")


@pulumi.output_type
class InventoryClaimParametersLicense(dict):
    def __init__(__self__, *,
                 key: Optional[_builtins.str] = None,
                 mode: Optional[_builtins.str] = None):
        """
        :param _builtins.str key: The key of the license
        :param _builtins.str mode: Co-term licensing only: either 'renew' or 'addDevices'. 'addDevices' will increase the license limit, while 'renew' will extend the amount of time until expiration. Defaults to 'addDevices'. All licenses must be claimed with the same mode, and at most one renewal can be claimed at a time. Does not apply to organizations using per-device licensing model.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

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

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional[_builtins.str]:
        """
        Co-term licensing only: either 'renew' or 'addDevices'. 'addDevices' will increase the license limit, while 'renew' will extend the amount of time until expiration. Defaults to 'addDevices'. All licenses must be claimed with the same mode, and at most one renewal can be claimed at a time. Does not apply to organizations using per-device licensing model.
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringExportEventsParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logEvent":
            suggest = "log_event"
        elif key == "targetOs":
            suggest = "target_os"

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

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

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

    def __init__(__self__, *,
                 log_event: Optional[_builtins.str] = None,
                 request: Optional[_builtins.str] = None,
                 target_os: Optional[_builtins.str] = None,
                 timestamp: Optional[_builtins.int] = None):
        """
        :param _builtins.str log_event: The type of log event this is recording, e.g. download or opening a banner
        :param _builtins.str request: Used to describe if this event was the result of a redirect. E.g. a query param if an info banner is being used
        :param _builtins.str target_os: The name of the onboarding distro being downloaded
        :param _builtins.int timestamp: A JavaScript UTC datetime stamp for when the even occurred
        """
        if log_event is not None:
            pulumi.set(__self__, "log_event", log_event)
        if request is not None:
            pulumi.set(__self__, "request", request)
        if target_os is not None:
            pulumi.set(__self__, "target_os", target_os)
        if timestamp is not None:
            pulumi.set(__self__, "timestamp", timestamp)

    @_builtins.property
    @pulumi.getter(name="logEvent")
    def log_event(self) -> Optional[_builtins.str]:
        """
        The type of log event this is recording, e.g. download or opening a banner
        """
        return pulumi.get(self, "log_event")

    @_builtins.property
    @pulumi.getter
    def request(self) -> Optional[_builtins.str]:
        """
        Used to describe if this event was the result of a redirect. E.g. a query param if an info banner is being used
        """
        return pulumi.get(self, "request")

    @_builtins.property
    @pulumi.getter(name="targetOs")
    def target_os(self) -> Optional[_builtins.str]:
        """
        The name of the onboarding distro being downloaded
        """
        return pulumi.get(self, "target_os")

    @_builtins.property
    @pulumi.getter
    def timestamp(self) -> Optional[_builtins.int]:
        """
        A JavaScript UTC datetime stamp for when the even occurred
        """
        return pulumi.get(self, "timestamp")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringImportsParameters(dict):
    def __init__(__self__, *,
                 devices: Optional[Sequence['outputs.InventoryOnboardingCloudMonitoringImportsParametersDevice']] = None,
                 items: Optional[Sequence['outputs.InventoryOnboardingCloudMonitoringImportsParametersItem']] = None):
        """
        :param Sequence['InventoryOnboardingCloudMonitoringImportsParametersDeviceArgs'] devices: A set of device imports to commit
        """
        if devices is not None:
            pulumi.set(__self__, "devices", devices)
        if items is not None:
            pulumi.set(__self__, "items", items)

    @_builtins.property
    @pulumi.getter
    def devices(self) -> Optional[Sequence['outputs.InventoryOnboardingCloudMonitoringImportsParametersDevice']]:
        """
        A set of device imports to commit
        """
        return pulumi.get(self, "devices")

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


@pulumi.output_type
class InventoryOnboardingCloudMonitoringImportsParametersDevice(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceId":
            suggest = "device_id"
        elif key == "networkId":
            suggest = "network_id"

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

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

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

    def __init__(__self__, *,
                 device_id: Optional[_builtins.str] = None,
                 network_id: Optional[_builtins.str] = None,
                 udi: Optional[_builtins.str] = None):
        """
        :param _builtins.str device_id: Import ID from the Import operation
        :param _builtins.str network_id: Network Id
        :param _builtins.str udi: Device UDI certificate
        """
        if device_id is not None:
            pulumi.set(__self__, "device_id", device_id)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if udi is not None:
            pulumi.set(__self__, "udi", udi)

    @_builtins.property
    @pulumi.getter(name="deviceId")
    def device_id(self) -> Optional[_builtins.str]:
        """
        Import ID from the Import operation
        """
        return pulumi.get(self, "device_id")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[_builtins.str]:
        """
        Network Id
        """
        return pulumi.get(self, "network_id")

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


@pulumi.output_type
class InventoryOnboardingCloudMonitoringImportsParametersItem(dict):
    def __init__(__self__, *,
                 items: Optional[Sequence['outputs.InventoryOnboardingCloudMonitoringImportsParametersItemItem']] = None):
        """
        :param Sequence['InventoryOnboardingCloudMonitoringImportsParametersItemItemArgs'] items: Array of ResponseOrganizationsCreateOrganizationInventoryOnboardingCloudMonitoringImport
        """
        if items is not None:
            pulumi.set(__self__, "items", items)

    @_builtins.property
    @pulumi.getter
    def items(self) -> Optional[Sequence['outputs.InventoryOnboardingCloudMonitoringImportsParametersItemItem']]:
        """
        Array of ResponseOrganizationsCreateOrganizationInventoryOnboardingCloudMonitoringImport
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringImportsParametersItemItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "importId":
            suggest = "import_id"

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

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

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

    def __init__(__self__, *,
                 import_id: Optional[_builtins.str] = None,
                 message: Optional[_builtins.str] = None,
                 status: Optional[_builtins.str] = None):
        """
        :param _builtins.str import_id: Unique id associated with the import of the device
        :param _builtins.str message: Response method
        :param _builtins.str status: Cloud monitor import status
        """
        if import_id is not None:
            pulumi.set(__self__, "import_id", import_id)
        if message is not None:
            pulumi.set(__self__, "message", message)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter(name="importId")
    def import_id(self) -> Optional[_builtins.str]:
        """
        Unique id associated with the import of the device
        """
        return pulumi.get(self, "import_id")

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

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


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configParams":
            suggest = "config_params"
        elif key == "deviceId":
            suggest = "device_id"

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

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

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

    def __init__(__self__, *,
                 config_params: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareItemConfigParams'] = None,
                 device_id: Optional[_builtins.str] = None,
                 message: Optional[_builtins.str] = None,
                 status: Optional[_builtins.str] = None,
                 udi: Optional[_builtins.str] = None):
        """
        :param 'InventoryOnboardingCloudMonitoringPrepareItemConfigParamsArgs' config_params: Params used in order to connect to the device
        :param _builtins.str device_id: Import ID from the Import operation
        :param _builtins.str message: Message related to whether or not the device was found and can be imported.
        :param _builtins.str status: The import status of the device
        :param _builtins.str udi: Device UDI certificate
        """
        if config_params is not None:
            pulumi.set(__self__, "config_params", config_params)
        if device_id is not None:
            pulumi.set(__self__, "device_id", device_id)
        if message is not None:
            pulumi.set(__self__, "message", message)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if udi is not None:
            pulumi.set(__self__, "udi", udi)

    @_builtins.property
    @pulumi.getter(name="configParams")
    def config_params(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareItemConfigParams']:
        """
        Params used in order to connect to the device
        """
        return pulumi.get(self, "config_params")

    @_builtins.property
    @pulumi.getter(name="deviceId")
    def device_id(self) -> Optional[_builtins.str]:
        """
        Import ID from the Import operation
        """
        return pulumi.get(self, "device_id")

    @_builtins.property
    @pulumi.getter
    def message(self) -> Optional[_builtins.str]:
        """
        Message related to whether or not the device was found and can be imported.
        """
        return pulumi.get(self, "message")

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

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


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareItemConfigParams(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudStaticIp":
            suggest = "cloud_static_ip"

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

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

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

    def __init__(__self__, *,
                 cloud_static_ip: Optional[_builtins.str] = None,
                 tunnel: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareItemConfigParamsTunnel'] = None,
                 user: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareItemConfigParamsUser'] = None):
        """
        :param _builtins.str cloud_static_ip: Static IP Address used to connect to the device
        :param 'InventoryOnboardingCloudMonitoringPrepareItemConfigParamsTunnelArgs' tunnel: Configuration options used to connect to the device
        :param 'InventoryOnboardingCloudMonitoringPrepareItemConfigParamsUserArgs' user: User credentials used to connect to the device
        """
        if cloud_static_ip is not None:
            pulumi.set(__self__, "cloud_static_ip", cloud_static_ip)
        if tunnel is not None:
            pulumi.set(__self__, "tunnel", tunnel)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @_builtins.property
    @pulumi.getter(name="cloudStaticIp")
    def cloud_static_ip(self) -> Optional[_builtins.str]:
        """
        Static IP Address used to connect to the device
        """
        return pulumi.get(self, "cloud_static_ip")

    @_builtins.property
    @pulumi.getter
    def tunnel(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareItemConfigParamsTunnel']:
        """
        Configuration options used to connect to the device
        """
        return pulumi.get(self, "tunnel")

    @_builtins.property
    @pulumi.getter
    def user(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareItemConfigParamsUser']:
        """
        User credentials used to connect to the device
        """
        return pulumi.get(self, "user")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareItemConfigParamsTunnel(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rootCertificate":
            suggest = "root_certificate"

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

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

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

    def __init__(__self__, *,
                 host: Optional[_builtins.str] = None,
                 mode: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 port: Optional[_builtins.str] = None,
                 root_certificate: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareItemConfigParamsTunnelRootCertificate'] = None):
        """
        :param _builtins.str host: SSH tunnel URL used to connect to the device
        :param _builtins.str name: The name of the tunnel we are attempting to connect to
        :param _builtins.str port: The port used for the ssh tunnel.
        :param 'InventoryOnboardingCloudMonitoringPrepareItemConfigParamsTunnelRootCertificateArgs' root_certificate: Root certificate information
        """
        if host is not None:
            pulumi.set(__self__, "host", host)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if root_certificate is not None:
            pulumi.set(__self__, "root_certificate", root_certificate)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[_builtins.str]:
        """
        SSH tunnel URL used to connect to the device
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        The name of the tunnel we are attempting to connect to
        """
        return pulumi.get(self, "name")

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

    @_builtins.property
    @pulumi.getter(name="rootCertificate")
    def root_certificate(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareItemConfigParamsTunnelRootCertificate']:
        """
        Root certificate information
        """
        return pulumi.get(self, "root_certificate")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareItemConfigParamsTunnelRootCertificate(dict):
    def __init__(__self__, *,
                 content: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.str content: Public certificate value
        :param _builtins.str name: The name of the server protected by the certificate
        """
        if content is not None:
            pulumi.set(__self__, "content", content)
        if name is not None:
            pulumi.set(__self__, "name", name)

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

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        The name of the server protected by the certificate
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareItemConfigParamsUser(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "publicKey":
            suggest = "public_key"

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

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

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

    def __init__(__self__, *,
                 public_key: Optional[_builtins.str] = None,
                 secret: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareItemConfigParamsUserSecret'] = None,
                 username: Optional[_builtins.str] = None):
        """
        :param _builtins.str public_key: The public key for the registered user
        :param 'InventoryOnboardingCloudMonitoringPrepareItemConfigParamsUserSecretArgs' secret: Stores the user secret hash
        :param _builtins.str username: The username added to Catalyst device
        """
        if public_key is not None:
            pulumi.set(__self__, "public_key", public_key)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter(name="publicKey")
    def public_key(self) -> Optional[_builtins.str]:
        """
        The public key for the registered user
        """
        return pulumi.get(self, "public_key")

    @_builtins.property
    @pulumi.getter
    def secret(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareItemConfigParamsUserSecret']:
        """
        Stores the user secret hash
        """
        return pulumi.get(self, "secret")

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[_builtins.str]:
        """
        The username added to Catalyst device
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareItemConfigParamsUserSecret(dict):
    def __init__(__self__, *,
                 hash: Optional[_builtins.str] = None):
        """
        :param _builtins.str hash: The hashed secret
        """
        if hash is not None:
            pulumi.set(__self__, "hash", hash)

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


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareParameters(dict):
    def __init__(__self__, *,
                 devices: Optional[Sequence['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDevice']] = None):
        """
        :param Sequence['InventoryOnboardingCloudMonitoringPrepareParametersDeviceArgs'] devices: A set of devices to import (or update)
        """
        if devices is not None:
            pulumi.set(__self__, "devices", devices)

    @_builtins.property
    @pulumi.getter
    def devices(self) -> Optional[Sequence['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDevice']]:
        """
        A set of devices to import (or update)
        """
        return pulumi.get(self, "devices")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareParametersDevice(dict):
    def __init__(__self__, *,
                 sudi: Optional[_builtins.str] = None,
                 tunnel: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceTunnel'] = None,
                 user: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceUser'] = None,
                 vty: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVty'] = None):
        """
        :param _builtins.str sudi: Device SUDI certificate
        :param 'InventoryOnboardingCloudMonitoringPrepareParametersDeviceTunnelArgs' tunnel: TLS Related Parameters
        :param 'InventoryOnboardingCloudMonitoringPrepareParametersDeviceUserArgs' user: User parameters
        :param 'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyArgs' vty: VTY Related Parameters
        """
        if sudi is not None:
            pulumi.set(__self__, "sudi", sudi)
        if tunnel is not None:
            pulumi.set(__self__, "tunnel", tunnel)
        if user is not None:
            pulumi.set(__self__, "user", user)
        if vty is not None:
            pulumi.set(__self__, "vty", vty)

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

    @_builtins.property
    @pulumi.getter
    def tunnel(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceTunnel']:
        """
        TLS Related Parameters
        """
        return pulumi.get(self, "tunnel")

    @_builtins.property
    @pulumi.getter
    def user(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceUser']:
        """
        User parameters
        """
        return pulumi.get(self, "user")

    @_builtins.property
    @pulumi.getter
    def vty(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVty']:
        """
        VTY Related Parameters
        """
        return pulumi.get(self, "vty")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareParametersDeviceTunnel(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateName":
            suggest = "certificate_name"
        elif key == "localInterface":
            suggest = "local_interface"
        elif key == "loopbackNumber":
            suggest = "loopback_number"

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

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

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

    def __init__(__self__, *,
                 certificate_name: Optional[_builtins.str] = None,
                 local_interface: Optional[_builtins.int] = None,
                 loopback_number: Optional[_builtins.int] = None,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.str certificate_name: Name of the configured TLS certificate
        :param _builtins.int local_interface: Number of the vlan expected to be used to connect to the cloud
        :param _builtins.int loopback_number: Number of the configured Loopback Interface used for TLS overlay
        :param _builtins.str name: Name of the configured TLS tunnel
        """
        if certificate_name is not None:
            pulumi.set(__self__, "certificate_name", certificate_name)
        if local_interface is not None:
            pulumi.set(__self__, "local_interface", local_interface)
        if loopback_number is not None:
            pulumi.set(__self__, "loopback_number", loopback_number)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter(name="certificateName")
    def certificate_name(self) -> Optional[_builtins.str]:
        """
        Name of the configured TLS certificate
        """
        return pulumi.get(self, "certificate_name")

    @_builtins.property
    @pulumi.getter(name="localInterface")
    def local_interface(self) -> Optional[_builtins.int]:
        """
        Number of the vlan expected to be used to connect to the cloud
        """
        return pulumi.get(self, "local_interface")

    @_builtins.property
    @pulumi.getter(name="loopbackNumber")
    def loopback_number(self) -> Optional[_builtins.int]:
        """
        Number of the configured Loopback Interface used for TLS overlay
        """
        return pulumi.get(self, "loopback_number")

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


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareParametersDeviceUser(dict):
    def __init__(__self__, *,
                 username: Optional[_builtins.str] = None):
        """
        :param _builtins.str username: The name of the device user for Meraki monitoring
        """
        if username is not None:
            pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[_builtins.str]:
        """
        The name of the device user for Meraki monitoring
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareParametersDeviceVty(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessList":
            suggest = "access_list"
        elif key == "endLineNumber":
            suggest = "end_line_number"
        elif key == "rotaryNumber":
            suggest = "rotary_number"
        elif key == "startLineNumber":
            suggest = "start_line_number"

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

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

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

    def __init__(__self__, *,
                 access_list: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessList'] = None,
                 authentication: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthentication'] = None,
                 authorization: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthorization'] = None,
                 end_line_number: Optional[_builtins.int] = None,
                 rotary_number: Optional[_builtins.int] = None,
                 start_line_number: Optional[_builtins.int] = None):
        """
        :param 'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessListArgs' access_list: AccessList details
        :param 'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthenticationArgs' authentication: VTY AAA authentication
        :param 'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthorizationArgs' authorization: VTY AAA authorization
        :param _builtins.int end_line_number: Ending line VTY number
        :param _builtins.int rotary_number: SSH rotary number
        :param _builtins.int start_line_number: Starting line VTY number
        """
        if access_list is not None:
            pulumi.set(__self__, "access_list", access_list)
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if authorization is not None:
            pulumi.set(__self__, "authorization", authorization)
        if end_line_number is not None:
            pulumi.set(__self__, "end_line_number", end_line_number)
        if rotary_number is not None:
            pulumi.set(__self__, "rotary_number", rotary_number)
        if start_line_number is not None:
            pulumi.set(__self__, "start_line_number", start_line_number)

    @_builtins.property
    @pulumi.getter(name="accessList")
    def access_list(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessList']:
        """
        AccessList details
        """
        return pulumi.get(self, "access_list")

    @_builtins.property
    @pulumi.getter
    def authentication(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthentication']:
        """
        VTY AAA authentication
        """
        return pulumi.get(self, "authentication")

    @_builtins.property
    @pulumi.getter
    def authorization(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthorization']:
        """
        VTY AAA authorization
        """
        return pulumi.get(self, "authorization")

    @_builtins.property
    @pulumi.getter(name="endLineNumber")
    def end_line_number(self) -> Optional[_builtins.int]:
        """
        Ending line VTY number
        """
        return pulumi.get(self, "end_line_number")

    @_builtins.property
    @pulumi.getter(name="rotaryNumber")
    def rotary_number(self) -> Optional[_builtins.int]:
        """
        SSH rotary number
        """
        return pulumi.get(self, "rotary_number")

    @_builtins.property
    @pulumi.getter(name="startLineNumber")
    def start_line_number(self) -> Optional[_builtins.int]:
        """
        Starting line VTY number
        """
        return pulumi.get(self, "start_line_number")


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessList(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vtyIn":
            suggest = "vty_in"
        elif key == "vtyOut":
            suggest = "vty_out"

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

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

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

    def __init__(__self__, *,
                 vty_in: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessListVtyIn'] = None,
                 vty_out: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessListVtyOut'] = None):
        """
        :param 'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessListVtyInArgs' vty_in: VTY in ACL
        :param 'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessListVtyOutArgs' vty_out: VTY out ACL
        """
        if vty_in is not None:
            pulumi.set(__self__, "vty_in", vty_in)
        if vty_out is not None:
            pulumi.set(__self__, "vty_out", vty_out)

    @_builtins.property
    @pulumi.getter(name="vtyIn")
    def vty_in(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessListVtyIn']:
        """
        VTY in ACL
        """
        return pulumi.get(self, "vty_in")

    @_builtins.property
    @pulumi.getter(name="vtyOut")
    def vty_out(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAccessListVtyOut']:
        """
        VTY out ACL
        """
        return pulumi.get(self, "vty_out")


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

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


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

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


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthentication(dict):
    def __init__(__self__, *,
                 group: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthenticationGroup'] = None):
        """
        :param 'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthenticationGroupArgs' group: Group Details
        """
        if group is not None:
            pulumi.set(__self__, "group", group)

    @_builtins.property
    @pulumi.getter
    def group(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthenticationGroup']:
        """
        Group Details
        """
        return pulumi.get(self, "group")


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

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


@pulumi.output_type
class InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthorization(dict):
    def __init__(__self__, *,
                 group: Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthorizationGroup'] = None):
        """
        :param 'InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthorizationGroupArgs' group: Group Details
        """
        if group is not None:
            pulumi.set(__self__, "group", group)

    @_builtins.property
    @pulumi.getter
    def group(self) -> Optional['outputs.InventoryOnboardingCloudMonitoringPrepareParametersDeviceVtyAuthorizationGroup']:
        """
        Group Details
        """
        return pulumi.get(self, "group")


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

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


@pulumi.output_type
class InventoryReleaseItem(dict):
    def __init__(__self__, *,
                 serials: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] serials: Serials of the devices that were released
        """
        if serials is not None:
            pulumi.set(__self__, "serials", serials)

    @_builtins.property
    @pulumi.getter
    def serials(self) -> Optional[Sequence[_builtins.str]]:
        """
        Serials of the devices that were released
        """
        return pulumi.get(self, "serials")


@pulumi.output_type
class InventoryReleaseParameters(dict):
    def __init__(__self__, *,
                 serials: Optional[Sequence[_builtins.str]] = None):
        """
        :param Sequence[_builtins.str] serials: Serials of the devices that should be released
        """
        if serials is not None:
            pulumi.set(__self__, "serials", serials)

    @_builtins.property
    @pulumi.getter
    def serials(self) -> Optional[Sequence[_builtins.str]]:
        """
        Serials of the devices that should be released
        """
        return pulumi.get(self, "serials")


@pulumi.output_type
class LicensesAssignSeatsItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resultingLicenses":
            suggest = "resulting_licenses"

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

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

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

    def __init__(__self__, *,
                 resulting_licenses: Optional[Sequence['outputs.LicensesAssignSeatsItemResultingLicense']] = None):
        """
        :param Sequence['LicensesAssignSeatsItemResultingLicenseArgs'] resulting_licenses: Resulting licenses from the move
        """
        if resulting_licenses is not None:
            pulumi.set(__self__, "resulting_licenses", resulting_licenses)

    @_builtins.property
    @pulumi.getter(name="resultingLicenses")
    def resulting_licenses(self) -> Optional[Sequence['outputs.LicensesAssignSeatsItemResultingLicense']]:
        """
        Resulting licenses from the move
        """
        return pulumi.get(self, "resulting_licenses")


@pulumi.output_type
class LicensesAssignSeatsItemResultingLicense(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "activationDate":
            suggest = "activation_date"
        elif key == "claimDate":
            suggest = "claim_date"
        elif key == "deviceSerial":
            suggest = "device_serial"
        elif key == "durationInDays":
            suggest = "duration_in_days"
        elif key == "expirationDate":
            suggest = "expiration_date"
        elif key == "headLicenseId":
            suggest = "head_license_id"
        elif key == "licenseKey":
            suggest = "license_key"
        elif key == "licenseType":
            suggest = "license_type"
        elif key == "networkId":
            suggest = "network_id"
        elif key == "orderNumber":
            suggest = "order_number"
        elif key == "permanentlyQueuedLicenses":
            suggest = "permanently_queued_licenses"
        elif key == "seatCount":
            suggest = "seat_count"
        elif key == "totalDurationInDays":
            suggest = "total_duration_in_days"

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

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

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

    def __init__(__self__, *,
                 activation_date: Optional[_builtins.str] = None,
                 claim_date: Optional[_builtins.str] = None,
                 device_serial: Optional[_builtins.str] = None,
                 duration_in_days: Optional[_builtins.int] = None,
                 expiration_date: Optional[_builtins.str] = None,
                 head_license_id: Optional[_builtins.str] = None,
                 id: Optional[_builtins.str] = None,
                 license_key: Optional[_builtins.str] = None,
                 license_type: Optional[_builtins.str] = None,
                 network_id: Optional[_builtins.str] = None,
                 order_number: Optional[_builtins.str] = None,
                 permanently_queued_licenses: Optional[Sequence['outputs.LicensesAssignSeatsItemResultingLicensePermanentlyQueuedLicense']] = None,
                 seat_count: Optional[_builtins.int] = None,
                 state: Optional[_builtins.str] = None,
                 total_duration_in_days: Optional[_builtins.int] = None):
        """
        :param _builtins.str activation_date: The date the license started burning
        :param _builtins.str claim_date: The date the license was claimed into the organization
        :param _builtins.str device_serial: Serial number of the device the license is assigned to
        :param _builtins.int duration_in_days: The duration of the individual license
        :param _builtins.str expiration_date: The date the license will expire
        :param _builtins.str head_license_id: The id of the head license this license is queued behind. If there is no head license, it returns nil.
        :param _builtins.str id: License ID
        :param _builtins.str license_key: License key
        :param _builtins.str license_type: License type
        :param _builtins.str network_id: ID of the network the license is assigned to
        :param _builtins.str order_number: Order number
        :param Sequence['LicensesAssignSeatsItemResultingLicensePermanentlyQueuedLicenseArgs'] permanently_queued_licenses: DEPRECATED List of permanently queued licenses attached to the license. Instead, use /organizations/{organizationId}/licenses?deviceSerial= to retrieved queued licenses for a given device.
        :param _builtins.int seat_count: The number of seats of the license. Only applicable to SM licenses.
        :param _builtins.str state: The state of the license. All queued licenses have a status of *recentlyQueued*.
        :param _builtins.int total_duration_in_days: The duration of the license plus all permanently queued licenses associated with it
        """
        if activation_date is not None:
            pulumi.set(__self__, "activation_date", activation_date)
        if claim_date is not None:
            pulumi.set(__self__, "claim_date", claim_date)
        if device_serial is not None:
            pulumi.set(__self__, "device_serial", device_serial)
        if duration_in_days is not None:
            pulumi.set(__self__, "duration_in_days", duration_in_days)
        if expiration_date is not None:
            pulumi.set(__self__, "expiration_date", expiration_date)
        if head_license_id is not None:
            pulumi.set(__self__, "head_license_id", head_license_id)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if license_key is not None:
            pulumi.set(__self__, "license_key", license_key)
        if license_type is not None:
            pulumi.set(__self__, "license_type", license_type)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if order_number is not None:
            pulumi.set(__self__, "order_number", order_number)
        if permanently_queued_licenses is not None:
            pulumi.set(__self__, "permanently_queued_licenses", permanently_queued_licenses)
        if seat_count is not None:
            pulumi.set(__self__, "seat_count", seat_count)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if total_duration_in_days is not None:
            pulumi.set(__self__, "total_duration_in_days", total_duration_in_days)

    @_builtins.property
    @pulumi.getter(name="activationDate")
    def activation_date(self) -> Optional[_builtins.str]:
        """
        The date the license started burning
        """
        return pulumi.get(self, "activation_date")

    @_builtins.property
    @pulumi.getter(name="claimDate")
    def claim_date(self) -> Optional[_builtins.str]:
        """
        The date the license was claimed into the organization
        """
        return pulumi.get(self, "claim_date")

    @_builtins.property
    @pulumi.getter(name="deviceSerial")
    def device_serial(self) -> Optional[_builtins.str]:
        """
        Serial number of the device the license is assigned to
        """
        return pulumi.get(self, "device_serial")

    @_builtins.property
    @pulumi.getter(name="durationInDays")
    def duration_in_days(self) -> Optional[_builtins.int]:
        """
        The duration of the individual license
        """
        return pulumi.get(self, "duration_in_days")

    @_builtins.property
    @pulumi.getter(name="expirationDate")
    def expiration_date(self) -> Optional[_builtins.str]:
        """
        The date the license will expire
        """
        return pulumi.get(self, "expiration_date")

    @_builtins.property
    @pulumi.getter(name="headLicenseId")
    def head_license_id(self) -> Optional[_builtins.str]:
        """
        The id of the head license this license is queued behind. If there is no head license, it returns nil.
        """
        return pulumi.get(self, "head_license_id")

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

    @_builtins.property
    @pulumi.getter(name="licenseKey")
    def license_key(self) -> Optional[_builtins.str]:
        """
        License key
        """
        return pulumi.get(self, "license_key")

    @_builtins.property
    @pulumi.getter(name="licenseType")
    def license_type(self) -> Optional[_builtins.str]:
        """
        License type
        """
        return pulumi.get(self, "license_type")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[_builtins.str]:
        """
        ID of the network the license is assigned to
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="orderNumber")
    def order_number(self) -> Optional[_builtins.str]:
        """
        Order number
        """
        return pulumi.get(self, "order_number")

    @_builtins.property
    @pulumi.getter(name="permanentlyQueuedLicenses")
    def permanently_queued_licenses(self) -> Optional[Sequence['outputs.LicensesAssignSeatsItemResultingLicensePermanentlyQueuedLicense']]:
        """
        DEPRECATED List of permanently queued licenses attached to the license. Instead, use /organizations/{organizationId}/licenses?deviceSerial= to retrieved queued licenses for a given device.
        """
        return pulumi.get(self, "permanently_queued_licenses")

    @_builtins.property
    @pulumi.getter(name="seatCount")
    def seat_count(self) -> Optional[_builtins.int]:
        """
        The number of seats of the license. Only applicable to SM licenses.
        """
        return pulumi.get(self, "seat_count")

    @_builtins.property
    @pulumi.getter
    def state(self) -> Optional[_builtins.str]:
        """
        The state of the license. All queued licenses have a status of *recentlyQueued*.
        """
        return pulumi.get(self, "state")

    @_builtins.property
    @pulumi.getter(name="totalDurationInDays")
    def total_duration_in_days(self) -> Optional[_builtins.int]:
        """
        The duration of the license plus all permanently queued licenses associated with it
        """
        return pulumi.get(self, "total_duration_in_days")


@pulumi.output_type
class LicensesAssignSeatsItemResultingLicensePermanentlyQueuedLicense(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "durationInDays":
            suggest = "duration_in_days"
        elif key == "licenseKey":
            suggest = "license_key"
        elif key == "licenseType":
            suggest = "license_type"
        elif key == "orderNumber":
            suggest = "order_number"

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

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

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

    def __init__(__self__, *,
                 duration_in_days: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 license_key: Optional[_builtins.str] = None,
                 license_type: Optional[_builtins.str] = None,
                 order_number: Optional[_builtins.str] = None):
        """
        :param _builtins.int duration_in_days: The duration of the individual license
        :param _builtins.str id: Permanently queued license ID
        :param _builtins.str license_key: License key
        :param _builtins.str license_type: License type
        :param _builtins.str order_number: Order number
        """
        if duration_in_days is not None:
            pulumi.set(__self__, "duration_in_days", duration_in_days)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if license_key is not None:
            pulumi.set(__self__, "license_key", license_key)
        if license_type is not None:
            pulumi.set(__self__, "license_type", license_type)
        if order_number is not None:
            pulumi.set(__self__, "order_number", order_number)

    @_builtins.property
    @pulumi.getter(name="durationInDays")
    def duration_in_days(self) -> Optional[_builtins.int]:
        """
        The duration of the individual license
        """
        return pulumi.get(self, "duration_in_days")

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        Permanently queued license ID
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="licenseKey")
    def license_key(self) -> Optional[_builtins.str]:
        """
        License key
        """
        return pulumi.get(self, "license_key")

    @_builtins.property
    @pulumi.getter(name="licenseType")
    def license_type(self) -> Optional[_builtins.str]:
        """
        License type
        """
        return pulumi.get(self, "license_type")

    @_builtins.property
    @pulumi.getter(name="orderNumber")
    def order_number(self) -> Optional[_builtins.str]:
        """
        Order number
        """
        return pulumi.get(self, "order_number")


@pulumi.output_type
class LicensesAssignSeatsParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "licenseId":
            suggest = "license_id"
        elif key == "networkId":
            suggest = "network_id"
        elif key == "seatCount":
            suggest = "seat_count"

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

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

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

    def __init__(__self__, *,
                 license_id: Optional[_builtins.str] = None,
                 network_id: Optional[_builtins.str] = None,
                 seat_count: Optional[_builtins.int] = None):
        """
        :param _builtins.str license_id: The ID of the SM license to assign seats from
        :param _builtins.str network_id: The ID of the SM network to assign the seats to
        :param _builtins.int seat_count: The number of seats to assign to the SM network. Must be less than or equal to the total number of seats of the license
        """
        if license_id is not None:
            pulumi.set(__self__, "license_id", license_id)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if seat_count is not None:
            pulumi.set(__self__, "seat_count", seat_count)

    @_builtins.property
    @pulumi.getter(name="licenseId")
    def license_id(self) -> Optional[_builtins.str]:
        """
        The ID of the SM license to assign seats from
        """
        return pulumi.get(self, "license_id")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[_builtins.str]:
        """
        The ID of the SM network to assign the seats to
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="seatCount")
    def seat_count(self) -> Optional[_builtins.int]:
        """
        The number of seats to assign to the SM network. Must be less than or equal to the total number of seats of the license
        """
        return pulumi.get(self, "seat_count")


@pulumi.output_type
class LicensesMoveItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destOrganizationId":
            suggest = "dest_organization_id"
        elif key == "licenseIds":
            suggest = "license_ids"

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

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

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

    def __init__(__self__, *,
                 dest_organization_id: Optional[_builtins.str] = None,
                 license_ids: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.str dest_organization_id: The ID of the organization to move the licenses to
        :param Sequence[_builtins.str] license_ids: A list of IDs of licenses to move to the new organization
        """
        if dest_organization_id is not None:
            pulumi.set(__self__, "dest_organization_id", dest_organization_id)
        if license_ids is not None:
            pulumi.set(__self__, "license_ids", license_ids)

    @_builtins.property
    @pulumi.getter(name="destOrganizationId")
    def dest_organization_id(self) -> Optional[_builtins.str]:
        """
        The ID of the organization to move the licenses to
        """
        return pulumi.get(self, "dest_organization_id")

    @_builtins.property
    @pulumi.getter(name="licenseIds")
    def license_ids(self) -> Optional[Sequence[_builtins.str]]:
        """
        A list of IDs of licenses to move to the new organization
        """
        return pulumi.get(self, "license_ids")


@pulumi.output_type
class LicensesMoveParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destOrganizationId":
            suggest = "dest_organization_id"
        elif key == "licenseIds":
            suggest = "license_ids"

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

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

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

    def __init__(__self__, *,
                 dest_organization_id: Optional[_builtins.str] = None,
                 license_ids: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.str dest_organization_id: The ID of the organization to move the licenses to
        :param Sequence[_builtins.str] license_ids: A list of IDs of licenses to move to the new organization
        """
        if dest_organization_id is not None:
            pulumi.set(__self__, "dest_organization_id", dest_organization_id)
        if license_ids is not None:
            pulumi.set(__self__, "license_ids", license_ids)

    @_builtins.property
    @pulumi.getter(name="destOrganizationId")
    def dest_organization_id(self) -> Optional[_builtins.str]:
        """
        The ID of the organization to move the licenses to
        """
        return pulumi.get(self, "dest_organization_id")

    @_builtins.property
    @pulumi.getter(name="licenseIds")
    def license_ids(self) -> Optional[Sequence[_builtins.str]]:
        """
        A list of IDs of licenses to move to the new organization
        """
        return pulumi.get(self, "license_ids")


@pulumi.output_type
class LicensesMoveSeatsItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destOrganizationId":
            suggest = "dest_organization_id"
        elif key == "licenseId":
            suggest = "license_id"
        elif key == "seatCount":
            suggest = "seat_count"

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

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

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

    def __init__(__self__, *,
                 dest_organization_id: Optional[_builtins.str] = None,
                 license_id: Optional[_builtins.str] = None,
                 seat_count: Optional[_builtins.int] = None):
        """
        :param _builtins.str dest_organization_id: The ID of the organization to move the SM seats to
        :param _builtins.str license_id: The ID of the SM license to move the seats from
        :param _builtins.int seat_count: The number of seats to move to the new organization. Must be less than or equal to the total number of seats of the license
        """
        if dest_organization_id is not None:
            pulumi.set(__self__, "dest_organization_id", dest_organization_id)
        if license_id is not None:
            pulumi.set(__self__, "license_id", license_id)
        if seat_count is not None:
            pulumi.set(__self__, "seat_count", seat_count)

    @_builtins.property
    @pulumi.getter(name="destOrganizationId")
    def dest_organization_id(self) -> Optional[_builtins.str]:
        """
        The ID of the organization to move the SM seats to
        """
        return pulumi.get(self, "dest_organization_id")

    @_builtins.property
    @pulumi.getter(name="licenseId")
    def license_id(self) -> Optional[_builtins.str]:
        """
        The ID of the SM license to move the seats from
        """
        return pulumi.get(self, "license_id")

    @_builtins.property
    @pulumi.getter(name="seatCount")
    def seat_count(self) -> Optional[_builtins.int]:
        """
        The number of seats to move to the new organization. Must be less than or equal to the total number of seats of the license
        """
        return pulumi.get(self, "seat_count")


@pulumi.output_type
class LicensesMoveSeatsParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destOrganizationId":
            suggest = "dest_organization_id"
        elif key == "licenseId":
            suggest = "license_id"
        elif key == "seatCount":
            suggest = "seat_count"

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

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

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

    def __init__(__self__, *,
                 dest_organization_id: Optional[_builtins.str] = None,
                 license_id: Optional[_builtins.str] = None,
                 seat_count: Optional[_builtins.int] = None):
        """
        :param _builtins.str dest_organization_id: The ID of the organization to move the SM seats to
        :param _builtins.str license_id: The ID of the SM license to move the seats from
        :param _builtins.int seat_count: The number of seats to move to the new organization. Must be less than or equal to the total number of seats of the license
        """
        if dest_organization_id is not None:
            pulumi.set(__self__, "dest_organization_id", dest_organization_id)
        if license_id is not None:
            pulumi.set(__self__, "license_id", license_id)
        if seat_count is not None:
            pulumi.set(__self__, "seat_count", seat_count)

    @_builtins.property
    @pulumi.getter(name="destOrganizationId")
    def dest_organization_id(self) -> Optional[_builtins.str]:
        """
        The ID of the organization to move the SM seats to
        """
        return pulumi.get(self, "dest_organization_id")

    @_builtins.property
    @pulumi.getter(name="licenseId")
    def license_id(self) -> Optional[_builtins.str]:
        """
        The ID of the SM license to move the seats from
        """
        return pulumi.get(self, "license_id")

    @_builtins.property
    @pulumi.getter(name="seatCount")
    def seat_count(self) -> Optional[_builtins.int]:
        """
        The number of seats to move to the new organization. Must be less than or equal to the total number of seats of the license
        """
        return pulumi.get(self, "seat_count")


@pulumi.output_type
class LicensesPermanentlyQueuedLicense(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "durationInDays":
            suggest = "duration_in_days"
        elif key == "licenseKey":
            suggest = "license_key"
        elif key == "licenseType":
            suggest = "license_type"
        elif key == "orderNumber":
            suggest = "order_number"

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

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

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

    def __init__(__self__, *,
                 duration_in_days: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 license_key: Optional[_builtins.str] = None,
                 license_type: Optional[_builtins.str] = None,
                 order_number: Optional[_builtins.str] = None):
        """
        :param _builtins.int duration_in_days: The duration of the individual license
        :param _builtins.str id: Permanently queued license ID
        :param _builtins.str license_key: License key
        :param _builtins.str license_type: License type
        :param _builtins.str order_number: Order number
        """
        if duration_in_days is not None:
            pulumi.set(__self__, "duration_in_days", duration_in_days)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if license_key is not None:
            pulumi.set(__self__, "license_key", license_key)
        if license_type is not None:
            pulumi.set(__self__, "license_type", license_type)
        if order_number is not None:
            pulumi.set(__self__, "order_number", order_number)

    @_builtins.property
    @pulumi.getter(name="durationInDays")
    def duration_in_days(self) -> Optional[_builtins.int]:
        """
        The duration of the individual license
        """
        return pulumi.get(self, "duration_in_days")

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        Permanently queued license ID
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="licenseKey")
    def license_key(self) -> Optional[_builtins.str]:
        """
        License key
        """
        return pulumi.get(self, "license_key")

    @_builtins.property
    @pulumi.getter(name="licenseType")
    def license_type(self) -> Optional[_builtins.str]:
        """
        License type
        """
        return pulumi.get(self, "license_type")

    @_builtins.property
    @pulumi.getter(name="orderNumber")
    def order_number(self) -> Optional[_builtins.str]:
        """
        Order number
        """
        return pulumi.get(self, "order_number")


@pulumi.output_type
class LicensesRenewSeatsItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resultingLicenses":
            suggest = "resulting_licenses"

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

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

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

    def __init__(__self__, *,
                 resulting_licenses: Optional[Sequence['outputs.LicensesRenewSeatsItemResultingLicense']] = None):
        """
        :param Sequence['LicensesRenewSeatsItemResultingLicenseArgs'] resulting_licenses: Resulting licenses from the move
        """
        if resulting_licenses is not None:
            pulumi.set(__self__, "resulting_licenses", resulting_licenses)

    @_builtins.property
    @pulumi.getter(name="resultingLicenses")
    def resulting_licenses(self) -> Optional[Sequence['outputs.LicensesRenewSeatsItemResultingLicense']]:
        """
        Resulting licenses from the move
        """
        return pulumi.get(self, "resulting_licenses")


@pulumi.output_type
class LicensesRenewSeatsItemResultingLicense(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "activationDate":
            suggest = "activation_date"
        elif key == "claimDate":
            suggest = "claim_date"
        elif key == "deviceSerial":
            suggest = "device_serial"
        elif key == "durationInDays":
            suggest = "duration_in_days"
        elif key == "expirationDate":
            suggest = "expiration_date"
        elif key == "headLicenseId":
            suggest = "head_license_id"
        elif key == "licenseKey":
            suggest = "license_key"
        elif key == "licenseType":
            suggest = "license_type"
        elif key == "networkId":
            suggest = "network_id"
        elif key == "orderNumber":
            suggest = "order_number"
        elif key == "permanentlyQueuedLicenses":
            suggest = "permanently_queued_licenses"
        elif key == "seatCount":
            suggest = "seat_count"
        elif key == "totalDurationInDays":
            suggest = "total_duration_in_days"

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

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

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

    def __init__(__self__, *,
                 activation_date: Optional[_builtins.str] = None,
                 claim_date: Optional[_builtins.str] = None,
                 device_serial: Optional[_builtins.str] = None,
                 duration_in_days: Optional[_builtins.int] = None,
                 expiration_date: Optional[_builtins.str] = None,
                 head_license_id: Optional[_builtins.str] = None,
                 id: Optional[_builtins.str] = None,
                 license_key: Optional[_builtins.str] = None,
                 license_type: Optional[_builtins.str] = None,
                 network_id: Optional[_builtins.str] = None,
                 order_number: Optional[_builtins.str] = None,
                 permanently_queued_licenses: Optional[Sequence['outputs.LicensesRenewSeatsItemResultingLicensePermanentlyQueuedLicense']] = None,
                 seat_count: Optional[_builtins.int] = None,
                 state: Optional[_builtins.str] = None,
                 total_duration_in_days: Optional[_builtins.int] = None):
        """
        :param _builtins.str activation_date: The date the license started burning
        :param _builtins.str claim_date: The date the license was claimed into the organization
        :param _builtins.str device_serial: Serial number of the device the license is assigned to
        :param _builtins.int duration_in_days: The duration of the individual license
        :param _builtins.str expiration_date: The date the license will expire
        :param _builtins.str head_license_id: The id of the head license this license is queued behind. If there is no head license, it returns nil.
        :param _builtins.str id: License ID
        :param _builtins.str license_key: License key
        :param _builtins.str license_type: License type
        :param _builtins.str network_id: ID of the network the license is assigned to
        :param _builtins.str order_number: Order number
        :param Sequence['LicensesRenewSeatsItemResultingLicensePermanentlyQueuedLicenseArgs'] permanently_queued_licenses: DEPRECATED List of permanently queued licenses attached to the license. Instead, use /organizations/{organizationId}/licenses?deviceSerial= to retrieved queued licenses for a given device.
        :param _builtins.int seat_count: The number of seats of the license. Only applicable to SM licenses.
        :param _builtins.str state: The state of the license. All queued licenses have a status of *recentlyQueued*.
        :param _builtins.int total_duration_in_days: The duration of the license plus all permanently queued licenses associated with it
        """
        if activation_date is not None:
            pulumi.set(__self__, "activation_date", activation_date)
        if claim_date is not None:
            pulumi.set(__self__, "claim_date", claim_date)
        if device_serial is not None:
            pulumi.set(__self__, "device_serial", device_serial)
        if duration_in_days is not None:
            pulumi.set(__self__, "duration_in_days", duration_in_days)
        if expiration_date is not None:
            pulumi.set(__self__, "expiration_date", expiration_date)
        if head_license_id is not None:
            pulumi.set(__self__, "head_license_id", head_license_id)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if license_key is not None:
            pulumi.set(__self__, "license_key", license_key)
        if license_type is not None:
            pulumi.set(__self__, "license_type", license_type)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if order_number is not None:
            pulumi.set(__self__, "order_number", order_number)
        if permanently_queued_licenses is not None:
            pulumi.set(__self__, "permanently_queued_licenses", permanently_queued_licenses)
        if seat_count is not None:
            pulumi.set(__self__, "seat_count", seat_count)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if total_duration_in_days is not None:
            pulumi.set(__self__, "total_duration_in_days", total_duration_in_days)

    @_builtins.property
    @pulumi.getter(name="activationDate")
    def activation_date(self) -> Optional[_builtins.str]:
        """
        The date the license started burning
        """
        return pulumi.get(self, "activation_date")

    @_builtins.property
    @pulumi.getter(name="claimDate")
    def claim_date(self) -> Optional[_builtins.str]:
        """
        The date the license was claimed into the organization
        """
        return pulumi.get(self, "claim_date")

    @_builtins.property
    @pulumi.getter(name="deviceSerial")
    def device_serial(self) -> Optional[_builtins.str]:
        """
        Serial number of the device the license is assigned to
        """
        return pulumi.get(self, "device_serial")

    @_builtins.property
    @pulumi.getter(name="durationInDays")
    def duration_in_days(self) -> Optional[_builtins.int]:
        """
        The duration of the individual license
        """
        return pulumi.get(self, "duration_in_days")

    @_builtins.property
    @pulumi.getter(name="expirationDate")
    def expiration_date(self) -> Optional[_builtins.str]:
        """
        The date the license will expire
        """
        return pulumi.get(self, "expiration_date")

    @_builtins.property
    @pulumi.getter(name="headLicenseId")
    def head_license_id(self) -> Optional[_builtins.str]:
        """
        The id of the head license this license is queued behind. If there is no head license, it returns nil.
        """
        return pulumi.get(self, "head_license_id")

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

    @_builtins.property
    @pulumi.getter(name="licenseKey")
    def license_key(self) -> Optional[_builtins.str]:
        """
        License key
        """
        return pulumi.get(self, "license_key")

    @_builtins.property
    @pulumi.getter(name="licenseType")
    def license_type(self) -> Optional[_builtins.str]:
        """
        License type
        """
        return pulumi.get(self, "license_type")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[_builtins.str]:
        """
        ID of the network the license is assigned to
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="orderNumber")
    def order_number(self) -> Optional[_builtins.str]:
        """
        Order number
        """
        return pulumi.get(self, "order_number")

    @_builtins.property
    @pulumi.getter(name="permanentlyQueuedLicenses")
    def permanently_queued_licenses(self) -> Optional[Sequence['outputs.LicensesRenewSeatsItemResultingLicensePermanentlyQueuedLicense']]:
        """
        DEPRECATED List of permanently queued licenses attached to the license. Instead, use /organizations/{organizationId}/licenses?deviceSerial= to retrieved queued licenses for a given device.
        """
        return pulumi.get(self, "permanently_queued_licenses")

    @_builtins.property
    @pulumi.getter(name="seatCount")
    def seat_count(self) -> Optional[_builtins.int]:
        """
        The number of seats of the license. Only applicable to SM licenses.
        """
        return pulumi.get(self, "seat_count")

    @_builtins.property
    @pulumi.getter
    def state(self) -> Optional[_builtins.str]:
        """
        The state of the license. All queued licenses have a status of *recentlyQueued*.
        """
        return pulumi.get(self, "state")

    @_builtins.property
    @pulumi.getter(name="totalDurationInDays")
    def total_duration_in_days(self) -> Optional[_builtins.int]:
        """
        The duration of the license plus all permanently queued licenses associated with it
        """
        return pulumi.get(self, "total_duration_in_days")


@pulumi.output_type
class LicensesRenewSeatsItemResultingLicensePermanentlyQueuedLicense(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "durationInDays":
            suggest = "duration_in_days"
        elif key == "licenseKey":
            suggest = "license_key"
        elif key == "licenseType":
            suggest = "license_type"
        elif key == "orderNumber":
            suggest = "order_number"

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

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

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

    def __init__(__self__, *,
                 duration_in_days: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 license_key: Optional[_builtins.str] = None,
                 license_type: Optional[_builtins.str] = None,
                 order_number: Optional[_builtins.str] = None):
        """
        :param _builtins.int duration_in_days: The duration of the individual license
        :param _builtins.str id: Permanently queued license ID
        :param _builtins.str license_key: License key
        :param _builtins.str license_type: License type
        :param _builtins.str order_number: Order number
        """
        if duration_in_days is not None:
            pulumi.set(__self__, "duration_in_days", duration_in_days)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if license_key is not None:
            pulumi.set(__self__, "license_key", license_key)
        if license_type is not None:
            pulumi.set(__self__, "license_type", license_type)
        if order_number is not None:
            pulumi.set(__self__, "order_number", order_number)

    @_builtins.property
    @pulumi.getter(name="durationInDays")
    def duration_in_days(self) -> Optional[_builtins.int]:
        """
        The duration of the individual license
        """
        return pulumi.get(self, "duration_in_days")

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        Permanently queued license ID
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="licenseKey")
    def license_key(self) -> Optional[_builtins.str]:
        """
        License key
        """
        return pulumi.get(self, "license_key")

    @_builtins.property
    @pulumi.getter(name="licenseType")
    def license_type(self) -> Optional[_builtins.str]:
        """
        License type
        """
        return pulumi.get(self, "license_type")

    @_builtins.property
    @pulumi.getter(name="orderNumber")
    def order_number(self) -> Optional[_builtins.str]:
        """
        Order number
        """
        return pulumi.get(self, "order_number")


@pulumi.output_type
class LicensesRenewSeatsParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "licenseIdToRenew":
            suggest = "license_id_to_renew"
        elif key == "unusedLicenseId":
            suggest = "unused_license_id"

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

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

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

    def __init__(__self__, *,
                 license_id_to_renew: Optional[_builtins.str] = None,
                 unused_license_id: Optional[_builtins.str] = None):
        """
        :param _builtins.str license_id_to_renew: The ID of the SM license to renew. This license must already be assigned to an SM network
        :param _builtins.str unused_license_id: The SM license to use to renew the seats on 'licenseIdToRenew'. This license must have at least as many seats available as there are seats on 'licenseIdToRenew'
        """
        if license_id_to_renew is not None:
            pulumi.set(__self__, "license_id_to_renew", license_id_to_renew)
        if unused_license_id is not None:
            pulumi.set(__self__, "unused_license_id", unused_license_id)

    @_builtins.property
    @pulumi.getter(name="licenseIdToRenew")
    def license_id_to_renew(self) -> Optional[_builtins.str]:
        """
        The ID of the SM license to renew. This license must already be assigned to an SM network
        """
        return pulumi.get(self, "license_id_to_renew")

    @_builtins.property
    @pulumi.getter(name="unusedLicenseId")
    def unused_license_id(self) -> Optional[_builtins.str]:
        """
        The SM license to use to renew the seats on 'licenseIdToRenew'. This license must have at least as many seats available as there are seats on 'licenseIdToRenew'
        """
        return pulumi.get(self, "unused_license_id")


@pulumi.output_type
class LicensingCotermLicensesMoveItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "movedLicenses":
            suggest = "moved_licenses"
        elif key == "remainderLicenses":
            suggest = "remainder_licenses"

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

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

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

    def __init__(__self__, *,
                 moved_licenses: Optional[Sequence['outputs.LicensingCotermLicensesMoveItemMovedLicense']] = None,
                 remainder_licenses: Optional[Sequence['outputs.LicensingCotermLicensesMoveItemRemainderLicense']] = None):
        """
        :param Sequence['LicensingCotermLicensesMoveItemMovedLicenseArgs'] moved_licenses: Newly moved licenses created in the destination organization of the license move operation
        :param Sequence['LicensingCotermLicensesMoveItemRemainderLicenseArgs'] remainder_licenses: Remainder licenses created in the source organization as a result of moving a subset of the counts of a license
        """
        if moved_licenses is not None:
            pulumi.set(__self__, "moved_licenses", moved_licenses)
        if remainder_licenses is not None:
            pulumi.set(__self__, "remainder_licenses", remainder_licenses)

    @_builtins.property
    @pulumi.getter(name="movedLicenses")
    def moved_licenses(self) -> Optional[Sequence['outputs.LicensingCotermLicensesMoveItemMovedLicense']]:
        """
        Newly moved licenses created in the destination organization of the license move operation
        """
        return pulumi.get(self, "moved_licenses")

    @_builtins.property
    @pulumi.getter(name="remainderLicenses")
    def remainder_licenses(self) -> Optional[Sequence['outputs.LicensingCotermLicensesMoveItemRemainderLicense']]:
        """
        Remainder licenses created in the source organization as a result of moving a subset of the counts of a license
        """
        return pulumi.get(self, "remainder_licenses")


@pulumi.output_type
class LicensingCotermLicensesMoveItemMovedLicense(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "claimedAt":
            suggest = "claimed_at"
        elif key == "invalidatedAt":
            suggest = "invalidated_at"
        elif key == "organizationId":
            suggest = "organization_id"
        elif key == "startedAt":
            suggest = "started_at"

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

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

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

    def __init__(__self__, *,
                 claimed_at: Optional[_builtins.str] = None,
                 counts: Optional[Sequence['outputs.LicensingCotermLicensesMoveItemMovedLicenseCount']] = None,
                 duration: Optional[_builtins.int] = None,
                 editions: Optional[Sequence['outputs.LicensingCotermLicensesMoveItemMovedLicenseEdition']] = None,
                 expired: Optional[_builtins.bool] = None,
                 invalidated: Optional[_builtins.bool] = None,
                 invalidated_at: Optional[_builtins.str] = None,
                 key: Optional[_builtins.str] = None,
                 mode: Optional[_builtins.str] = None,
                 organization_id: Optional[_builtins.str] = None,
                 started_at: Optional[_builtins.str] = None):
        """
        :param _builtins.str claimed_at: When the license was claimed into the organization
        :param Sequence['LicensingCotermLicensesMoveItemMovedLicenseCountArgs'] counts: The counts of the license by model type
        :param _builtins.int duration: The duration (term length) of the license, measured in days
        :param Sequence['LicensingCotermLicensesMoveItemMovedLicenseEditionArgs'] editions: The editions of the license for each relevant product type
        :param _builtins.bool expired: Flag to indicate if the license is expired
        :param _builtins.bool invalidated: Flag to indicated that the license is invalidated
        :param _builtins.str invalidated_at: When the license was invalidated. Will be null for active licenses
        :param _builtins.str key: The key of the license
        :param _builtins.str mode: The operation mode of the license when it was claimed
        :param _builtins.str organization_id: The ID of the organization that the license is claimed in
        :param _builtins.str started_at: When the license's term began (approximately the date when the license was created)
        """
        if claimed_at is not None:
            pulumi.set(__self__, "claimed_at", claimed_at)
        if counts is not None:
            pulumi.set(__self__, "counts", counts)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if editions is not None:
            pulumi.set(__self__, "editions", editions)
        if expired is not None:
            pulumi.set(__self__, "expired", expired)
        if invalidated is not None:
            pulumi.set(__self__, "invalidated", invalidated)
        if invalidated_at is not None:
            pulumi.set(__self__, "invalidated_at", invalidated_at)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if organization_id is not None:
            pulumi.set(__self__, "organization_id", organization_id)
        if started_at is not None:
            pulumi.set(__self__, "started_at", started_at)

    @_builtins.property
    @pulumi.getter(name="claimedAt")
    def claimed_at(self) -> Optional[_builtins.str]:
        """
        When the license was claimed into the organization
        """
        return pulumi.get(self, "claimed_at")

    @_builtins.property
    @pulumi.getter
    def counts(self) -> Optional[Sequence['outputs.LicensingCotermLicensesMoveItemMovedLicenseCount']]:
        """
        The counts of the license by model type
        """
        return pulumi.get(self, "counts")

    @_builtins.property
    @pulumi.getter
    def duration(self) -> Optional[_builtins.int]:
        """
        The duration (term length) of the license, measured in days
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def editions(self) -> Optional[Sequence['outputs.LicensingCotermLicensesMoveItemMovedLicenseEdition']]:
        """
        The editions of the license for each relevant product type
        """
        return pulumi.get(self, "editions")

    @_builtins.property
    @pulumi.getter
    def expired(self) -> Optional[_builtins.bool]:
        """
        Flag to indicate if the license is expired
        """
        return pulumi.get(self, "expired")

    @_builtins.property
    @pulumi.getter
    def invalidated(self) -> Optional[_builtins.bool]:
        """
        Flag to indicated that the license is invalidated
        """
        return pulumi.get(self, "invalidated")

    @_builtins.property
    @pulumi.getter(name="invalidatedAt")
    def invalidated_at(self) -> Optional[_builtins.str]:
        """
        When the license was invalidated. Will be null for active licenses
        """
        return pulumi.get(self, "invalidated_at")

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

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional[_builtins.str]:
        """
        The operation mode of the license when it was claimed
        """
        return pulumi.get(self, "mode")

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> Optional[_builtins.str]:
        """
        The ID of the organization that the license is claimed in
        """
        return pulumi.get(self, "organization_id")

    @_builtins.property
    @pulumi.getter(name="startedAt")
    def started_at(self) -> Optional[_builtins.str]:
        """
        When the license's term began (approximately the date when the license was created)
        """
        return pulumi.get(self, "started_at")


@pulumi.output_type
class LicensingCotermLicensesMoveItemMovedLicenseCount(dict):
    def __init__(__self__, *,
                 count: Optional[_builtins.int] = None,
                 model: Optional[_builtins.str] = None):
        """
        :param _builtins.int count: The number of counts the license contains of this model
        :param _builtins.str model: The license model type
        """
        if count is not None:
            pulumi.set(__self__, "count", count)
        if model is not None:
            pulumi.set(__self__, "model", model)

    @_builtins.property
    @pulumi.getter
    def count(self) -> Optional[_builtins.int]:
        """
        The number of counts the license contains of this model
        """
        return pulumi.get(self, "count")

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


@pulumi.output_type
class LicensingCotermLicensesMoveItemMovedLicenseEdition(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 LicensingCotermLicensesMoveItemMovedLicenseEdition. Access the value via the '{suggest}' property getter instead.")

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

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

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

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

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


@pulumi.output_type
class LicensingCotermLicensesMoveItemRemainderLicense(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "claimedAt":
            suggest = "claimed_at"
        elif key == "invalidatedAt":
            suggest = "invalidated_at"
        elif key == "organizationId":
            suggest = "organization_id"
        elif key == "startedAt":
            suggest = "started_at"

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

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

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

    def __init__(__self__, *,
                 claimed_at: Optional[_builtins.str] = None,
                 counts: Optional[Sequence['outputs.LicensingCotermLicensesMoveItemRemainderLicenseCount']] = None,
                 duration: Optional[_builtins.int] = None,
                 editions: Optional[Sequence['outputs.LicensingCotermLicensesMoveItemRemainderLicenseEdition']] = None,
                 expired: Optional[_builtins.bool] = None,
                 invalidated: Optional[_builtins.bool] = None,
                 invalidated_at: Optional[_builtins.str] = None,
                 key: Optional[_builtins.str] = None,
                 mode: Optional[_builtins.str] = None,
                 organization_id: Optional[_builtins.str] = None,
                 started_at: Optional[_builtins.str] = None):
        """
        :param _builtins.str claimed_at: When the license was claimed into the organization
        :param Sequence['LicensingCotermLicensesMoveItemRemainderLicenseCountArgs'] counts: The counts of the license by model type
        :param _builtins.int duration: The duration (term length) of the license, measured in days
        :param Sequence['LicensingCotermLicensesMoveItemRemainderLicenseEditionArgs'] editions: The editions of the license for each relevant product type
        :param _builtins.bool expired: Flag to indicate if the license is expired
        :param _builtins.bool invalidated: Flag to indicated that the license is invalidated
        :param _builtins.str invalidated_at: When the license was invalidated. Will be null for active licenses
        :param _builtins.str key: The key of the license
        :param _builtins.str mode: The operation mode of the license when it was claimed
        :param _builtins.str organization_id: The ID of the organization that the license is claimed in
        :param _builtins.str started_at: When the license's term began (approximately the date when the license was created)
        """
        if claimed_at is not None:
            pulumi.set(__self__, "claimed_at", claimed_at)
        if counts is not None:
            pulumi.set(__self__, "counts", counts)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if editions is not None:
            pulumi.set(__self__, "editions", editions)
        if expired is not None:
            pulumi.set(__self__, "expired", expired)
        if invalidated is not None:
            pulumi.set(__self__, "invalidated", invalidated)
        if invalidated_at is not None:
            pulumi.set(__self__, "invalidated_at", invalidated_at)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if organization_id is not None:
            pulumi.set(__self__, "organization_id", organization_id)
        if started_at is not None:
            pulumi.set(__self__, "started_at", started_at)

    @_builtins.property
    @pulumi.getter(name="claimedAt")
    def claimed_at(self) -> Optional[_builtins.str]:
        """
        When the license was claimed into the organization
        """
        return pulumi.get(self, "claimed_at")

    @_builtins.property
    @pulumi.getter
    def counts(self) -> Optional[Sequence['outputs.LicensingCotermLicensesMoveItemRemainderLicenseCount']]:
        """
        The counts of the license by model type
        """
        return pulumi.get(self, "counts")

    @_builtins.property
    @pulumi.getter
    def duration(self) -> Optional[_builtins.int]:
        """
        The duration (term length) of the license, measured in days
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def editions(self) -> Optional[Sequence['outputs.LicensingCotermLicensesMoveItemRemainderLicenseEdition']]:
        """
        The editions of the license for each relevant product type
        """
        return pulumi.get(self, "editions")

    @_builtins.property
    @pulumi.getter
    def expired(self) -> Optional[_builtins.bool]:
        """
        Flag to indicate if the license is expired
        """
        return pulumi.get(self, "expired")

    @_builtins.property
    @pulumi.getter
    def invalidated(self) -> Optional[_builtins.bool]:
        """
        Flag to indicated that the license is invalidated
        """
        return pulumi.get(self, "invalidated")

    @_builtins.property
    @pulumi.getter(name="invalidatedAt")
    def invalidated_at(self) -> Optional[_builtins.str]:
        """
        When the license was invalidated. Will be null for active licenses
        """
        return pulumi.get(self, "invalidated_at")

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

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional[_builtins.str]:
        """
        The operation mode of the license when it was claimed
        """
        return pulumi.get(self, "mode")

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> Optional[_builtins.str]:
        """
        The ID of the organization that the license is claimed in
        """
        return pulumi.get(self, "organization_id")

    @_builtins.property
    @pulumi.getter(name="startedAt")
    def started_at(self) -> Optional[_builtins.str]:
        """
        When the license's term began (approximately the date when the license was created)
        """
        return pulumi.get(self, "started_at")


@pulumi.output_type
class LicensingCotermLicensesMoveItemRemainderLicenseCount(dict):
    def __init__(__self__, *,
                 count: Optional[_builtins.int] = None,
                 model: Optional[_builtins.str] = None):
        """
        :param _builtins.int count: The number of counts the license contains of this model
        :param _builtins.str model: The license model type
        """
        if count is not None:
            pulumi.set(__self__, "count", count)
        if model is not None:
            pulumi.set(__self__, "model", model)

    @_builtins.property
    @pulumi.getter
    def count(self) -> Optional[_builtins.int]:
        """
        The number of counts the license contains of this model
        """
        return pulumi.get(self, "count")

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


@pulumi.output_type
class LicensingCotermLicensesMoveItemRemainderLicenseEdition(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 LicensingCotermLicensesMoveItemRemainderLicenseEdition. Access the value via the '{suggest}' property getter instead.")

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

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

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

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

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


@pulumi.output_type
class LicensingCotermLicensesMoveParameters(dict):
    def __init__(__self__, *,
                 destination: Optional['outputs.LicensingCotermLicensesMoveParametersDestination'] = None,
                 licenses: Optional[Sequence['outputs.LicensingCotermLicensesMoveParametersLicense']] = None):
        """
        :param 'LicensingCotermLicensesMoveParametersDestinationArgs' destination: Destination data for the license move
        :param Sequence['LicensingCotermLicensesMoveParametersLicenseArgs'] licenses: The list of licenses to move
        """
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if licenses is not None:
            pulumi.set(__self__, "licenses", licenses)

    @_builtins.property
    @pulumi.getter
    def destination(self) -> Optional['outputs.LicensingCotermLicensesMoveParametersDestination']:
        """
        Destination data for the license move
        """
        return pulumi.get(self, "destination")

    @_builtins.property
    @pulumi.getter
    def licenses(self) -> Optional[Sequence['outputs.LicensingCotermLicensesMoveParametersLicense']]:
        """
        The list of licenses to move
        """
        return pulumi.get(self, "licenses")


@pulumi.output_type
class LicensingCotermLicensesMoveParametersDestination(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "organizationId":
            suggest = "organization_id"

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

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

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

    def __init__(__self__, *,
                 mode: Optional[_builtins.str] = None,
                 organization_id: Optional[_builtins.str] = None):
        """
        :param _builtins.str mode: The claim mode of the moved license
        :param _builtins.str organization_id: The organization to move the license to
        """
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if organization_id is not None:
            pulumi.set(__self__, "organization_id", organization_id)

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

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> Optional[_builtins.str]:
        """
        The organization to move the license to
        """
        return pulumi.get(self, "organization_id")


@pulumi.output_type
class LicensingCotermLicensesMoveParametersLicense(dict):
    def __init__(__self__, *,
                 counts: Optional[Sequence['outputs.LicensingCotermLicensesMoveParametersLicenseCount']] = None,
                 key: Optional[_builtins.str] = None):
        """
        :param Sequence['LicensingCotermLicensesMoveParametersLicenseCountArgs'] counts: The counts to move from the license by model type
        :param _builtins.str key: The license key to move counts from
        """
        if counts is not None:
            pulumi.set(__self__, "counts", counts)
        if key is not None:
            pulumi.set(__self__, "key", key)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> Optional[Sequence['outputs.LicensingCotermLicensesMoveParametersLicenseCount']]:
        """
        The counts to move from the license by model type
        """
        return pulumi.get(self, "counts")

    @_builtins.property
    @pulumi.getter
    def key(self) -> Optional[_builtins.str]:
        """
        The license key to move counts from
        """
        return pulumi.get(self, "key")


@pulumi.output_type
class LicensingCotermLicensesMoveParametersLicenseCount(dict):
    def __init__(__self__, *,
                 count: Optional[_builtins.int] = None,
                 model: Optional[_builtins.str] = None):
        """
        :param _builtins.int count: The number of counts to move
        :param _builtins.str model: The license model type to move counts of
        """
        if count is not None:
            pulumi.set(__self__, "count", count)
        if model is not None:
            pulumi.set(__self__, "model", model)

    @_builtins.property
    @pulumi.getter
    def count(self) -> Optional[_builtins.int]:
        """
        The number of counts to move
        """
        return pulumi.get(self, "count")

    @_builtins.property
    @pulumi.getter
    def model(self) -> Optional[_builtins.str]:
        """
        The license model type to move counts of
        """
        return pulumi.get(self, "model")


@pulumi.output_type
class LoginSecurityApiAuthentication(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipRestrictionsForKeys":
            suggest = "ip_restrictions_for_keys"

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

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

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

    def __init__(__self__, *,
                 ip_restrictions_for_keys: Optional['outputs.LoginSecurityApiAuthenticationIpRestrictionsForKeys'] = None):
        """
        :param 'LoginSecurityApiAuthenticationIpRestrictionsForKeysArgs' ip_restrictions_for_keys: Details for API-only IP restrictions.
        """
        if ip_restrictions_for_keys is not None:
            pulumi.set(__self__, "ip_restrictions_for_keys", ip_restrictions_for_keys)

    @_builtins.property
    @pulumi.getter(name="ipRestrictionsForKeys")
    def ip_restrictions_for_keys(self) -> Optional['outputs.LoginSecurityApiAuthenticationIpRestrictionsForKeys']:
        """
        Details for API-only IP restrictions.
        """
        return pulumi.get(self, "ip_restrictions_for_keys")


@pulumi.output_type
class LoginSecurityApiAuthenticationIpRestrictionsForKeys(dict):
    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None,
                 ranges: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.bool enabled: Boolean indicating whether the organization will restrict API key (not Dashboard GUI) usage to a specific list of IP addresses or CIDR ranges.
        :param Sequence[_builtins.str] ranges: List of acceptable IP ranges. Entries can be single IP addresses, IP address ranges, and CIDR subnets.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Boolean indicating whether the organization will restrict API key (not Dashboard GUI) usage to a specific list of IP addresses or CIDR ranges.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def ranges(self) -> Optional[Sequence[_builtins.str]]:
        """
        List of acceptable IP ranges. Entries can be single IP addresses, IP address ranges, and CIDR subnets.
        """
        return pulumi.get(self, "ranges")


@pulumi.output_type
class NetworksCombineItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resultingNetwork":
            suggest = "resulting_network"

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

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

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

    def __init__(__self__, *,
                 resulting_network: Optional['outputs.NetworksCombineItemResultingNetwork'] = None):
        """
        :param 'NetworksCombineItemResultingNetworkArgs' resulting_network: Network after the combination
        """
        if resulting_network is not None:
            pulumi.set(__self__, "resulting_network", resulting_network)

    @_builtins.property
    @pulumi.getter(name="resultingNetwork")
    def resulting_network(self) -> Optional['outputs.NetworksCombineItemResultingNetwork']:
        """
        Network after the combination
        """
        return pulumi.get(self, "resulting_network")


@pulumi.output_type
class NetworksCombineItemResultingNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enrollmentString":
            suggest = "enrollment_string"
        elif key == "isBoundToConfigTemplate":
            suggest = "is_bound_to_config_template"
        elif key == "organizationId":
            suggest = "organization_id"
        elif key == "productTypes":
            suggest = "product_types"
        elif key == "timeZone":
            suggest = "time_zone"

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

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

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

    def __init__(__self__, *,
                 enrollment_string: Optional[_builtins.str] = None,
                 id: Optional[_builtins.str] = None,
                 is_bound_to_config_template: Optional[_builtins.bool] = None,
                 name: Optional[_builtins.str] = None,
                 notes: Optional[_builtins.str] = None,
                 organization_id: Optional[_builtins.str] = None,
                 product_types: Optional[Sequence[_builtins.str]] = None,
                 tags: Optional[Sequence[_builtins.str]] = None,
                 time_zone: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param _builtins.str enrollment_string: Enrollment string for the network
        :param _builtins.str id: Network ID
        :param _builtins.bool is_bound_to_config_template: If the network is bound to a config template
        :param _builtins.str name: Network name
        :param _builtins.str notes: Notes for the network
        :param _builtins.str organization_id: Organization ID
        :param Sequence[_builtins.str] product_types: List of the product types that the network supports
        :param Sequence[_builtins.str] tags: Network tags
        :param _builtins.str time_zone: Timezone of the network
        :param _builtins.str url: URL to the network Dashboard UI
        """
        if enrollment_string is not None:
            pulumi.set(__self__, "enrollment_string", enrollment_string)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_bound_to_config_template is not None:
            pulumi.set(__self__, "is_bound_to_config_template", is_bound_to_config_template)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if notes is not None:
            pulumi.set(__self__, "notes", notes)
        if organization_id is not None:
            pulumi.set(__self__, "organization_id", organization_id)
        if product_types is not None:
            pulumi.set(__self__, "product_types", product_types)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="enrollmentString")
    def enrollment_string(self) -> Optional[_builtins.str]:
        """
        Enrollment string for the network
        """
        return pulumi.get(self, "enrollment_string")

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

    @_builtins.property
    @pulumi.getter(name="isBoundToConfigTemplate")
    def is_bound_to_config_template(self) -> Optional[_builtins.bool]:
        """
        If the network is bound to a config template
        """
        return pulumi.get(self, "is_bound_to_config_template")

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

    @_builtins.property
    @pulumi.getter
    def notes(self) -> Optional[_builtins.str]:
        """
        Notes for the network
        """
        return pulumi.get(self, "notes")

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> Optional[_builtins.str]:
        """
        Organization ID
        """
        return pulumi.get(self, "organization_id")

    @_builtins.property
    @pulumi.getter(name="productTypes")
    def product_types(self) -> Optional[Sequence[_builtins.str]]:
        """
        List of the product types that the network supports
        """
        return pulumi.get(self, "product_types")

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

    @_builtins.property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[_builtins.str]:
        """
        Timezone of the network
        """
        return pulumi.get(self, "time_zone")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        URL to the network Dashboard UI
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class NetworksCombineParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enrollmentString":
            suggest = "enrollment_string"
        elif key == "networkIds":
            suggest = "network_ids"

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

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

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

    def __init__(__self__, *,
                 enrollment_string: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 network_ids: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.str enrollment_string: A unique identifier which can be used for device enrollment or easy access through the Meraki SM Registration page or the Self Service Portal. Please note that changing this field may cause existing bookmarks to break. All networks that are part of this combined network will have their enrollment string appended by '-network_type'. If left empty, all exisitng enrollment strings will be deleted.
        :param _builtins.str name: The name of the combined network
        :param Sequence[_builtins.str] network_ids: A list of the network IDs that will be combined. If an ID of a combined network is included in this list, the other networks in the list will be grouped into that network
        """
        if enrollment_string is not None:
            pulumi.set(__self__, "enrollment_string", enrollment_string)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network_ids is not None:
            pulumi.set(__self__, "network_ids", network_ids)

    @_builtins.property
    @pulumi.getter(name="enrollmentString")
    def enrollment_string(self) -> Optional[_builtins.str]:
        """
        A unique identifier which can be used for device enrollment or easy access through the Meraki SM Registration page or the Self Service Portal. Please note that changing this field may cause existing bookmarks to break. All networks that are part of this combined network will have their enrollment string appended by '-network_type'. If left empty, all exisitng enrollment strings will be deleted.
        """
        return pulumi.get(self, "enrollment_string")

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

    @_builtins.property
    @pulumi.getter(name="networkIds")
    def network_ids(self) -> Optional[Sequence[_builtins.str]]:
        """
        A list of the network IDs that will be combined. If an ID of a combined network is included in this list, the other networks in the list will be grouped into that network
        """
        return pulumi.get(self, "network_ids")


@pulumi.output_type
class SamlRolesCamera(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "orgWide":
            suggest = "org_wide"

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

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

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

    def __init__(__self__, *,
                 access: Optional[_builtins.str] = None,
                 org_wide: Optional[_builtins.bool] = None):
        """
        :param _builtins.str access: Camera access ability
        :param _builtins.bool org_wide: Whether or not SAML administrator has org-wide access
        """
        if access is not None:
            pulumi.set(__self__, "access", access)
        if org_wide is not None:
            pulumi.set(__self__, "org_wide", org_wide)

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

    @_builtins.property
    @pulumi.getter(name="orgWide")
    def org_wide(self) -> Optional[_builtins.bool]:
        """
        Whether or not SAML administrator has org-wide access
        """
        return pulumi.get(self, "org_wide")


@pulumi.output_type
class SamlRolesNetwork(dict):
    def __init__(__self__, *,
                 access: Optional[_builtins.str] = None,
                 id: Optional[_builtins.str] = None):
        """
        :param _builtins.str access: The privilege of the SAML administrator on the network
        :param _builtins.str id: The network ID
        """
        if access is not None:
            pulumi.set(__self__, "access", access)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def access(self) -> Optional[_builtins.str]:
        """
        The privilege of the SAML administrator on the network
        """
        return pulumi.get(self, "access")

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


@pulumi.output_type
class SamlRolesTag(dict):
    def __init__(__self__, *,
                 access: Optional[_builtins.str] = None,
                 tag: Optional[_builtins.str] = None):
        """
        :param _builtins.str access: The privilege of the SAML administrator on the tag
        :param _builtins.str tag: The name of the tag
        """
        if access is not None:
            pulumi.set(__self__, "access", access)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)

    @_builtins.property
    @pulumi.getter
    def access(self) -> Optional[_builtins.str]:
        """
        The privilege of the SAML administrator on the tag
        """
        return pulumi.get(self, "access")

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


@pulumi.output_type
class SmSentryPoliciesAssignmentsItem(dict):
    def __init__(__self__, *,
                 items: Optional[Sequence['outputs.SmSentryPoliciesAssignmentsItemItem']] = None):
        """
        :param Sequence['SmSentryPoliciesAssignmentsItemItemArgs'] items: Sentry Group Policies for the Organization keyed by Network Id
        """
        if items is not None:
            pulumi.set(__self__, "items", items)

    @_builtins.property
    @pulumi.getter
    def items(self) -> Optional[Sequence['outputs.SmSentryPoliciesAssignmentsItemItem']]:
        """
        Sentry Group Policies for the Organization keyed by Network Id
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class SmSentryPoliciesAssignmentsItemItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkId":
            suggest = "network_id"

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

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

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

    def __init__(__self__, *,
                 network_id: Optional[_builtins.str] = None,
                 policies: Optional[Sequence['outputs.SmSentryPoliciesAssignmentsItemItemPolicy']] = None):
        """
        :param _builtins.str network_id: The Id of the Network
        :param Sequence['SmSentryPoliciesAssignmentsItemItemPolicyArgs'] policies: Array of Sentry Group Policies for the Network
        """
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[_builtins.str]:
        """
        The Id of the Network
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter
    def policies(self) -> Optional[Sequence['outputs.SmSentryPoliciesAssignmentsItemItemPolicy']]:
        """
        Array of Sentry Group Policies for the Network
        """
        return pulumi.get(self, "policies")


@pulumi.output_type
class SmSentryPoliciesAssignmentsItemItemPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "createdAt":
            suggest = "created_at"
        elif key == "groupNumber":
            suggest = "group_number"
        elif key == "groupPolicyId":
            suggest = "group_policy_id"
        elif key == "lastUpdatedAt":
            suggest = "last_updated_at"
        elif key == "networkId":
            suggest = "network_id"
        elif key == "policyId":
            suggest = "policy_id"
        elif key == "smNetworkId":
            suggest = "sm_network_id"

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

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

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

    def __init__(__self__, *,
                 created_at: Optional[_builtins.str] = None,
                 group_number: Optional[_builtins.str] = None,
                 group_policy_id: Optional[_builtins.str] = None,
                 last_updated_at: Optional[_builtins.str] = None,
                 network_id: Optional[_builtins.str] = None,
                 policy_id: Optional[_builtins.str] = None,
                 priority: Optional[_builtins.str] = None,
                 scope: Optional[_builtins.str] = None,
                 sm_network_id: Optional[_builtins.str] = None,
                 tags: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.str created_at: The creation time of the Sentry Policy
        :param _builtins.str group_number: The number of the Group Policy
        :param _builtins.str group_policy_id: The Id of the Group Policy. This is associated with the network specified by the networkId.
        :param _builtins.str last_updated_at: The last update time of the Sentry Policy
        :param _builtins.str network_id: The Id of the Network the Sentry Policy is associated with. In a locale, this should be the Wireless Group if present, otherwise the Wired Group.
        :param _builtins.str policy_id: The Id of the Sentry Policy
        :param _builtins.str priority: The priority of the Sentry Policy
        :param _builtins.str scope: The scope of the Sentry Policy
        :param _builtins.str sm_network_id: The Id of the Systems Manager Network the Sentry Policy is assigned to
        :param Sequence[_builtins.str] tags: The tags of the Sentry Policy
        """
        if created_at is not None:
            pulumi.set(__self__, "created_at", created_at)
        if group_number is not None:
            pulumi.set(__self__, "group_number", group_number)
        if group_policy_id is not None:
            pulumi.set(__self__, "group_policy_id", group_policy_id)
        if last_updated_at is not None:
            pulumi.set(__self__, "last_updated_at", last_updated_at)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if policy_id is not None:
            pulumi.set(__self__, "policy_id", policy_id)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if scope is not None:
            pulumi.set(__self__, "scope", scope)
        if sm_network_id is not None:
            pulumi.set(__self__, "sm_network_id", sm_network_id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @_builtins.property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> Optional[_builtins.str]:
        """
        The creation time of the Sentry Policy
        """
        return pulumi.get(self, "created_at")

    @_builtins.property
    @pulumi.getter(name="groupNumber")
    def group_number(self) -> Optional[_builtins.str]:
        """
        The number of the Group Policy
        """
        return pulumi.get(self, "group_number")

    @_builtins.property
    @pulumi.getter(name="groupPolicyId")
    def group_policy_id(self) -> Optional[_builtins.str]:
        """
        The Id of the Group Policy. This is associated with the network specified by the networkId.
        """
        return pulumi.get(self, "group_policy_id")

    @_builtins.property
    @pulumi.getter(name="lastUpdatedAt")
    def last_updated_at(self) -> Optional[_builtins.str]:
        """
        The last update time of the Sentry Policy
        """
        return pulumi.get(self, "last_updated_at")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[_builtins.str]:
        """
        The Id of the Network the Sentry Policy is associated with. In a locale, this should be the Wireless Group if present, otherwise the Wired Group.
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="policyId")
    def policy_id(self) -> Optional[_builtins.str]:
        """
        The Id of the Sentry Policy
        """
        return pulumi.get(self, "policy_id")

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

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

    @_builtins.property
    @pulumi.getter(name="smNetworkId")
    def sm_network_id(self) -> Optional[_builtins.str]:
        """
        The Id of the Systems Manager Network the Sentry Policy is assigned to
        """
        return pulumi.get(self, "sm_network_id")

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


@pulumi.output_type
class SmSentryPoliciesAssignmentsParameters(dict):
    def __init__(__self__, *,
                 items: Optional[Sequence['outputs.SmSentryPoliciesAssignmentsParametersItem']] = None):
        """
        :param Sequence['SmSentryPoliciesAssignmentsParametersItemArgs'] items: Sentry Group Policies for the Organization keyed by Network Id
        """
        if items is not None:
            pulumi.set(__self__, "items", items)

    @_builtins.property
    @pulumi.getter
    def items(self) -> Optional[Sequence['outputs.SmSentryPoliciesAssignmentsParametersItem']]:
        """
        Sentry Group Policies for the Organization keyed by Network Id
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class SmSentryPoliciesAssignmentsParametersItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkId":
            suggest = "network_id"

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

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

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

    def __init__(__self__, *,
                 network_id: Optional[_builtins.str] = None,
                 policies: Optional[Sequence['outputs.SmSentryPoliciesAssignmentsParametersItemPolicy']] = None):
        """
        :param _builtins.str network_id: The Id of the Network
        :param Sequence['SmSentryPoliciesAssignmentsParametersItemPolicyArgs'] policies: Array of Sentry Group Policies for the Network
        """
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[_builtins.str]:
        """
        The Id of the Network
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter
    def policies(self) -> Optional[Sequence['outputs.SmSentryPoliciesAssignmentsParametersItemPolicy']]:
        """
        Array of Sentry Group Policies for the Network
        """
        return pulumi.get(self, "policies")


@pulumi.output_type
class SmSentryPoliciesAssignmentsParametersItemPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "groupPolicyId":
            suggest = "group_policy_id"
        elif key == "policyId":
            suggest = "policy_id"
        elif key == "smNetworkId":
            suggest = "sm_network_id"

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

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

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

    def __init__(__self__, *,
                 group_policy_id: Optional[_builtins.str] = None,
                 policy_id: Optional[_builtins.str] = None,
                 scope: Optional[_builtins.str] = None,
                 sm_network_id: Optional[_builtins.str] = None,
                 tags: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.str group_policy_id: The Group Policy Id
        :param _builtins.str policy_id: The Sentry Policy Id, if updating an existing Sentry Policy
        :param _builtins.str scope: The scope of the Sentry Policy
        :param _builtins.str sm_network_id: The Id of the Systems Manager Network
        :param Sequence[_builtins.str] tags: The tags for the Sentry Policy
        """
        if group_policy_id is not None:
            pulumi.set(__self__, "group_policy_id", group_policy_id)
        if policy_id is not None:
            pulumi.set(__self__, "policy_id", policy_id)
        if scope is not None:
            pulumi.set(__self__, "scope", scope)
        if sm_network_id is not None:
            pulumi.set(__self__, "sm_network_id", sm_network_id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @_builtins.property
    @pulumi.getter(name="groupPolicyId")
    def group_policy_id(self) -> Optional[_builtins.str]:
        """
        The Group Policy Id
        """
        return pulumi.get(self, "group_policy_id")

    @_builtins.property
    @pulumi.getter(name="policyId")
    def policy_id(self) -> Optional[_builtins.str]:
        """
        The Sentry Policy Id, if updating an existing Sentry Policy
        """
        return pulumi.get(self, "policy_id")

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

    @_builtins.property
    @pulumi.getter(name="smNetworkId")
    def sm_network_id(self) -> Optional[_builtins.str]:
        """
        The Id of the Systems Manager Network
        """
        return pulumi.get(self, "sm_network_id")

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[_builtins.str]]:
        """
        The tags for the Sentry Policy
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class SwitchDevicesCloneParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceSerial":
            suggest = "source_serial"
        elif key == "targetSerials":
            suggest = "target_serials"

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

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

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

    def __init__(__self__, *,
                 source_serial: Optional[_builtins.str] = None,
                 target_serials: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.str source_serial: Serial number of the source switch (must be on a network not bound to a template)
        :param Sequence[_builtins.str] target_serials: Array of serial numbers of one or more target switches (must be on a network not bound to a template)
        """
        if source_serial is not None:
            pulumi.set(__self__, "source_serial", source_serial)
        if target_serials is not None:
            pulumi.set(__self__, "target_serials", target_serials)

    @_builtins.property
    @pulumi.getter(name="sourceSerial")
    def source_serial(self) -> Optional[_builtins.str]:
        """
        Serial number of the source switch (must be on a network not bound to a template)
        """
        return pulumi.get(self, "source_serial")

    @_builtins.property
    @pulumi.getter(name="targetSerials")
    def target_serials(self) -> Optional[Sequence[_builtins.str]]:
        """
        Array of serial numbers of one or more target switches (must be on a network not bound to a template)
        """
        return pulumi.get(self, "target_serials")


@pulumi.output_type
class BaseApi(dict):
    def __init__(__self__, *,
                 enabled: Optional[_builtins.bool] = None):
        """
        :param _builtins.bool enabled: Enable API access
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[_builtins.bool]:
        """
        Enable API access
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class BaseCloud(dict):
    def __init__(__self__, *,
                 region: Optional['outputs.BaseCloudRegion'] = None):
        """
        :param 'BaseCloudRegionArgs' region: Region info
        """
        if region is not None:
            pulumi.set(__self__, "region", region)

    @_builtins.property
    @pulumi.getter
    def region(self) -> Optional['outputs.BaseCloudRegion']:
        """
        Region info
        """
        return pulumi.get(self, "region")


@pulumi.output_type
class BaseCloudRegion(dict):
    def __init__(__self__, *,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.str name: Name of region
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class BaseLicensing(dict):
    def __init__(__self__, *,
                 model: Optional[_builtins.str] = None):
        """
        :param _builtins.str model: Organization licensing model. Can be 'co-term', 'per-device', or 'subscription'.
        """
        if model is not None:
            pulumi.set(__self__, "model", model)

    @_builtins.property
    @pulumi.getter
    def model(self) -> Optional[_builtins.str]:
        """
        Organization licensing model. Can be 'co-term', 'per-device', or 'subscription'.
        """
        return pulumi.get(self, "model")


@pulumi.output_type
class BaseManagement(dict):
    def __init__(__self__, *,
                 details: Optional[Sequence['outputs.BaseManagementDetail']] = None):
        """
        :param Sequence['BaseManagementDetailArgs'] details: Details related to organization management, possibly empty. Details may be named 'MSP ID', 'IP restriction mode for API', or 'IP restriction mode for dashboard', if the organization admin has configured any.
        """
        if details is not None:
            pulumi.set(__self__, "details", details)

    @_builtins.property
    @pulumi.getter
    def details(self) -> Optional[Sequence['outputs.BaseManagementDetail']]:
        """
        Details related to organization management, possibly empty. Details may be named 'MSP ID', 'IP restriction mode for API', or 'IP restriction mode for dashboard', if the organization admin has configured any.
        """
        return pulumi.get(self, "details")


@pulumi.output_type
class BaseManagementDetail(dict):
    def __init__(__self__, *,
                 name: Optional[_builtins.str] = None,
                 value: Optional[_builtins.str] = None):
        """
        :param _builtins.str name: Name of management data
        :param _builtins.str value: Value of management data
        """
        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 management data
        """
        return pulumi.get(self, "name")

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


@pulumi.output_type
class GetActionBatchesItemResult(dict):
    def __init__(__self__, *,
                 actions: Sequence['outputs.GetActionBatchesItemActionResult'],
                 confirmed: _builtins.bool,
                 id: _builtins.str,
                 organization_id: _builtins.str,
                 status: 'outputs.GetActionBatchesItemStatusResult',
                 synchronous: _builtins.bool):
        """
        :param Sequence['GetActionBatchesItemActionArgs'] actions: A set of changes made as part of this action (\\n\\nmore details\\n\\n)
        :param _builtins.bool confirmed: Flag describing whether the action should be previewed before executing or not
        :param _builtins.str id: ID of the action batch. Can be used to check the status of the action batch at /organizations/{organizationId}/actionBatches/{actionBatchId}
        :param _builtins.str organization_id: ID of the organization this action batch belongs to
        :param 'GetActionBatchesItemStatusArgs' status: Status of action batch
        :param _builtins.bool synchronous: Flag describing whether actions should run synchronously or asynchronously
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "confirmed", confirmed)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "organization_id", organization_id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "synchronous", synchronous)

    @_builtins.property
    @pulumi.getter
    def actions(self) -> Sequence['outputs.GetActionBatchesItemActionResult']:
        """
        A set of changes made as part of this action (\\n\\nmore details\\n\\n)
        """
        return pulumi.get(self, "actions")

    @_builtins.property
    @pulumi.getter
    def confirmed(self) -> _builtins.bool:
        """
        Flag describing whether the action should be previewed before executing or not
        """
        return pulumi.get(self, "confirmed")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID of the action batch. Can be used to check the status of the action batch at /organizations/{organizationId}/actionBatches/{actionBatchId}
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> _builtins.str:
        """
        ID of the organization this action batch belongs to
        """
        return pulumi.get(self, "organization_id")

    @_builtins.property
    @pulumi.getter
    def status(self) -> 'outputs.GetActionBatchesItemStatusResult':
        """
        Status of action batch
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def synchronous(self) -> _builtins.bool:
        """
        Flag describing whether actions should run synchronously or asynchronously
        """
        return pulumi.get(self, "synchronous")


@pulumi.output_type
class GetActionBatchesItemActionResult(dict):
    def __init__(__self__, *,
                 body: _builtins.str,
                 operation: _builtins.str,
                 resource: _builtins.str):
        """
        :param _builtins.str body: Data provided in the body of the Action. Contents depend on the Action type
        :param _builtins.str operation: The operation to be used by this action
        :param _builtins.str resource: Unique identifier for the resource to be acted on
        """
        pulumi.set(__self__, "body", body)
        pulumi.set(__self__, "operation", operation)
        pulumi.set(__self__, "resource", resource)

    @_builtins.property
    @pulumi.getter
    def body(self) -> _builtins.str:
        """
        Data provided in the body of the Action. Contents depend on the Action type
        """
        return pulumi.get(self, "body")

    @_builtins.property
    @pulumi.getter
    def operation(self) -> _builtins.str:
        """
        The operation to be used by this action
        """
        return pulumi.get(self, "operation")

    @_builtins.property
    @pulumi.getter
    def resource(self) -> _builtins.str:
        """
        Unique identifier for the resource to be acted on
        """
        return pulumi.get(self, "resource")


@pulumi.output_type
class GetActionBatchesItemStatusResult(dict):
    def __init__(__self__, *,
                 completed: _builtins.bool,
                 created_resources: Sequence['outputs.GetActionBatchesItemStatusCreatedResourceResult'],
                 errors: Sequence[_builtins.str],
                 failed: _builtins.bool):
        """
        :param _builtins.bool completed: Flag describing whether all actions in the action batch have completed
        :param Sequence['GetActionBatchesItemStatusCreatedResourceArgs'] created_resources: Resources created as a result of this action batch
        :param Sequence[_builtins.str] errors: List of errors encountered when running actions in the action batch
        :param _builtins.bool failed: Flag describing whether any actions in the action batch failed
        """
        pulumi.set(__self__, "completed", completed)
        pulumi.set(__self__, "created_resources", created_resources)
        pulumi.set(__self__, "errors", errors)
        pulumi.set(__self__, "failed", failed)

    @_builtins.property
    @pulumi.getter
    def completed(self) -> _builtins.bool:
        """
        Flag describing whether all actions in the action batch have completed
        """
        return pulumi.get(self, "completed")

    @_builtins.property
    @pulumi.getter(name="createdResources")
    def created_resources(self) -> Sequence['outputs.GetActionBatchesItemStatusCreatedResourceResult']:
        """
        Resources created as a result of this action batch
        """
        return pulumi.get(self, "created_resources")

    @_builtins.property
    @pulumi.getter
    def errors(self) -> Sequence[_builtins.str]:
        """
        List of errors encountered when running actions in the action batch
        """
        return pulumi.get(self, "errors")

    @_builtins.property
    @pulumi.getter
    def failed(self) -> _builtins.bool:
        """
        Flag describing whether any actions in the action batch failed
        """
        return pulumi.get(self, "failed")


@pulumi.output_type
class GetActionBatchesItemStatusCreatedResourceResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 uri: _builtins.str):
        """
        :param _builtins.str id: ID of the created resource
        :param _builtins.str uri: URI, not including base, of the created resource
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "uri", uri)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID of the created resource
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def uri(self) -> _builtins.str:
        """
        URI, not including base, of the created resource
        """
        return pulumi.get(self, "uri")


@pulumi.output_type
class GetAdaptivePolicyAclsItemResult(dict):
    def __init__(__self__, *,
                 acl_id: _builtins.str,
                 created_at: _builtins.str,
                 description: _builtins.str,
                 ip_version: _builtins.str,
                 name: _builtins.str,
                 rules: Sequence['outputs.GetAdaptivePolicyAclsItemRuleResult'],
                 updated_at: _builtins.str):
        """
        :param _builtins.str acl_id: ID of the adaptive policy ACL
        :param _builtins.str created_at: When the adaptive policy ACL was created
        :param _builtins.str description: Description of the adaptive policy ACL
        :param _builtins.str ip_version: IP version of adpative policy ACL
        :param _builtins.str name: Name of the adaptive policy ACL
        :param Sequence['GetAdaptivePolicyAclsItemRuleArgs'] rules: An ordered array of the adaptive policy ACL rules
        :param _builtins.str updated_at: When the adaptive policy ACL was last updated
        """
        pulumi.set(__self__, "acl_id", acl_id)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "ip_version", ip_version)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "rules", rules)
        pulumi.set(__self__, "updated_at", updated_at)

    @_builtins.property
    @pulumi.getter(name="aclId")
    def acl_id(self) -> _builtins.str:
        """
        ID of the adaptive policy ACL
        """
        return pulumi.get(self, "acl_id")

    @_builtins.property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> _builtins.str:
        """
        When the adaptive policy ACL was created
        """
        return pulumi.get(self, "created_at")

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

    @_builtins.property
    @pulumi.getter(name="ipVersion")
    def ip_version(self) -> _builtins.str:
        """
        IP version of adpative policy ACL
        """
        return pulumi.get(self, "ip_version")

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

    @_builtins.property
    @pulumi.getter
    def rules(self) -> Sequence['outputs.GetAdaptivePolicyAclsItemRuleResult']:
        """
        An ordered array of the adaptive policy ACL rules
        """
        return pulumi.get(self, "rules")

    @_builtins.property
    @pulumi.getter(name="updatedAt")
    def updated_at(self) -> _builtins.str:
        """
        When the adaptive policy ACL was last updated
        """
        return pulumi.get(self, "updated_at")


@pulumi.output_type
class GetAdaptivePolicyAclsItemRuleResult(dict):
    def __init__(__self__, *,
                 dst_port: _builtins.str,
                 policy: _builtins.str,
                 protocol: _builtins.str,
                 src_port: _builtins.str):
        """
        :param _builtins.str dst_port: Destination port
        :param _builtins.str policy: 'allow' or 'deny' traffic specified by this rule
        :param _builtins.str protocol: The type of protocol
        :param _builtins.str src_port: Source port
        """
        pulumi.set(__self__, "dst_port", dst_port)
        pulumi.set(__self__, "policy", policy)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "src_port", src_port)

    @_builtins.property
    @pulumi.getter(name="dstPort")
    def dst_port(self) -> _builtins.str:
        """
        Destination port
        """
        return pulumi.get(self, "dst_port")

    @_builtins.property
    @pulumi.getter
    def policy(self) -> _builtins.str:
        """
        'allow' or 'deny' traffic specified by this rule
        """
        return pulumi.get(self, "policy")

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

    @_builtins.property
    @pulumi.getter(name="srcPort")
    def src_port(self) -> _builtins.str:
        """
        Source port
        """
        return pulumi.get(self, "src_port")


@pulumi.output_type
class GetAdaptivePolicyGroupsItemResult(dict):
    def __init__(__self__, *,
                 created_at: _builtins.str,
                 description: _builtins.str,
                 group_id: _builtins.str,
                 is_default_group: _builtins.bool,
                 name: _builtins.str,
                 policy_objects: Sequence['outputs.GetAdaptivePolicyGroupsItemPolicyObjectResult'],
                 required_ip_mappings: Sequence[_builtins.str],
                 sgt: _builtins.int,
                 updated_at: _builtins.str):
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "group_id", group_id)
        pulumi.set(__self__, "is_default_group", is_default_group)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "policy_objects", policy_objects)
        pulumi.set(__self__, "required_ip_mappings", required_ip_mappings)
        pulumi.set(__self__, "sgt", sgt)
        pulumi.set(__self__, "updated_at", updated_at)

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

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

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

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

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

    @_builtins.property
    @pulumi.getter(name="policyObjects")
    def policy_objects(self) -> Sequence['outputs.GetAdaptivePolicyGroupsItemPolicyObjectResult']:
        return pulumi.get(self, "policy_objects")

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

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

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


@pulumi.output_type
class GetAdaptivePolicyGroupsItemPolicyObjectResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetAdaptivePolicyOverviewItemResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetAdaptivePolicyOverviewItemCountsResult',
                 limits: 'outputs.GetAdaptivePolicyOverviewItemLimitsResult'):
        """
        :param 'GetAdaptivePolicyOverviewItemCountsArgs' counts: The current amount of various adaptive policy objects.
        :param 'GetAdaptivePolicyOverviewItemLimitsArgs' limits: The current limits of various adaptive policy objects.
        """
        pulumi.set(__self__, "counts", counts)
        pulumi.set(__self__, "limits", limits)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> 'outputs.GetAdaptivePolicyOverviewItemCountsResult':
        """
        The current amount of various adaptive policy objects.
        """
        return pulumi.get(self, "counts")

    @_builtins.property
    @pulumi.getter
    def limits(self) -> 'outputs.GetAdaptivePolicyOverviewItemLimitsResult':
        """
        The current limits of various adaptive policy objects.
        """
        return pulumi.get(self, "limits")


@pulumi.output_type
class GetAdaptivePolicyOverviewItemCountsResult(dict):
    def __init__(__self__, *,
                 allow_policies: _builtins.int,
                 custom_acls: _builtins.int,
                 custom_groups: _builtins.int,
                 deny_policies: _builtins.int,
                 groups: _builtins.int,
                 policies: _builtins.int,
                 policy_objects: _builtins.int):
        """
        :param _builtins.int allow_policies: Number of adaptive policies currently in the organization that allow all traffic.
        :param _builtins.int custom_acls: Number of user-created adaptive policy ACLs currently in the organization.
        :param _builtins.int custom_groups: Number of user-created adaptive policy groups currently in the organization.
        :param _builtins.int deny_policies: Number of adaptive policies currently in the organization that deny all traffic.
        :param _builtins.int groups: Number of adaptive policy groups currently in the organization.
        :param _builtins.int policies: Number of adaptive policies currently in the organization.
        :param _builtins.int policy_objects: Number of policy objects (with the adaptive policy type) currently in the organization.
        """
        pulumi.set(__self__, "allow_policies", allow_policies)
        pulumi.set(__self__, "custom_acls", custom_acls)
        pulumi.set(__self__, "custom_groups", custom_groups)
        pulumi.set(__self__, "deny_policies", deny_policies)
        pulumi.set(__self__, "groups", groups)
        pulumi.set(__self__, "policies", policies)
        pulumi.set(__self__, "policy_objects", policy_objects)

    @_builtins.property
    @pulumi.getter(name="allowPolicies")
    def allow_policies(self) -> _builtins.int:
        """
        Number of adaptive policies currently in the organization that allow all traffic.
        """
        return pulumi.get(self, "allow_policies")

    @_builtins.property
    @pulumi.getter(name="customAcls")
    def custom_acls(self) -> _builtins.int:
        """
        Number of user-created adaptive policy ACLs currently in the organization.
        """
        return pulumi.get(self, "custom_acls")

    @_builtins.property
    @pulumi.getter(name="customGroups")
    def custom_groups(self) -> _builtins.int:
        """
        Number of user-created adaptive policy groups currently in the organization.
        """
        return pulumi.get(self, "custom_groups")

    @_builtins.property
    @pulumi.getter(name="denyPolicies")
    def deny_policies(self) -> _builtins.int:
        """
        Number of adaptive policies currently in the organization that deny all traffic.
        """
        return pulumi.get(self, "deny_policies")

    @_builtins.property
    @pulumi.getter
    def groups(self) -> _builtins.int:
        """
        Number of adaptive policy groups currently in the organization.
        """
        return pulumi.get(self, "groups")

    @_builtins.property
    @pulumi.getter
    def policies(self) -> _builtins.int:
        """
        Number of adaptive policies currently in the organization.
        """
        return pulumi.get(self, "policies")

    @_builtins.property
    @pulumi.getter(name="policyObjects")
    def policy_objects(self) -> _builtins.int:
        """
        Number of policy objects (with the adaptive policy type) currently in the organization.
        """
        return pulumi.get(self, "policy_objects")


@pulumi.output_type
class GetAdaptivePolicyOverviewItemLimitsResult(dict):
    def __init__(__self__, *,
                 acls_in_a_policy: _builtins.int,
                 custom_groups: _builtins.int,
                 policy_objects: _builtins.int,
                 rules_in_an_acl: _builtins.int):
        """
        :param _builtins.int acls_in_a_policy: Maximum number of adaptive policy ACLs that can be assigned to an adaptive policy in the organization.
        :param _builtins.int custom_groups: Maximum number of user-created adaptive policy groups allowed in the organization.
        :param _builtins.int policy_objects: Maximum number of policy objects (with the adaptive policy type) allowed in the organization.
        :param _builtins.int rules_in_an_acl: Maximum number of rules allowed in an adaptive policy ACL in the organization.
        """
        pulumi.set(__self__, "acls_in_a_policy", acls_in_a_policy)
        pulumi.set(__self__, "custom_groups", custom_groups)
        pulumi.set(__self__, "policy_objects", policy_objects)
        pulumi.set(__self__, "rules_in_an_acl", rules_in_an_acl)

    @_builtins.property
    @pulumi.getter(name="aclsInAPolicy")
    def acls_in_a_policy(self) -> _builtins.int:
        """
        Maximum number of adaptive policy ACLs that can be assigned to an adaptive policy in the organization.
        """
        return pulumi.get(self, "acls_in_a_policy")

    @_builtins.property
    @pulumi.getter(name="customGroups")
    def custom_groups(self) -> _builtins.int:
        """
        Maximum number of user-created adaptive policy groups allowed in the organization.
        """
        return pulumi.get(self, "custom_groups")

    @_builtins.property
    @pulumi.getter(name="policyObjects")
    def policy_objects(self) -> _builtins.int:
        """
        Maximum number of policy objects (with the adaptive policy type) allowed in the organization.
        """
        return pulumi.get(self, "policy_objects")

    @_builtins.property
    @pulumi.getter(name="rulesInAnAcl")
    def rules_in_an_acl(self) -> _builtins.int:
        """
        Maximum number of rules allowed in an adaptive policy ACL in the organization.
        """
        return pulumi.get(self, "rules_in_an_acl")


@pulumi.output_type
class GetAdaptivePolicyPoliciesItemResult(dict):
    def __init__(__self__, *,
                 acls: Sequence['outputs.GetAdaptivePolicyPoliciesItemAclResult'],
                 adaptive_policy_id: _builtins.str,
                 created_at: _builtins.str,
                 destination_group: 'outputs.GetAdaptivePolicyPoliciesItemDestinationGroupResult',
                 last_entry_rule: _builtins.str,
                 source_group: 'outputs.GetAdaptivePolicyPoliciesItemSourceGroupResult',
                 updated_at: _builtins.str):
        pulumi.set(__self__, "acls", acls)
        pulumi.set(__self__, "adaptive_policy_id", adaptive_policy_id)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "destination_group", destination_group)
        pulumi.set(__self__, "last_entry_rule", last_entry_rule)
        pulumi.set(__self__, "source_group", source_group)
        pulumi.set(__self__, "updated_at", updated_at)

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

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

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

    @_builtins.property
    @pulumi.getter(name="destinationGroup")
    def destination_group(self) -> 'outputs.GetAdaptivePolicyPoliciesItemDestinationGroupResult':
        return pulumi.get(self, "destination_group")

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

    @_builtins.property
    @pulumi.getter(name="sourceGroup")
    def source_group(self) -> 'outputs.GetAdaptivePolicyPoliciesItemSourceGroupResult':
        return pulumi.get(self, "source_group")

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


@pulumi.output_type
class GetAdaptivePolicyPoliciesItemAclResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetAdaptivePolicyPoliciesItemDestinationGroupResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str,
                 sgt: _builtins.int):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "sgt", sgt)

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

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

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


@pulumi.output_type
class GetAdaptivePolicyPoliciesItemSourceGroupResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str,
                 sgt: _builtins.int):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "sgt", sgt)

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

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

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


@pulumi.output_type
class GetAdaptivePolicySettingsItemResult(dict):
    def __init__(__self__, *,
                 enabled_networks: Sequence[_builtins.str]):
        pulumi.set(__self__, "enabled_networks", enabled_networks)

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


@pulumi.output_type
class GetAdminsItemResult(dict):
    def __init__(__self__, *,
                 account_status: _builtins.str,
                 authentication_method: _builtins.str,
                 email: _builtins.str,
                 has_api_key: _builtins.bool,
                 id: _builtins.str,
                 last_active: _builtins.str,
                 name: _builtins.str,
                 networks: Sequence['outputs.GetAdminsItemNetworkResult'],
                 org_access: _builtins.str,
                 tags: Sequence['outputs.GetAdminsItemTagResult'],
                 two_factor_auth_enabled: _builtins.bool):
        """
        :param _builtins.str account_status: Status of the admin's account
        :param _builtins.str authentication_method: Admin's authentication method
        :param _builtins.str email: Admin's email address
        :param _builtins.bool has_api_key: Indicates whether the admin has an API key
        :param _builtins.str id: Admin's ID
        :param _builtins.str last_active: Time when the admin was last active
        :param _builtins.str name: Admin's username
        :param Sequence['GetAdminsItemNetworkArgs'] networks: Admin network access information
        :param _builtins.str org_access: Admin's level of access to the organization
        :param Sequence['GetAdminsItemTagArgs'] tags: Admin tag information
        :param _builtins.bool two_factor_auth_enabled: Indicates whether two-factor authentication is enabled
        """
        pulumi.set(__self__, "account_status", account_status)
        pulumi.set(__self__, "authentication_method", authentication_method)
        pulumi.set(__self__, "email", email)
        pulumi.set(__self__, "has_api_key", has_api_key)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "last_active", last_active)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "networks", networks)
        pulumi.set(__self__, "org_access", org_access)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "two_factor_auth_enabled", two_factor_auth_enabled)

    @_builtins.property
    @pulumi.getter(name="accountStatus")
    def account_status(self) -> _builtins.str:
        """
        Status of the admin's account
        """
        return pulumi.get(self, "account_status")

    @_builtins.property
    @pulumi.getter(name="authenticationMethod")
    def authentication_method(self) -> _builtins.str:
        """
        Admin's authentication method
        """
        return pulumi.get(self, "authentication_method")

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

    @_builtins.property
    @pulumi.getter(name="hasApiKey")
    def has_api_key(self) -> _builtins.bool:
        """
        Indicates whether the admin has an API key
        """
        return pulumi.get(self, "has_api_key")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Admin's ID
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="lastActive")
    def last_active(self) -> _builtins.str:
        """
        Time when the admin was last active
        """
        return pulumi.get(self, "last_active")

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

    @_builtins.property
    @pulumi.getter
    def networks(self) -> Sequence['outputs.GetAdminsItemNetworkResult']:
        """
        Admin network access information
        """
        return pulumi.get(self, "networks")

    @_builtins.property
    @pulumi.getter(name="orgAccess")
    def org_access(self) -> _builtins.str:
        """
        Admin's level of access to the organization
        """
        return pulumi.get(self, "org_access")

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Sequence['outputs.GetAdminsItemTagResult']:
        """
        Admin tag information
        """
        return pulumi.get(self, "tags")

    @_builtins.property
    @pulumi.getter(name="twoFactorAuthEnabled")
    def two_factor_auth_enabled(self) -> _builtins.bool:
        """
        Indicates whether two-factor authentication is enabled
        """
        return pulumi.get(self, "two_factor_auth_enabled")


@pulumi.output_type
class GetAdminsItemNetworkResult(dict):
    def __init__(__self__, *,
                 access: _builtins.str,
                 id: _builtins.str):
        """
        :param _builtins.str access: Admin's level of access to the network
        :param _builtins.str id: Network ID
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def access(self) -> _builtins.str:
        """
        Admin's level of access to the network
        """
        return pulumi.get(self, "access")

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


@pulumi.output_type
class GetAdminsItemTagResult(dict):
    def __init__(__self__, *,
                 access: _builtins.str,
                 tag: _builtins.str):
        """
        :param _builtins.str access: Access level for the tag
        :param _builtins.str tag: Tag value
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "tag", tag)

    @_builtins.property
    @pulumi.getter
    def access(self) -> _builtins.str:
        """
        Access level for the tag
        """
        return pulumi.get(self, "access")

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


@pulumi.output_type
class GetAlertsProfilesItemResult(dict):
    def __init__(__self__, *,
                 alert_condition: 'outputs.GetAlertsProfilesItemAlertConditionResult',
                 description: _builtins.str,
                 enabled: _builtins.bool,
                 id: _builtins.str,
                 network_tags: Sequence[_builtins.str],
                 recipients: 'outputs.GetAlertsProfilesItemRecipientsResult',
                 type: _builtins.str):
        """
        :param 'GetAlertsProfilesItemAlertConditionArgs' alert_condition: The conditions that determine if the alert triggers
        :param _builtins.str description: User supplied description of the alert
        :param _builtins.bool enabled: Is the alert config enabled
        :param _builtins.str id: The alert config ID
        :param Sequence[_builtins.str] network_tags: Networks with these tags will be monitored for the alert
        :param 'GetAlertsProfilesItemRecipientsArgs' recipients: List of recipients that will recieve the alert.
        :param _builtins.str type: The alert type
        """
        pulumi.set(__self__, "alert_condition", alert_condition)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "network_tags", network_tags)
        pulumi.set(__self__, "recipients", recipients)
        pulumi.set(__self__, "type", type)

    @_builtins.property
    @pulumi.getter(name="alertCondition")
    def alert_condition(self) -> 'outputs.GetAlertsProfilesItemAlertConditionResult':
        """
        The conditions that determine if the alert triggers
        """
        return pulumi.get(self, "alert_condition")

    @_builtins.property
    @pulumi.getter
    def description(self) -> _builtins.str:
        """
        User supplied description of the alert
        """
        return pulumi.get(self, "description")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        The alert config ID
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="networkTags")
    def network_tags(self) -> Sequence[_builtins.str]:
        """
        Networks with these tags will be monitored for the alert
        """
        return pulumi.get(self, "network_tags")

    @_builtins.property
    @pulumi.getter
    def recipients(self) -> 'outputs.GetAlertsProfilesItemRecipientsResult':
        """
        List of recipients that will recieve the alert.
        """
        return pulumi.get(self, "recipients")

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


@pulumi.output_type
class GetAlertsProfilesItemAlertConditionResult(dict):
    def __init__(__self__, *,
                 bit_rate_bps: _builtins.int,
                 duration: _builtins.int,
                 interface: _builtins.str,
                 window: _builtins.int):
        """
        :param _builtins.int bit_rate_bps: The threshold the metric must cross to be valid for alerting. Used only for WAN Utilization alerts.
        :param _builtins.int duration: The total duration in seconds that the threshold should be crossed before alerting
        :param _builtins.str interface: The uplink observed for the alert
        :param _builtins.int window: The look back period in seconds for sensing the alert
        """
        pulumi.set(__self__, "bit_rate_bps", bit_rate_bps)
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "interface", interface)
        pulumi.set(__self__, "window", window)

    @_builtins.property
    @pulumi.getter(name="bitRateBps")
    def bit_rate_bps(self) -> _builtins.int:
        """
        The threshold the metric must cross to be valid for alerting. Used only for WAN Utilization alerts.
        """
        return pulumi.get(self, "bit_rate_bps")

    @_builtins.property
    @pulumi.getter
    def duration(self) -> _builtins.int:
        """
        The total duration in seconds that the threshold should be crossed before alerting
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def interface(self) -> _builtins.str:
        """
        The uplink observed for the alert
        """
        return pulumi.get(self, "interface")

    @_builtins.property
    @pulumi.getter
    def window(self) -> _builtins.int:
        """
        The look back period in seconds for sensing the alert
        """
        return pulumi.get(self, "window")


@pulumi.output_type
class GetAlertsProfilesItemRecipientsResult(dict):
    def __init__(__self__, *,
                 emails: Sequence[_builtins.str],
                 http_server_ids: Sequence[_builtins.str]):
        """
        :param Sequence[_builtins.str] emails: A list of emails that will receive information about the alert
        :param Sequence[_builtins.str] http_server_ids: A list base64 encoded urls of webhook endpoints that will receive information about the alert
        """
        pulumi.set(__self__, "emails", emails)
        pulumi.set(__self__, "http_server_ids", http_server_ids)

    @_builtins.property
    @pulumi.getter
    def emails(self) -> Sequence[_builtins.str]:
        """
        A list of emails that will receive information about the alert
        """
        return pulumi.get(self, "emails")

    @_builtins.property
    @pulumi.getter(name="httpServerIds")
    def http_server_ids(self) -> Sequence[_builtins.str]:
        """
        A list base64 encoded urls of webhook endpoints that will receive information about the alert
        """
        return pulumi.get(self, "http_server_ids")


@pulumi.output_type
class GetApiRequestsItemResult(dict):
    def __init__(__self__, *,
                 admin_id: _builtins.str,
                 host: _builtins.str,
                 method: _builtins.str,
                 operation_id: _builtins.str,
                 path: _builtins.str,
                 query_string: _builtins.str,
                 response_code: _builtins.int,
                 source_ip: _builtins.str,
                 ts: _builtins.str,
                 user_agent: _builtins.str,
                 version: _builtins.int):
        """
        :param _builtins.str admin_id: Database ID for the admin user who made the API request.
        :param _builtins.str host: The host which the API request was directed at.
        :param _builtins.str method: HTTP method used in the API request.
        :param _builtins.str operation_id: Operation ID for the endpoint.
        :param _builtins.str path: The API request path.
        :param _builtins.str query_string: The query string sent with the API request.
        :param _builtins.int response_code: API request response code.
        :param _builtins.str source_ip: Public IP address from which the API request was made.
        :param _builtins.str ts: Timestamp, in iso8601 format, indicating when the API request was made.
        :param _builtins.str user_agent: The API request user agent.
        :param _builtins.int version: API version of the endpoint.
        """
        pulumi.set(__self__, "admin_id", admin_id)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "method", method)
        pulumi.set(__self__, "operation_id", operation_id)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "query_string", query_string)
        pulumi.set(__self__, "response_code", response_code)
        pulumi.set(__self__, "source_ip", source_ip)
        pulumi.set(__self__, "ts", ts)
        pulumi.set(__self__, "user_agent", user_agent)
        pulumi.set(__self__, "version", version)

    @_builtins.property
    @pulumi.getter(name="adminId")
    def admin_id(self) -> _builtins.str:
        """
        Database ID for the admin user who made the API request.
        """
        return pulumi.get(self, "admin_id")

    @_builtins.property
    @pulumi.getter
    def host(self) -> _builtins.str:
        """
        The host which the API request was directed at.
        """
        return pulumi.get(self, "host")

    @_builtins.property
    @pulumi.getter
    def method(self) -> _builtins.str:
        """
        HTTP method used in the API request.
        """
        return pulumi.get(self, "method")

    @_builtins.property
    @pulumi.getter(name="operationId")
    def operation_id(self) -> _builtins.str:
        """
        Operation ID for the endpoint.
        """
        return pulumi.get(self, "operation_id")

    @_builtins.property
    @pulumi.getter
    def path(self) -> _builtins.str:
        """
        The API request path.
        """
        return pulumi.get(self, "path")

    @_builtins.property
    @pulumi.getter(name="queryString")
    def query_string(self) -> _builtins.str:
        """
        The query string sent with the API request.
        """
        return pulumi.get(self, "query_string")

    @_builtins.property
    @pulumi.getter(name="responseCode")
    def response_code(self) -> _builtins.int:
        """
        API request response code.
        """
        return pulumi.get(self, "response_code")

    @_builtins.property
    @pulumi.getter(name="sourceIp")
    def source_ip(self) -> _builtins.str:
        """
        Public IP address from which the API request was made.
        """
        return pulumi.get(self, "source_ip")

    @_builtins.property
    @pulumi.getter
    def ts(self) -> _builtins.str:
        """
        Timestamp, in iso8601 format, indicating when the API request was made.
        """
        return pulumi.get(self, "ts")

    @_builtins.property
    @pulumi.getter(name="userAgent")
    def user_agent(self) -> _builtins.str:
        """
        The API request user agent.
        """
        return pulumi.get(self, "user_agent")

    @_builtins.property
    @pulumi.getter
    def version(self) -> _builtins.int:
        """
        API version of the endpoint.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetApiRequestsOverviewItemResult(dict):
    def __init__(__self__, *,
                 response_code_counts: 'outputs.GetApiRequestsOverviewItemResponseCodeCountsResult'):
        """
        :param 'GetApiRequestsOverviewItemResponseCodeCountsArgs' response_code_counts: object of all supported HTTP response code
        """
        pulumi.set(__self__, "response_code_counts", response_code_counts)

    @_builtins.property
    @pulumi.getter(name="responseCodeCounts")
    def response_code_counts(self) -> 'outputs.GetApiRequestsOverviewItemResponseCodeCountsResult':
        """
        object of all supported HTTP response code
        """
        return pulumi.get(self, "response_code_counts")


@pulumi.output_type
class GetApiRequestsOverviewItemResponseCodeCountsResult(dict):
    def __init__(__self__, *,
                 status200: _builtins.int,
                 status201: _builtins.int,
                 status202: _builtins.int,
                 status203: _builtins.int,
                 status204: _builtins.int,
                 status205: _builtins.int,
                 status206: _builtins.int,
                 status207: _builtins.int,
                 status208: _builtins.int,
                 status226: _builtins.int,
                 status300: _builtins.int,
                 status301: _builtins.int,
                 status302: _builtins.int,
                 status303: _builtins.int,
                 status304: _builtins.int,
                 status305: _builtins.int,
                 status306: _builtins.int,
                 status307: _builtins.int,
                 status308: _builtins.int,
                 status400: _builtins.int,
                 status401: _builtins.int,
                 status402: _builtins.int,
                 status403: _builtins.int,
                 status404: _builtins.int,
                 status405: _builtins.int,
                 status406: _builtins.int,
                 status407: _builtins.int,
                 status408: _builtins.int,
                 status409: _builtins.int,
                 status410: _builtins.int,
                 status411: _builtins.int,
                 status412: _builtins.int,
                 status413: _builtins.int,
                 status414: _builtins.int,
                 status415: _builtins.int,
                 status416: _builtins.int,
                 status417: _builtins.int,
                 status421: _builtins.int,
                 status422: _builtins.int,
                 status423: _builtins.int,
                 status424: _builtins.int,
                 status425: _builtins.int,
                 status426: _builtins.int,
                 status428: _builtins.int,
                 status429: _builtins.int,
                 status431: _builtins.int,
                 status451: _builtins.int,
                 status500: _builtins.int,
                 status501: _builtins.int,
                 status502: _builtins.int,
                 status503: _builtins.int,
                 status504: _builtins.int,
                 status505: _builtins.int,
                 status506: _builtins.int,
                 status507: _builtins.int,
                 status508: _builtins.int,
                 status509: _builtins.int,
                 status510: _builtins.int,
                 status511: _builtins.int):
        """
        :param _builtins.int status200: HTTP 200 response code count.
        :param _builtins.int status201: HTTP 201 response code count.
        :param _builtins.int status202: HTTP 202 response code count.
        :param _builtins.int status203: HTTP 203 response code count.
        :param _builtins.int status204: HTTP 204 response code count.
        :param _builtins.int status205: HTTP 205 response code count.
        :param _builtins.int status206: HTTP 206 response code count.
        :param _builtins.int status207: HTTP 207 response code count.
        :param _builtins.int status208: HTTP 208 response code count.
        :param _builtins.int status226: HTTP 226 response code count.
        :param _builtins.int status300: HTTP 300 response code count.
        :param _builtins.int status301: HTTP 301 response code count.
        :param _builtins.int status302: HTTP 302 response code count.
        :param _builtins.int status303: HTTP 303 response code count.
        :param _builtins.int status304: HTTP 304 response code count.
        :param _builtins.int status305: HTTP 305 response code count.
        :param _builtins.int status306: HTTP 306 response code count.
        :param _builtins.int status307: HTTP 307 response code count.
        :param _builtins.int status308: HTTP 308 response code count.
        :param _builtins.int status400: HTTP 400 response code count.
        :param _builtins.int status401: HTTP 401 response code count.
        :param _builtins.int status402: HTTP 402 response code count.
        :param _builtins.int status403: HTTP 403 response code count.
        :param _builtins.int status404: HTTP 404 response code count.
        :param _builtins.int status405: HTTP 405 response code count.
        :param _builtins.int status406: HTTP 406 response code count.
        :param _builtins.int status407: HTTP 407 response code count.
        :param _builtins.int status408: HTTP 408 response code count.
        :param _builtins.int status409: HTTP 409 response code count.
        :param _builtins.int status410: HTTP 410 response code count.
        :param _builtins.int status411: HTTP 411 response code count.
        :param _builtins.int status412: HTTP 412 response code count.
        :param _builtins.int status413: HTTP 413 response code count.
        :param _builtins.int status414: HTTP 414 response code count.
        :param _builtins.int status415: HTTP 415 response code count.
        :param _builtins.int status416: HTTP 416 response code count.
        :param _builtins.int status417: HTTP 417 response code count.
        :param _builtins.int status421: HTTP 421 response code count.
        :param _builtins.int status422: HTTP 422 response code count.
        :param _builtins.int status423: HTTP 423 response code count.
        :param _builtins.int status424: HTTP 424 response code count.
        :param _builtins.int status425: HTTP 425 response code count.
        :param _builtins.int status426: HTTP 426 response code count.
        :param _builtins.int status428: HTTP 428 response code count.
        :param _builtins.int status429: HTTP 429 response code count.
        :param _builtins.int status431: HTTP 431 response code count.
        :param _builtins.int status451: HTTP 451 response code count.
        :param _builtins.int status500: HTTP 500 response code count.
        :param _builtins.int status501: HTTP 501 response code count.
        :param _builtins.int status502: HTTP 502 response code count.
        :param _builtins.int status503: HTTP 503 response code count.
        :param _builtins.int status504: HTTP 504 response code count.
        :param _builtins.int status505: HTTP 505 response code count.
        :param _builtins.int status506: HTTP 506 response code count.
        :param _builtins.int status507: HTTP 507 response code count.
        :param _builtins.int status508: HTTP 508 response code count.
        :param _builtins.int status509: HTTP 509 response code count.
        :param _builtins.int status510: HTTP 510 response code count.
        :param _builtins.int status511: HTTP 511 response code count.
        """
        pulumi.set(__self__, "status200", status200)
        pulumi.set(__self__, "status201", status201)
        pulumi.set(__self__, "status202", status202)
        pulumi.set(__self__, "status203", status203)
        pulumi.set(__self__, "status204", status204)
        pulumi.set(__self__, "status205", status205)
        pulumi.set(__self__, "status206", status206)
        pulumi.set(__self__, "status207", status207)
        pulumi.set(__self__, "status208", status208)
        pulumi.set(__self__, "status226", status226)
        pulumi.set(__self__, "status300", status300)
        pulumi.set(__self__, "status301", status301)
        pulumi.set(__self__, "status302", status302)
        pulumi.set(__self__, "status303", status303)
        pulumi.set(__self__, "status304", status304)
        pulumi.set(__self__, "status305", status305)
        pulumi.set(__self__, "status306", status306)
        pulumi.set(__self__, "status307", status307)
        pulumi.set(__self__, "status308", status308)
        pulumi.set(__self__, "status400", status400)
        pulumi.set(__self__, "status401", status401)
        pulumi.set(__self__, "status402", status402)
        pulumi.set(__self__, "status403", status403)
        pulumi.set(__self__, "status404", status404)
        pulumi.set(__self__, "status405", status405)
        pulumi.set(__self__, "status406", status406)
        pulumi.set(__self__, "status407", status407)
        pulumi.set(__self__, "status408", status408)
        pulumi.set(__self__, "status409", status409)
        pulumi.set(__self__, "status410", status410)
        pulumi.set(__self__, "status411", status411)
        pulumi.set(__self__, "status412", status412)
        pulumi.set(__self__, "status413", status413)
        pulumi.set(__self__, "status414", status414)
        pulumi.set(__self__, "status415", status415)
        pulumi.set(__self__, "status416", status416)
        pulumi.set(__self__, "status417", status417)
        pulumi.set(__self__, "status421", status421)
        pulumi.set(__self__, "status422", status422)
        pulumi.set(__self__, "status423", status423)
        pulumi.set(__self__, "status424", status424)
        pulumi.set(__self__, "status425", status425)
        pulumi.set(__self__, "status426", status426)
        pulumi.set(__self__, "status428", status428)
        pulumi.set(__self__, "status429", status429)
        pulumi.set(__self__, "status431", status431)
        pulumi.set(__self__, "status451", status451)
        pulumi.set(__self__, "status500", status500)
        pulumi.set(__self__, "status501", status501)
        pulumi.set(__self__, "status502", status502)
        pulumi.set(__self__, "status503", status503)
        pulumi.set(__self__, "status504", status504)
        pulumi.set(__self__, "status505", status505)
        pulumi.set(__self__, "status506", status506)
        pulumi.set(__self__, "status507", status507)
        pulumi.set(__self__, "status508", status508)
        pulumi.set(__self__, "status509", status509)
        pulumi.set(__self__, "status510", status510)
        pulumi.set(__self__, "status511", status511)

    @_builtins.property
    @pulumi.getter
    def status200(self) -> _builtins.int:
        """
        HTTP 200 response code count.
        """
        return pulumi.get(self, "status200")

    @_builtins.property
    @pulumi.getter
    def status201(self) -> _builtins.int:
        """
        HTTP 201 response code count.
        """
        return pulumi.get(self, "status201")

    @_builtins.property
    @pulumi.getter
    def status202(self) -> _builtins.int:
        """
        HTTP 202 response code count.
        """
        return pulumi.get(self, "status202")

    @_builtins.property
    @pulumi.getter
    def status203(self) -> _builtins.int:
        """
        HTTP 203 response code count.
        """
        return pulumi.get(self, "status203")

    @_builtins.property
    @pulumi.getter
    def status204(self) -> _builtins.int:
        """
        HTTP 204 response code count.
        """
        return pulumi.get(self, "status204")

    @_builtins.property
    @pulumi.getter
    def status205(self) -> _builtins.int:
        """
        HTTP 205 response code count.
        """
        return pulumi.get(self, "status205")

    @_builtins.property
    @pulumi.getter
    def status206(self) -> _builtins.int:
        """
        HTTP 206 response code count.
        """
        return pulumi.get(self, "status206")

    @_builtins.property
    @pulumi.getter
    def status207(self) -> _builtins.int:
        """
        HTTP 207 response code count.
        """
        return pulumi.get(self, "status207")

    @_builtins.property
    @pulumi.getter
    def status208(self) -> _builtins.int:
        """
        HTTP 208 response code count.
        """
        return pulumi.get(self, "status208")

    @_builtins.property
    @pulumi.getter
    def status226(self) -> _builtins.int:
        """
        HTTP 226 response code count.
        """
        return pulumi.get(self, "status226")

    @_builtins.property
    @pulumi.getter
    def status300(self) -> _builtins.int:
        """
        HTTP 300 response code count.
        """
        return pulumi.get(self, "status300")

    @_builtins.property
    @pulumi.getter
    def status301(self) -> _builtins.int:
        """
        HTTP 301 response code count.
        """
        return pulumi.get(self, "status301")

    @_builtins.property
    @pulumi.getter
    def status302(self) -> _builtins.int:
        """
        HTTP 302 response code count.
        """
        return pulumi.get(self, "status302")

    @_builtins.property
    @pulumi.getter
    def status303(self) -> _builtins.int:
        """
        HTTP 303 response code count.
        """
        return pulumi.get(self, "status303")

    @_builtins.property
    @pulumi.getter
    def status304(self) -> _builtins.int:
        """
        HTTP 304 response code count.
        """
        return pulumi.get(self, "status304")

    @_builtins.property
    @pulumi.getter
    def status305(self) -> _builtins.int:
        """
        HTTP 305 response code count.
        """
        return pulumi.get(self, "status305")

    @_builtins.property
    @pulumi.getter
    def status306(self) -> _builtins.int:
        """
        HTTP 306 response code count.
        """
        return pulumi.get(self, "status306")

    @_builtins.property
    @pulumi.getter
    def status307(self) -> _builtins.int:
        """
        HTTP 307 response code count.
        """
        return pulumi.get(self, "status307")

    @_builtins.property
    @pulumi.getter
    def status308(self) -> _builtins.int:
        """
        HTTP 308 response code count.
        """
        return pulumi.get(self, "status308")

    @_builtins.property
    @pulumi.getter
    def status400(self) -> _builtins.int:
        """
        HTTP 400 response code count.
        """
        return pulumi.get(self, "status400")

    @_builtins.property
    @pulumi.getter
    def status401(self) -> _builtins.int:
        """
        HTTP 401 response code count.
        """
        return pulumi.get(self, "status401")

    @_builtins.property
    @pulumi.getter
    def status402(self) -> _builtins.int:
        """
        HTTP 402 response code count.
        """
        return pulumi.get(self, "status402")

    @_builtins.property
    @pulumi.getter
    def status403(self) -> _builtins.int:
        """
        HTTP 403 response code count.
        """
        return pulumi.get(self, "status403")

    @_builtins.property
    @pulumi.getter
    def status404(self) -> _builtins.int:
        """
        HTTP 404 response code count.
        """
        return pulumi.get(self, "status404")

    @_builtins.property
    @pulumi.getter
    def status405(self) -> _builtins.int:
        """
        HTTP 405 response code count.
        """
        return pulumi.get(self, "status405")

    @_builtins.property
    @pulumi.getter
    def status406(self) -> _builtins.int:
        """
        HTTP 406 response code count.
        """
        return pulumi.get(self, "status406")

    @_builtins.property
    @pulumi.getter
    def status407(self) -> _builtins.int:
        """
        HTTP 407 response code count.
        """
        return pulumi.get(self, "status407")

    @_builtins.property
    @pulumi.getter
    def status408(self) -> _builtins.int:
        """
        HTTP 408 response code count.
        """
        return pulumi.get(self, "status408")

    @_builtins.property
    @pulumi.getter
    def status409(self) -> _builtins.int:
        """
        HTTP 409 response code count.
        """
        return pulumi.get(self, "status409")

    @_builtins.property
    @pulumi.getter
    def status410(self) -> _builtins.int:
        """
        HTTP 410 response code count.
        """
        return pulumi.get(self, "status410")

    @_builtins.property
    @pulumi.getter
    def status411(self) -> _builtins.int:
        """
        HTTP 411 response code count.
        """
        return pulumi.get(self, "status411")

    @_builtins.property
    @pulumi.getter
    def status412(self) -> _builtins.int:
        """
        HTTP 412 response code count.
        """
        return pulumi.get(self, "status412")

    @_builtins.property
    @pulumi.getter
    def status413(self) -> _builtins.int:
        """
        HTTP 413 response code count.
        """
        return pulumi.get(self, "status413")

    @_builtins.property
    @pulumi.getter
    def status414(self) -> _builtins.int:
        """
        HTTP 414 response code count.
        """
        return pulumi.get(self, "status414")

    @_builtins.property
    @pulumi.getter
    def status415(self) -> _builtins.int:
        """
        HTTP 415 response code count.
        """
        return pulumi.get(self, "status415")

    @_builtins.property
    @pulumi.getter
    def status416(self) -> _builtins.int:
        """
        HTTP 416 response code count.
        """
        return pulumi.get(self, "status416")

    @_builtins.property
    @pulumi.getter
    def status417(self) -> _builtins.int:
        """
        HTTP 417 response code count.
        """
        return pulumi.get(self, "status417")

    @_builtins.property
    @pulumi.getter
    def status421(self) -> _builtins.int:
        """
        HTTP 421 response code count.
        """
        return pulumi.get(self, "status421")

    @_builtins.property
    @pulumi.getter
    def status422(self) -> _builtins.int:
        """
        HTTP 422 response code count.
        """
        return pulumi.get(self, "status422")

    @_builtins.property
    @pulumi.getter
    def status423(self) -> _builtins.int:
        """
        HTTP 423 response code count.
        """
        return pulumi.get(self, "status423")

    @_builtins.property
    @pulumi.getter
    def status424(self) -> _builtins.int:
        """
        HTTP 424 response code count.
        """
        return pulumi.get(self, "status424")

    @_builtins.property
    @pulumi.getter
    def status425(self) -> _builtins.int:
        """
        HTTP 425 response code count.
        """
        return pulumi.get(self, "status425")

    @_builtins.property
    @pulumi.getter
    def status426(self) -> _builtins.int:
        """
        HTTP 426 response code count.
        """
        return pulumi.get(self, "status426")

    @_builtins.property
    @pulumi.getter
    def status428(self) -> _builtins.int:
        """
        HTTP 428 response code count.
        """
        return pulumi.get(self, "status428")

    @_builtins.property
    @pulumi.getter
    def status429(self) -> _builtins.int:
        """
        HTTP 429 response code count.
        """
        return pulumi.get(self, "status429")

    @_builtins.property
    @pulumi.getter
    def status431(self) -> _builtins.int:
        """
        HTTP 431 response code count.
        """
        return pulumi.get(self, "status431")

    @_builtins.property
    @pulumi.getter
    def status451(self) -> _builtins.int:
        """
        HTTP 451 response code count.
        """
        return pulumi.get(self, "status451")

    @_builtins.property
    @pulumi.getter
    def status500(self) -> _builtins.int:
        """
        HTTP 500 response code count.
        """
        return pulumi.get(self, "status500")

    @_builtins.property
    @pulumi.getter
    def status501(self) -> _builtins.int:
        """
        HTTP 501 response code count.
        """
        return pulumi.get(self, "status501")

    @_builtins.property
    @pulumi.getter
    def status502(self) -> _builtins.int:
        """
        HTTP 502 response code count.
        """
        return pulumi.get(self, "status502")

    @_builtins.property
    @pulumi.getter
    def status503(self) -> _builtins.int:
        """
        HTTP 503 response code count.
        """
        return pulumi.get(self, "status503")

    @_builtins.property
    @pulumi.getter
    def status504(self) -> _builtins.int:
        """
        HTTP 504 response code count.
        """
        return pulumi.get(self, "status504")

    @_builtins.property
    @pulumi.getter
    def status505(self) -> _builtins.int:
        """
        HTTP 505 response code count.
        """
        return pulumi.get(self, "status505")

    @_builtins.property
    @pulumi.getter
    def status506(self) -> _builtins.int:
        """
        HTTP 506 response code count.
        """
        return pulumi.get(self, "status506")

    @_builtins.property
    @pulumi.getter
    def status507(self) -> _builtins.int:
        """
        HTTP 507 response code count.
        """
        return pulumi.get(self, "status507")

    @_builtins.property
    @pulumi.getter
    def status508(self) -> _builtins.int:
        """
        HTTP 508 response code count.
        """
        return pulumi.get(self, "status508")

    @_builtins.property
    @pulumi.getter
    def status509(self) -> _builtins.int:
        """
        HTTP 509 response code count.
        """
        return pulumi.get(self, "status509")

    @_builtins.property
    @pulumi.getter
    def status510(self) -> _builtins.int:
        """
        HTTP 510 response code count.
        """
        return pulumi.get(self, "status510")

    @_builtins.property
    @pulumi.getter
    def status511(self) -> _builtins.int:
        """
        HTTP 511 response code count.
        """
        return pulumi.get(self, "status511")


@pulumi.output_type
class GetApiRequestsOverviewResponseCodesByIntervalItemResult(dict):
    def __init__(__self__, *,
                 counts: Sequence['outputs.GetApiRequestsOverviewResponseCodesByIntervalItemCountResult'],
                 end_ts: _builtins.str,
                 start_ts: _builtins.str):
        """
        :param Sequence['GetApiRequestsOverviewResponseCodesByIntervalItemCountArgs'] counts: list of response codes and a count of how many requests had that code in the given time period
        :param _builtins.str end_ts: The end time of the access period
        :param _builtins.str start_ts: The start time of the access period
        """
        pulumi.set(__self__, "counts", counts)
        pulumi.set(__self__, "end_ts", end_ts)
        pulumi.set(__self__, "start_ts", start_ts)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> Sequence['outputs.GetApiRequestsOverviewResponseCodesByIntervalItemCountResult']:
        """
        list of response codes and a count of how many requests had that code in the given time period
        """
        return pulumi.get(self, "counts")

    @_builtins.property
    @pulumi.getter(name="endTs")
    def end_ts(self) -> _builtins.str:
        """
        The end time of the access period
        """
        return pulumi.get(self, "end_ts")

    @_builtins.property
    @pulumi.getter(name="startTs")
    def start_ts(self) -> _builtins.str:
        """
        The start time of the access period
        """
        return pulumi.get(self, "start_ts")


@pulumi.output_type
class GetApiRequestsOverviewResponseCodesByIntervalItemCountResult(dict):
    def __init__(__self__, *,
                 code: _builtins.int,
                 count: _builtins.int):
        """
        :param _builtins.int code: Response status code of the API response
        :param _builtins.int count: Number of records that match the status code
        """
        pulumi.set(__self__, "code", code)
        pulumi.set(__self__, "count", count)

    @_builtins.property
    @pulumi.getter
    def code(self) -> _builtins.int:
        """
        Response status code of the API response
        """
        return pulumi.get(self, "code")

    @_builtins.property
    @pulumi.getter
    def count(self) -> _builtins.int:
        """
        Number of records that match the status code
        """
        return pulumi.get(self, "count")


@pulumi.output_type
class GetApplianceSecurityIntrusionItemResult(dict):
    def __init__(__self__, *,
                 allowed_rules: Sequence['outputs.GetApplianceSecurityIntrusionItemAllowedRuleResult']):
        pulumi.set(__self__, "allowed_rules", allowed_rules)

    @_builtins.property
    @pulumi.getter(name="allowedRules")
    def allowed_rules(self) -> Sequence['outputs.GetApplianceSecurityIntrusionItemAllowedRuleResult']:
        return pulumi.get(self, "allowed_rules")


@pulumi.output_type
class GetApplianceSecurityIntrusionItemAllowedRuleResult(dict):
    def __init__(__self__, *,
                 message: _builtins.str,
                 rule_id: _builtins.str):
        pulumi.set(__self__, "message", message)
        pulumi.set(__self__, "rule_id", rule_id)

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

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


@pulumi.output_type
class GetApplianceTrafficShapingVpnExclusionsByNetworkItemResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemResult']):
        """
        :param Sequence['GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemArgs'] items: VPN exclusion rules by network
        """
        pulumi.set(__self__, "items", items)

    @_builtins.property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemResult']:
        """
        VPN exclusion rules by network
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemResult(dict):
    def __init__(__self__, *,
                 customs: Sequence['outputs.GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemCustomResult'],
                 major_applications: Sequence['outputs.GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemMajorApplicationResult'],
                 network_id: _builtins.str,
                 network_name: _builtins.str):
        """
        :param Sequence['GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemCustomArgs'] customs: Custom VPN exclusion rules.
        :param Sequence['GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemMajorApplicationArgs'] major_applications: Major Application based VPN exclusion rules.
        :param _builtins.str network_id: ID of the network whose VPN exclusion rules are returned.
        :param _builtins.str network_name: Name of the network whose VPN exclusion rules are returned.
        """
        pulumi.set(__self__, "customs", customs)
        pulumi.set(__self__, "major_applications", major_applications)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "network_name", network_name)

    @_builtins.property
    @pulumi.getter
    def customs(self) -> Sequence['outputs.GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemCustomResult']:
        """
        Custom VPN exclusion rules.
        """
        return pulumi.get(self, "customs")

    @_builtins.property
    @pulumi.getter(name="majorApplications")
    def major_applications(self) -> Sequence['outputs.GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemMajorApplicationResult']:
        """
        Major Application based VPN exclusion rules.
        """
        return pulumi.get(self, "major_applications")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        ID of the network whose VPN exclusion rules are returned.
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="networkName")
    def network_name(self) -> _builtins.str:
        """
        Name of the network whose VPN exclusion rules are returned.
        """
        return pulumi.get(self, "network_name")


@pulumi.output_type
class GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemCustomResult(dict):
    def __init__(__self__, *,
                 destination: _builtins.str,
                 port: _builtins.str,
                 protocol: _builtins.str):
        """
        :param _builtins.str destination: Destination address; hostname required for DNS, IPv4 otherwise.
        :param _builtins.str port: Destination port.
        :param _builtins.str protocol: Protocol.
        """
        pulumi.set(__self__, "destination", destination)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

    @_builtins.property
    @pulumi.getter
    def destination(self) -> _builtins.str:
        """
        Destination address; hostname required for DNS, IPv4 otherwise.
        """
        return pulumi.get(self, "destination")

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

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


@pulumi.output_type
class GetApplianceTrafficShapingVpnExclusionsByNetworkItemItemMajorApplicationResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: Application's Meraki ID.
        :param _builtins.str name: Application's name.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Application's Meraki ID.
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetApplianceUplinksStatusesOverviewItemResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetApplianceUplinksStatusesOverviewItemCountsResult'):
        """
        :param 'GetApplianceUplinksStatusesOverviewItemCountsArgs' counts: counts
        """
        pulumi.set(__self__, "counts", counts)

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


@pulumi.output_type
class GetApplianceUplinksStatusesOverviewItemCountsResult(dict):
    def __init__(__self__, *,
                 by_status: 'outputs.GetApplianceUplinksStatusesOverviewItemCountsByStatusResult'):
        """
        :param 'GetApplianceUplinksStatusesOverviewItemCountsByStatusArgs' by_status: byStatus
        """
        pulumi.set(__self__, "by_status", by_status)

    @_builtins.property
    @pulumi.getter(name="byStatus")
    def by_status(self) -> 'outputs.GetApplianceUplinksStatusesOverviewItemCountsByStatusResult':
        """
        byStatus
        """
        return pulumi.get(self, "by_status")


@pulumi.output_type
class GetApplianceUplinksStatusesOverviewItemCountsByStatusResult(dict):
    def __init__(__self__, *,
                 active: _builtins.int,
                 connecting: _builtins.int,
                 failed: _builtins.int,
                 not_connected: _builtins.int,
                 ready: _builtins.int):
        """
        :param _builtins.int active: number of uplinks that are active and working
        :param _builtins.int connecting: number of uplinks currently connecting
        :param _builtins.int failed: number of uplinks that were working but have failed
        :param _builtins.int not_connected: number of uplinks currently where nothing is plugged in
        :param _builtins.int ready: number of uplinks that are working but on standby
        """
        pulumi.set(__self__, "active", active)
        pulumi.set(__self__, "connecting", connecting)
        pulumi.set(__self__, "failed", failed)
        pulumi.set(__self__, "not_connected", not_connected)
        pulumi.set(__self__, "ready", ready)

    @_builtins.property
    @pulumi.getter
    def active(self) -> _builtins.int:
        """
        number of uplinks that are active and working
        """
        return pulumi.get(self, "active")

    @_builtins.property
    @pulumi.getter
    def connecting(self) -> _builtins.int:
        """
        number of uplinks currently connecting
        """
        return pulumi.get(self, "connecting")

    @_builtins.property
    @pulumi.getter
    def failed(self) -> _builtins.int:
        """
        number of uplinks that were working but have failed
        """
        return pulumi.get(self, "failed")

    @_builtins.property
    @pulumi.getter(name="notConnected")
    def not_connected(self) -> _builtins.int:
        """
        number of uplinks currently where nothing is plugged in
        """
        return pulumi.get(self, "not_connected")

    @_builtins.property
    @pulumi.getter
    def ready(self) -> _builtins.int:
        """
        number of uplinks that are working but on standby
        """
        return pulumi.get(self, "ready")


@pulumi.output_type
class GetApplianceUplinksUsageByNetworkItemResult(dict):
    def __init__(__self__, *,
                 by_uplinks: Sequence['outputs.GetApplianceUplinksUsageByNetworkItemByUplinkResult'],
                 name: _builtins.str,
                 network_id: _builtins.str):
        """
        :param Sequence['GetApplianceUplinksUsageByNetworkItemByUplinkArgs'] by_uplinks: Uplink usage
        :param _builtins.str name: Network name
        :param _builtins.str network_id: Network identifier
        """
        pulumi.set(__self__, "by_uplinks", by_uplinks)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_id", network_id)

    @_builtins.property
    @pulumi.getter(name="byUplinks")
    def by_uplinks(self) -> Sequence['outputs.GetApplianceUplinksUsageByNetworkItemByUplinkResult']:
        """
        Uplink usage
        """
        return pulumi.get(self, "by_uplinks")

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

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        Network identifier
        """
        return pulumi.get(self, "network_id")


@pulumi.output_type
class GetApplianceUplinksUsageByNetworkItemByUplinkResult(dict):
    def __init__(__self__, *,
                 interface: _builtins.str,
                 received: _builtins.int,
                 sent: _builtins.int,
                 serial: _builtins.str):
        """
        :param _builtins.str interface: Uplink name
        :param _builtins.int received: Bytes received
        :param _builtins.int sent: Bytes sent
        :param _builtins.str serial: Uplink serial
        """
        pulumi.set(__self__, "interface", interface)
        pulumi.set(__self__, "received", received)
        pulumi.set(__self__, "sent", sent)
        pulumi.set(__self__, "serial", serial)

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

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

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

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


@pulumi.output_type
class GetApplianceVpnThirdPartyVpnpeersItemResult(dict):
    def __init__(__self__, *,
                 peers: Sequence['outputs.GetApplianceVpnThirdPartyVpnpeersItemPeerResult']):
        """
        :param Sequence['GetApplianceVpnThirdPartyVpnpeersItemPeerArgs'] peers: The list of VPN peers
        """
        pulumi.set(__self__, "peers", peers)

    @_builtins.property
    @pulumi.getter
    def peers(self) -> Sequence['outputs.GetApplianceVpnThirdPartyVpnpeersItemPeerResult']:
        """
        The list of VPN peers
        """
        return pulumi.get(self, "peers")


@pulumi.output_type
class GetApplianceVpnThirdPartyVpnpeersItemPeerResult(dict):
    def __init__(__self__, *,
                 ike_version: _builtins.str,
                 ipsec_policies: 'outputs.GetApplianceVpnThirdPartyVpnpeersItemPeerIpsecPoliciesResult',
                 ipsec_policies_preset: _builtins.str,
                 local_id: _builtins.str,
                 name: _builtins.str,
                 network_tags: Sequence[_builtins.str],
                 private_subnets: Sequence[_builtins.str],
                 public_ip: _builtins.str,
                 remote_id: _builtins.str,
                 secret: _builtins.str):
        """
        :param _builtins.str ike_version: [optional] The IKE version to be used for the IPsec VPN peer configuration. Defaults to '1' when omitted.
        :param 'GetApplianceVpnThirdPartyVpnpeersItemPeerIpsecPoliciesArgs' ipsec_policies: Custom IPSec policies for the VPN peer. If not included and a preset has not been chosen, the default preset for IPSec policies will be used.
        :param _builtins.str ipsec_policies_preset: One of the following available presets: 'default', 'aws', 'azure'. If this is provided, the 'ipsecPolicies' parameter is ignored.
        :param _builtins.str local_id: [optional] The local ID is used to identify the MX to the peer. This will apply to all MXs this peer applies to.
        :param _builtins.str name: The name of the VPN peer
        :param Sequence[_builtins.str] network_tags: A list of network tags that will connect with this peer. Use ['all'] for all networks. Use ['none'] for no networks. If not included, the default is ['all'].
        :param Sequence[_builtins.str] private_subnets: The list of the private subnets of the VPN peer
        :param _builtins.str public_ip: [optional] The public IP of the VPN peer
        :param _builtins.str remote_id: [optional] The remote ID is used to identify the connecting VPN peer. This can either be a valid IPv4 Address, FQDN or User FQDN.
        :param _builtins.str secret: The shared secret with the VPN peer
        """
        pulumi.set(__self__, "ike_version", ike_version)
        pulumi.set(__self__, "ipsec_policies", ipsec_policies)
        pulumi.set(__self__, "ipsec_policies_preset", ipsec_policies_preset)
        pulumi.set(__self__, "local_id", local_id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_tags", network_tags)
        pulumi.set(__self__, "private_subnets", private_subnets)
        pulumi.set(__self__, "public_ip", public_ip)
        pulumi.set(__self__, "remote_id", remote_id)
        pulumi.set(__self__, "secret", secret)

    @_builtins.property
    @pulumi.getter(name="ikeVersion")
    def ike_version(self) -> _builtins.str:
        """
        [optional] The IKE version to be used for the IPsec VPN peer configuration. Defaults to '1' when omitted.
        """
        return pulumi.get(self, "ike_version")

    @_builtins.property
    @pulumi.getter(name="ipsecPolicies")
    def ipsec_policies(self) -> 'outputs.GetApplianceVpnThirdPartyVpnpeersItemPeerIpsecPoliciesResult':
        """
        Custom IPSec policies for the VPN peer. If not included and a preset has not been chosen, the default preset for IPSec policies will be used.
        """
        return pulumi.get(self, "ipsec_policies")

    @_builtins.property
    @pulumi.getter(name="ipsecPoliciesPreset")
    def ipsec_policies_preset(self) -> _builtins.str:
        """
        One of the following available presets: 'default', 'aws', 'azure'. If this is provided, the 'ipsecPolicies' parameter is ignored.
        """
        return pulumi.get(self, "ipsec_policies_preset")

    @_builtins.property
    @pulumi.getter(name="localId")
    def local_id(self) -> _builtins.str:
        """
        [optional] The local ID is used to identify the MX to the peer. This will apply to all MXs this peer applies to.
        """
        return pulumi.get(self, "local_id")

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

    @_builtins.property
    @pulumi.getter(name="networkTags")
    def network_tags(self) -> Sequence[_builtins.str]:
        """
        A list of network tags that will connect with this peer. Use ['all'] for all networks. Use ['none'] for no networks. If not included, the default is ['all'].
        """
        return pulumi.get(self, "network_tags")

    @_builtins.property
    @pulumi.getter(name="privateSubnets")
    def private_subnets(self) -> Sequence[_builtins.str]:
        """
        The list of the private subnets of the VPN peer
        """
        return pulumi.get(self, "private_subnets")

    @_builtins.property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> _builtins.str:
        """
        [optional] The public IP of the VPN peer
        """
        return pulumi.get(self, "public_ip")

    @_builtins.property
    @pulumi.getter(name="remoteId")
    def remote_id(self) -> _builtins.str:
        """
        [optional] The remote ID is used to identify the connecting VPN peer. This can either be a valid IPv4 Address, FQDN or User FQDN.
        """
        return pulumi.get(self, "remote_id")

    @_builtins.property
    @pulumi.getter
    def secret(self) -> _builtins.str:
        """
        The shared secret with the VPN peer
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetApplianceVpnThirdPartyVpnpeersItemPeerIpsecPoliciesResult(dict):
    def __init__(__self__, *,
                 child_auth_algos: Sequence[_builtins.str],
                 child_cipher_algos: Sequence[_builtins.str],
                 child_lifetime: _builtins.int,
                 child_pfs_groups: Sequence[_builtins.str],
                 ike_auth_algos: Sequence[_builtins.str],
                 ike_cipher_algos: Sequence[_builtins.str],
                 ike_diffie_hellman_groups: Sequence[_builtins.str],
                 ike_lifetime: _builtins.int,
                 ike_prf_algos: Sequence[_builtins.str]):
        """
        :param Sequence[_builtins.str] child_auth_algos: This is the authentication algorithms to be used in Phase 2. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        :param Sequence[_builtins.str] child_cipher_algos: This is the cipher algorithms to be used in Phase 2. The value should be an array with one or more of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des', 'null'
        :param _builtins.int child_lifetime: The lifetime of the Phase 2 SA in seconds.
        :param Sequence[_builtins.str] child_pfs_groups: This is the Diffie-Hellman group to be used for Perfect Forward Secrecy in Phase 2. The value should be an array with one of the following values: 'disabled','group14', 'group5', 'group2', 'group1'
        :param Sequence[_builtins.str] ike_auth_algos: This is the authentication algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        :param Sequence[_builtins.str] ike_cipher_algos: This is the cipher algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des'
        :param Sequence[_builtins.str] ike_diffie_hellman_groups: This is the Diffie-Hellman group to be used in Phase 1. The value should be an array with one of the following algorithms: 'group14', 'group5', 'group2', 'group1'
        :param _builtins.int ike_lifetime: The lifetime of the Phase 1 SA in seconds.
        :param Sequence[_builtins.str] ike_prf_algos: [optional] This is the pseudo-random function to be used in IKE_SA. The value should be an array with one of the following algorithms: 'prfsha256', 'prfsha1', 'prfmd5', 'default'. The 'default' option can be used to default to the Authentication algorithm.
        """
        pulumi.set(__self__, "child_auth_algos", child_auth_algos)
        pulumi.set(__self__, "child_cipher_algos", child_cipher_algos)
        pulumi.set(__self__, "child_lifetime", child_lifetime)
        pulumi.set(__self__, "child_pfs_groups", child_pfs_groups)
        pulumi.set(__self__, "ike_auth_algos", ike_auth_algos)
        pulumi.set(__self__, "ike_cipher_algos", ike_cipher_algos)
        pulumi.set(__self__, "ike_diffie_hellman_groups", ike_diffie_hellman_groups)
        pulumi.set(__self__, "ike_lifetime", ike_lifetime)
        pulumi.set(__self__, "ike_prf_algos", ike_prf_algos)

    @_builtins.property
    @pulumi.getter(name="childAuthAlgos")
    def child_auth_algos(self) -> Sequence[_builtins.str]:
        """
        This is the authentication algorithms to be used in Phase 2. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        """
        return pulumi.get(self, "child_auth_algos")

    @_builtins.property
    @pulumi.getter(name="childCipherAlgos")
    def child_cipher_algos(self) -> Sequence[_builtins.str]:
        """
        This is the cipher algorithms to be used in Phase 2. The value should be an array with one or more of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des', 'null'
        """
        return pulumi.get(self, "child_cipher_algos")

    @_builtins.property
    @pulumi.getter(name="childLifetime")
    def child_lifetime(self) -> _builtins.int:
        """
        The lifetime of the Phase 2 SA in seconds.
        """
        return pulumi.get(self, "child_lifetime")

    @_builtins.property
    @pulumi.getter(name="childPfsGroups")
    def child_pfs_groups(self) -> Sequence[_builtins.str]:
        """
        This is the Diffie-Hellman group to be used for Perfect Forward Secrecy in Phase 2. The value should be an array with one of the following values: 'disabled','group14', 'group5', 'group2', 'group1'
        """
        return pulumi.get(self, "child_pfs_groups")

    @_builtins.property
    @pulumi.getter(name="ikeAuthAlgos")
    def ike_auth_algos(self) -> Sequence[_builtins.str]:
        """
        This is the authentication algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'sha256', 'sha1', 'md5'
        """
        return pulumi.get(self, "ike_auth_algos")

    @_builtins.property
    @pulumi.getter(name="ikeCipherAlgos")
    def ike_cipher_algos(self) -> Sequence[_builtins.str]:
        """
        This is the cipher algorithm to be used in Phase 1. The value should be an array with one of the following algorithms: 'aes256', 'aes192', 'aes128', 'tripledes', 'des'
        """
        return pulumi.get(self, "ike_cipher_algos")

    @_builtins.property
    @pulumi.getter(name="ikeDiffieHellmanGroups")
    def ike_diffie_hellman_groups(self) -> Sequence[_builtins.str]:
        """
        This is the Diffie-Hellman group to be used in Phase 1. The value should be an array with one of the following algorithms: 'group14', 'group5', 'group2', 'group1'
        """
        return pulumi.get(self, "ike_diffie_hellman_groups")

    @_builtins.property
    @pulumi.getter(name="ikeLifetime")
    def ike_lifetime(self) -> _builtins.int:
        """
        The lifetime of the Phase 1 SA in seconds.
        """
        return pulumi.get(self, "ike_lifetime")

    @_builtins.property
    @pulumi.getter(name="ikePrfAlgos")
    def ike_prf_algos(self) -> Sequence[_builtins.str]:
        """
        [optional] This is the pseudo-random function to be used in IKE_SA. The value should be an array with one of the following algorithms: 'prfsha256', 'prfsha1', 'prfmd5', 'default'. The 'default' option can be used to default to the Authentication algorithm.
        """
        return pulumi.get(self, "ike_prf_algos")


@pulumi.output_type
class GetApplianceVpnVpnFirewallRulesItemResult(dict):
    def __init__(__self__, *,
                 rules: Sequence['outputs.GetApplianceVpnVpnFirewallRulesItemRuleResult']):
        """
        :param Sequence['GetApplianceVpnVpnFirewallRulesItemRuleArgs'] rules: An ordered array of the firewall rules (not including the default rule)
        """
        pulumi.set(__self__, "rules", rules)

    @_builtins.property
    @pulumi.getter
    def rules(self) -> Sequence['outputs.GetApplianceVpnVpnFirewallRulesItemRuleResult']:
        """
        An ordered array of the firewall rules (not including the default rule)
        """
        return pulumi.get(self, "rules")


@pulumi.output_type
class GetApplianceVpnVpnFirewallRulesItemRuleResult(dict):
    def __init__(__self__, *,
                 comment: _builtins.str,
                 dest_cidr: _builtins.str,
                 dest_port: _builtins.str,
                 policy: _builtins.str,
                 protocol: _builtins.str,
                 src_cidr: _builtins.str,
                 src_port: _builtins.str,
                 syslog_enabled: _builtins.bool):
        """
        :param _builtins.str comment: Description of the rule (optional)
        :param _builtins.str dest_cidr: Comma-separated list of destination IP address(es) (in IP or CIDR notation), fully-qualified domain names (FQDN) or 'any'
        :param _builtins.str dest_port: Comma-separated list of destination port(s) (integer in the range 1-65535), or 'any'
        :param _builtins.str policy: 'allow' or 'deny' traffic specified by this rule
        :param _builtins.str protocol: The type of protocol (must be 'tcp', 'udp', 'icmp', 'icmp6' or 'any')
        :param _builtins.str src_cidr: Comma-separated list of source IP address(es) (in IP or CIDR notation), or 'any' (note: FQDN not supported for source addresses)
        :param _builtins.str src_port: Comma-separated list of source port(s) (integer in the range 1-65535), or 'any'
        :param _builtins.bool syslog_enabled: Log this rule to syslog (true or false, boolean value) - only applicable if a syslog has been configured (optional)
        """
        pulumi.set(__self__, "comment", comment)
        pulumi.set(__self__, "dest_cidr", dest_cidr)
        pulumi.set(__self__, "dest_port", dest_port)
        pulumi.set(__self__, "policy", policy)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "src_cidr", src_cidr)
        pulumi.set(__self__, "src_port", src_port)
        pulumi.set(__self__, "syslog_enabled", syslog_enabled)

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

    @_builtins.property
    @pulumi.getter(name="destCidr")
    def dest_cidr(self) -> _builtins.str:
        """
        Comma-separated list of destination IP address(es) (in IP or CIDR notation), fully-qualified domain names (FQDN) or 'any'
        """
        return pulumi.get(self, "dest_cidr")

    @_builtins.property
    @pulumi.getter(name="destPort")
    def dest_port(self) -> _builtins.str:
        """
        Comma-separated list of destination port(s) (integer in the range 1-65535), or 'any'
        """
        return pulumi.get(self, "dest_port")

    @_builtins.property
    @pulumi.getter
    def policy(self) -> _builtins.str:
        """
        'allow' or 'deny' traffic specified by this rule
        """
        return pulumi.get(self, "policy")

    @_builtins.property
    @pulumi.getter
    def protocol(self) -> _builtins.str:
        """
        The type of protocol (must be 'tcp', 'udp', 'icmp', 'icmp6' or 'any')
        """
        return pulumi.get(self, "protocol")

    @_builtins.property
    @pulumi.getter(name="srcCidr")
    def src_cidr(self) -> _builtins.str:
        """
        Comma-separated list of source IP address(es) (in IP or CIDR notation), or 'any' (note: FQDN not supported for source addresses)
        """
        return pulumi.get(self, "src_cidr")

    @_builtins.property
    @pulumi.getter(name="srcPort")
    def src_port(self) -> _builtins.str:
        """
        Comma-separated list of source port(s) (integer in the range 1-65535), or 'any'
        """
        return pulumi.get(self, "src_port")

    @_builtins.property
    @pulumi.getter(name="syslogEnabled")
    def syslog_enabled(self) -> _builtins.bool:
        """
        Log this rule to syslog (true or false, boolean value) - only applicable if a syslog has been configured (optional)
        """
        return pulumi.get(self, "syslog_enabled")


@pulumi.output_type
class GetBrandingPoliciesItemResult(dict):
    def __init__(__self__, *,
                 admin_settings: 'outputs.GetBrandingPoliciesItemAdminSettingsResult',
                 custom_logo: 'outputs.GetBrandingPoliciesItemCustomLogoResult',
                 enabled: _builtins.bool,
                 help_settings: 'outputs.GetBrandingPoliciesItemHelpSettingsResult',
                 name: _builtins.str):
        """
        :param 'GetBrandingPoliciesItemAdminSettingsArgs' admin_settings: Settings for describing which kinds of admins this policy applies to.
        :param 'GetBrandingPoliciesItemCustomLogoArgs' custom_logo: Properties describing the custom logo attached to the branding policy.
        :param _builtins.bool enabled: Boolean indicating whether this policy is enabled.
        :param 'GetBrandingPoliciesItemHelpSettingsArgs' help_settings: Settings for describing the modifications to various Help page features. Each property in this object accepts one of
                 'default or inherit' (do not modify functionality), 'hide' (remove the section from Dashboard), or 'show' (always show
                 the section on Dashboard). Some properties in this object also accept custom HTML used to replace the section on
                 Dashboard; see the documentation for each property to see the allowed values.
        :param _builtins.str name: Name of the Dashboard branding policy.
        """
        pulumi.set(__self__, "admin_settings", admin_settings)
        pulumi.set(__self__, "custom_logo", custom_logo)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "help_settings", help_settings)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter(name="adminSettings")
    def admin_settings(self) -> 'outputs.GetBrandingPoliciesItemAdminSettingsResult':
        """
        Settings for describing which kinds of admins this policy applies to.
        """
        return pulumi.get(self, "admin_settings")

    @_builtins.property
    @pulumi.getter(name="customLogo")
    def custom_logo(self) -> 'outputs.GetBrandingPoliciesItemCustomLogoResult':
        """
        Properties describing the custom logo attached to the branding policy.
        """
        return pulumi.get(self, "custom_logo")

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Boolean indicating whether this policy is enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter(name="helpSettings")
    def help_settings(self) -> 'outputs.GetBrandingPoliciesItemHelpSettingsResult':
        """
        Settings for describing the modifications to various Help page features. Each property in this object accepts one of
          'default or inherit' (do not modify functionality), 'hide' (remove the section from Dashboard), or 'show' (always show
          the section on Dashboard). Some properties in this object also accept custom HTML used to replace the section on
          Dashboard; see the documentation for each property to see the allowed values.
        """
        return pulumi.get(self, "help_settings")

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


@pulumi.output_type
class GetBrandingPoliciesItemAdminSettingsResult(dict):
    def __init__(__self__, *,
                 applies_to: _builtins.str,
                 values: Sequence[_builtins.str]):
        """
        :param _builtins.str applies_to: Which kinds of admins this policy applies to. Can be one of 'All organization admins', 'All enterprise admins', 'All network admins', 'All admins of networks...', 'All admins of networks tagged...', 'Specific admins...', 'All admins' or 'All SAML admins'.
        :param Sequence[_builtins.str] values: If 'appliesTo' is set to one of 'Specific admins...', 'All admins of networks...' or 'All admins of networks tagged...', then you must specify this 'values' property to provide the set of
                 entities to apply the branding policy to. For 'Specific admins...', specify an array of admin IDs. For 'All admins of
                 networks...', specify an array of network IDs and/or configuration template IDs. For 'All admins of networks tagged...',
                 specify an array of tag names.
        """
        pulumi.set(__self__, "applies_to", applies_to)
        pulumi.set(__self__, "values", values)

    @_builtins.property
    @pulumi.getter(name="appliesTo")
    def applies_to(self) -> _builtins.str:
        """
        Which kinds of admins this policy applies to. Can be one of 'All organization admins', 'All enterprise admins', 'All network admins', 'All admins of networks...', 'All admins of networks tagged...', 'Specific admins...', 'All admins' or 'All SAML admins'.
        """
        return pulumi.get(self, "applies_to")

    @_builtins.property
    @pulumi.getter
    def values(self) -> Sequence[_builtins.str]:
        """
        If 'appliesTo' is set to one of 'Specific admins...', 'All admins of networks...' or 'All admins of networks tagged...', then you must specify this 'values' property to provide the set of
          entities to apply the branding policy to. For 'Specific admins...', specify an array of admin IDs. For 'All admins of
          networks...', specify an array of network IDs and/or configuration template IDs. For 'All admins of networks tagged...',
          specify an array of tag names.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetBrandingPoliciesItemCustomLogoResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 image: 'outputs.GetBrandingPoliciesItemCustomLogoImageResult'):
        """
        :param _builtins.bool enabled: Whether or not there is a custom logo enabled.
        :param 'GetBrandingPoliciesItemCustomLogoImageArgs' image: Properties of the image.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "image", image)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Whether or not there is a custom logo enabled.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def image(self) -> 'outputs.GetBrandingPoliciesItemCustomLogoImageResult':
        """
        Properties of the image.
        """
        return pulumi.get(self, "image")


@pulumi.output_type
class GetBrandingPoliciesItemCustomLogoImageResult(dict):
    def __init__(__self__, *,
                 preview: 'outputs.GetBrandingPoliciesItemCustomLogoImagePreviewResult'):
        """
        :param 'GetBrandingPoliciesItemCustomLogoImagePreviewArgs' preview: Preview of the image
        """
        pulumi.set(__self__, "preview", preview)

    @_builtins.property
    @pulumi.getter
    def preview(self) -> 'outputs.GetBrandingPoliciesItemCustomLogoImagePreviewResult':
        """
        Preview of the image
        """
        return pulumi.get(self, "preview")


@pulumi.output_type
class GetBrandingPoliciesItemCustomLogoImagePreviewResult(dict):
    def __init__(__self__, *,
                 expires_at: _builtins.str,
                 url: _builtins.str):
        """
        :param _builtins.str expires_at: Timestamp of the preview image
        :param _builtins.str url: Url of the preview image
        """
        pulumi.set(__self__, "expires_at", expires_at)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="expiresAt")
    def expires_at(self) -> _builtins.str:
        """
        Timestamp of the preview image
        """
        return pulumi.get(self, "expires_at")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        Url of the preview image
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetBrandingPoliciesItemHelpSettingsResult(dict):
    def __init__(__self__, *,
                 api_docs_subtab: _builtins.str,
                 cases_subtab: _builtins.str,
                 cisco_meraki_product_documentation: _builtins.str,
                 community_subtab: _builtins.str,
                 data_protection_requests_subtab: _builtins.str,
                 firewall_info_subtab: _builtins.str,
                 get_help_subtab: _builtins.str,
                 get_help_subtab_knowledge_base_search: _builtins.str,
                 hardware_replacements_subtab: _builtins.str,
                 help_tab: _builtins.str,
                 help_widget: _builtins.str,
                 new_features_subtab: _builtins.str,
                 sm_forums: _builtins.str,
                 support_contact_info: _builtins.str,
                 universal_search_knowledge_base_search: _builtins.str):
        """
        :param _builtins.str api_docs_subtab: The 'Help > API docs' subtab where a detailed description of the Dashboard API is listed. Can be one of
                 'default or inherit', 'hide' or 'show'.
        :param _builtins.str cases_subtab: The 'Help > Cases' Dashboard subtab on which Cisco Meraki support cases for this organization can be managed. Can be one
                 of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str cisco_meraki_product_documentation: The 'Product Manuals' section of the 'Help > Get Help' subtab. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        :param _builtins.str community_subtab: The 'Help > Community' subtab which provides a link to Meraki Community. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str data_protection_requests_subtab: The 'Help > Data protection requests' Dashboard subtab on which requests to delete, restrict, or export end-user data can
                 be audited. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str firewall_info_subtab: The 'Help > Firewall info' subtab where necessary upstream firewall rules for communication to the Cisco Meraki cloud are
                 listed. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str get_help_subtab: The 'Help > Get Help' subtab on which Cisco Meraki KB, Product Manuals, and Support/Case Information are displayed. Note
                 that if this subtab is hidden, branding customizations for the KB on 'Get help', Cisco Meraki product documentation,
                 and support contact info will not be visible. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str get_help_subtab_knowledge_base_search: The KB search box which appears on the Help page. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        :param _builtins.str hardware_replacements_subtab: The 'Help > Replacement info' subtab where important information regarding device replacements is detailed. Can be one of
                 'default or inherit', 'hide' or 'show'.
        :param _builtins.str help_tab: The Help tab, under which all support information resides. If this tab is hidden, no other 'Help' branding
                 customizations will be visible. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str help_widget: The 'Help Widget' is a support widget which provides access to live chat, documentation links, Sales contact info,
                 and other contact avenues to reach Meraki Support. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str new_features_subtab: The 'Help > New features' subtab where new Dashboard features are detailed. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str sm_forums: The 'SM Forums' subtab which links to community-based support for Cisco Meraki Systems Manager. Only configurable for
                 organizations that contain Systems Manager networks. Can be one of 'default or inherit', 'hide' or 'show'.
        :param _builtins.str support_contact_info: The 'Contact Meraki Support' section of the 'Help > Get Help' subtab. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        :param _builtins.str universal_search_knowledge_base_search: The universal search box always visible on Dashboard will, by default, present results from the Meraki KB. This configures
                 whether these Meraki KB results should be returned. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        pulumi.set(__self__, "api_docs_subtab", api_docs_subtab)
        pulumi.set(__self__, "cases_subtab", cases_subtab)
        pulumi.set(__self__, "cisco_meraki_product_documentation", cisco_meraki_product_documentation)
        pulumi.set(__self__, "community_subtab", community_subtab)
        pulumi.set(__self__, "data_protection_requests_subtab", data_protection_requests_subtab)
        pulumi.set(__self__, "firewall_info_subtab", firewall_info_subtab)
        pulumi.set(__self__, "get_help_subtab", get_help_subtab)
        pulumi.set(__self__, "get_help_subtab_knowledge_base_search", get_help_subtab_knowledge_base_search)
        pulumi.set(__self__, "hardware_replacements_subtab", hardware_replacements_subtab)
        pulumi.set(__self__, "help_tab", help_tab)
        pulumi.set(__self__, "help_widget", help_widget)
        pulumi.set(__self__, "new_features_subtab", new_features_subtab)
        pulumi.set(__self__, "sm_forums", sm_forums)
        pulumi.set(__self__, "support_contact_info", support_contact_info)
        pulumi.set(__self__, "universal_search_knowledge_base_search", universal_search_knowledge_base_search)

    @_builtins.property
    @pulumi.getter(name="apiDocsSubtab")
    def api_docs_subtab(self) -> _builtins.str:
        """
        The 'Help > API docs' subtab where a detailed description of the Dashboard API is listed. Can be one of
          'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "api_docs_subtab")

    @_builtins.property
    @pulumi.getter(name="casesSubtab")
    def cases_subtab(self) -> _builtins.str:
        """
        The 'Help > Cases' Dashboard subtab on which Cisco Meraki support cases for this organization can be managed. Can be one
          of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "cases_subtab")

    @_builtins.property
    @pulumi.getter(name="ciscoMerakiProductDocumentation")
    def cisco_meraki_product_documentation(self) -> _builtins.str:
        """
        The 'Product Manuals' section of the 'Help > Get Help' subtab. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        """
        return pulumi.get(self, "cisco_meraki_product_documentation")

    @_builtins.property
    @pulumi.getter(name="communitySubtab")
    def community_subtab(self) -> _builtins.str:
        """
        The 'Help > Community' subtab which provides a link to Meraki Community. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "community_subtab")

    @_builtins.property
    @pulumi.getter(name="dataProtectionRequestsSubtab")
    def data_protection_requests_subtab(self) -> _builtins.str:
        """
        The 'Help > Data protection requests' Dashboard subtab on which requests to delete, restrict, or export end-user data can
          be audited. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "data_protection_requests_subtab")

    @_builtins.property
    @pulumi.getter(name="firewallInfoSubtab")
    def firewall_info_subtab(self) -> _builtins.str:
        """
        The 'Help > Firewall info' subtab where necessary upstream firewall rules for communication to the Cisco Meraki cloud are
          listed. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "firewall_info_subtab")

    @_builtins.property
    @pulumi.getter(name="getHelpSubtab")
    def get_help_subtab(self) -> _builtins.str:
        """
        The 'Help > Get Help' subtab on which Cisco Meraki KB, Product Manuals, and Support/Case Information are displayed. Note
          that if this subtab is hidden, branding customizations for the KB on 'Get help', Cisco Meraki product documentation,
          and support contact info will not be visible. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "get_help_subtab")

    @_builtins.property
    @pulumi.getter(name="getHelpSubtabKnowledgeBaseSearch")
    def get_help_subtab_knowledge_base_search(self) -> _builtins.str:
        """
        The KB search box which appears on the Help page. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        """
        return pulumi.get(self, "get_help_subtab_knowledge_base_search")

    @_builtins.property
    @pulumi.getter(name="hardwareReplacementsSubtab")
    def hardware_replacements_subtab(self) -> _builtins.str:
        """
        The 'Help > Replacement info' subtab where important information regarding device replacements is detailed. Can be one of
          'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "hardware_replacements_subtab")

    @_builtins.property
    @pulumi.getter(name="helpTab")
    def help_tab(self) -> _builtins.str:
        """
        The Help tab, under which all support information resides. If this tab is hidden, no other 'Help' branding
          customizations will be visible. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "help_tab")

    @_builtins.property
    @pulumi.getter(name="helpWidget")
    def help_widget(self) -> _builtins.str:
        """
        The 'Help Widget' is a support widget which provides access to live chat, documentation links, Sales contact info,
          and other contact avenues to reach Meraki Support. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "help_widget")

    @_builtins.property
    @pulumi.getter(name="newFeaturesSubtab")
    def new_features_subtab(self) -> _builtins.str:
        """
        The 'Help > New features' subtab where new Dashboard features are detailed. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "new_features_subtab")

    @_builtins.property
    @pulumi.getter(name="smForums")
    def sm_forums(self) -> _builtins.str:
        """
        The 'SM Forums' subtab which links to community-based support for Cisco Meraki Systems Manager. Only configurable for
          organizations that contain Systems Manager networks. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "sm_forums")

    @_builtins.property
    @pulumi.getter(name="supportContactInfo")
    def support_contact_info(self) -> _builtins.str:
        """
        The 'Contact Meraki Support' section of the 'Help > Get Help' subtab. Can be one of 'default or inherit', 'hide', 'show', or a replacement custom HTML string.
        """
        return pulumi.get(self, "support_contact_info")

    @_builtins.property
    @pulumi.getter(name="universalSearchKnowledgeBaseSearch")
    def universal_search_knowledge_base_search(self) -> _builtins.str:
        """
        The universal search box always visible on Dashboard will, by default, present results from the Meraki KB. This configures
          whether these Meraki KB results should be returned. Can be one of 'default or inherit', 'hide' or 'show'.
        """
        return pulumi.get(self, "universal_search_knowledge_base_search")


@pulumi.output_type
class GetBrandingPoliciesPrioritiesItemResult(dict):
    def __init__(__self__, *,
                 branding_policy_ids: Sequence[_builtins.str]):
        """
        :param Sequence[_builtins.str] branding_policy_ids: An ordered list of branding policy IDs that determines the priority order of how to apply the policies
        """
        pulumi.set(__self__, "branding_policy_ids", branding_policy_ids)

    @_builtins.property
    @pulumi.getter(name="brandingPolicyIds")
    def branding_policy_ids(self) -> Sequence[_builtins.str]:
        """
        An ordered list of branding policy IDs that determines the priority order of how to apply the policies
        """
        return pulumi.get(self, "branding_policy_ids")


@pulumi.output_type
class GetCameraBoundariesAreasByDeviceItemResult(dict):
    def __init__(__self__, *,
                 boundaries: 'outputs.GetCameraBoundariesAreasByDeviceItemBoundariesResult',
                 network_id: _builtins.str,
                 serial: _builtins.str):
        """
        :param 'GetCameraBoundariesAreasByDeviceItemBoundariesArgs' boundaries: Configured area boundaries of the camera
        :param _builtins.str network_id: The network id of the camera
        :param _builtins.str serial: The serial number of the camera
        """
        pulumi.set(__self__, "boundaries", boundaries)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter
    def boundaries(self) -> 'outputs.GetCameraBoundariesAreasByDeviceItemBoundariesResult':
        """
        Configured area boundaries of the camera
        """
        return pulumi.get(self, "boundaries")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        The network id of the camera
        """
        return pulumi.get(self, "network_id")

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


@pulumi.output_type
class GetCameraBoundariesAreasByDeviceItemBoundariesResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str,
                 type: _builtins.str,
                 vertices: Sequence['outputs.GetCameraBoundariesAreasByDeviceItemBoundariesVertexResult']):
        """
        :param _builtins.str id: The area boundary id
        :param _builtins.str name: The area boundary name
        :param _builtins.str type: The area boundary type
        :param Sequence['GetCameraBoundariesAreasByDeviceItemBoundariesVertexArgs'] vertices: The area boundary vertices
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "vertices", vertices)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        The area boundary id
        """
        return pulumi.get(self, "id")

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

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

    @_builtins.property
    @pulumi.getter
    def vertices(self) -> Sequence['outputs.GetCameraBoundariesAreasByDeviceItemBoundariesVertexResult']:
        """
        The area boundary vertices
        """
        return pulumi.get(self, "vertices")


@pulumi.output_type
class GetCameraBoundariesAreasByDeviceItemBoundariesVertexResult(dict):
    def __init__(__self__, *,
                 x: _builtins.float,
                 y: _builtins.float):
        """
        :param _builtins.float x: The vertex x coordinate
        :param _builtins.float y: The vertex y coordinate
        """
        pulumi.set(__self__, "x", x)
        pulumi.set(__self__, "y", y)

    @_builtins.property
    @pulumi.getter
    def x(self) -> _builtins.float:
        """
        The vertex x coordinate
        """
        return pulumi.get(self, "x")

    @_builtins.property
    @pulumi.getter
    def y(self) -> _builtins.float:
        """
        The vertex y coordinate
        """
        return pulumi.get(self, "y")


@pulumi.output_type
class GetCameraBoundariesLinesByDeviceItemResult(dict):
    def __init__(__self__, *,
                 boundaries: 'outputs.GetCameraBoundariesLinesByDeviceItemBoundariesResult',
                 network_id: _builtins.str,
                 serial: _builtins.str):
        """
        :param 'GetCameraBoundariesLinesByDeviceItemBoundariesArgs' boundaries: Configured line boundaries of the camera
        :param _builtins.str network_id: The network id of the camera
        :param _builtins.str serial: The serial number of the camera
        """
        pulumi.set(__self__, "boundaries", boundaries)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter
    def boundaries(self) -> 'outputs.GetCameraBoundariesLinesByDeviceItemBoundariesResult':
        """
        Configured line boundaries of the camera
        """
        return pulumi.get(self, "boundaries")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        The network id of the camera
        """
        return pulumi.get(self, "network_id")

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


@pulumi.output_type
class GetCameraBoundariesLinesByDeviceItemBoundariesResult(dict):
    def __init__(__self__, *,
                 direction_vertex: 'outputs.GetCameraBoundariesLinesByDeviceItemBoundariesDirectionVertexResult',
                 id: _builtins.str,
                 name: _builtins.str,
                 type: _builtins.str,
                 vertices: Sequence['outputs.GetCameraBoundariesLinesByDeviceItemBoundariesVertexResult']):
        """
        :param 'GetCameraBoundariesLinesByDeviceItemBoundariesDirectionVertexArgs' direction_vertex: The line boundary crossing direction vertex
        :param _builtins.str id: The line boundary id
        :param _builtins.str name: The line boundary name
        :param _builtins.str type: The line boundary type
        :param Sequence['GetCameraBoundariesLinesByDeviceItemBoundariesVertexArgs'] vertices: The line boundary vertices
        """
        pulumi.set(__self__, "direction_vertex", direction_vertex)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "vertices", vertices)

    @_builtins.property
    @pulumi.getter(name="directionVertex")
    def direction_vertex(self) -> 'outputs.GetCameraBoundariesLinesByDeviceItemBoundariesDirectionVertexResult':
        """
        The line boundary crossing direction vertex
        """
        return pulumi.get(self, "direction_vertex")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        The line boundary id
        """
        return pulumi.get(self, "id")

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

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

    @_builtins.property
    @pulumi.getter
    def vertices(self) -> Sequence['outputs.GetCameraBoundariesLinesByDeviceItemBoundariesVertexResult']:
        """
        The line boundary vertices
        """
        return pulumi.get(self, "vertices")


@pulumi.output_type
class GetCameraBoundariesLinesByDeviceItemBoundariesDirectionVertexResult(dict):
    def __init__(__self__, *,
                 x: _builtins.float,
                 y: _builtins.float):
        """
        :param _builtins.float x: The vertex x coordinate
        :param _builtins.float y: The vertex y coordinate
        """
        pulumi.set(__self__, "x", x)
        pulumi.set(__self__, "y", y)

    @_builtins.property
    @pulumi.getter
    def x(self) -> _builtins.float:
        """
        The vertex x coordinate
        """
        return pulumi.get(self, "x")

    @_builtins.property
    @pulumi.getter
    def y(self) -> _builtins.float:
        """
        The vertex y coordinate
        """
        return pulumi.get(self, "y")


@pulumi.output_type
class GetCameraBoundariesLinesByDeviceItemBoundariesVertexResult(dict):
    def __init__(__self__, *,
                 x: _builtins.float,
                 y: _builtins.float):
        """
        :param _builtins.float x: The vertex x coordinate
        :param _builtins.float y: The vertex y coordinate
        """
        pulumi.set(__self__, "x", x)
        pulumi.set(__self__, "y", y)

    @_builtins.property
    @pulumi.getter
    def x(self) -> _builtins.float:
        """
        The vertex x coordinate
        """
        return pulumi.get(self, "x")

    @_builtins.property
    @pulumi.getter
    def y(self) -> _builtins.float:
        """
        The vertex y coordinate
        """
        return pulumi.get(self, "y")


@pulumi.output_type
class GetCameraCustomAnalyticsArtifactsItemResult(dict):
    def __init__(__self__, *,
                 artifact_id: _builtins.str,
                 name: _builtins.str,
                 organization_id: _builtins.str,
                 status: 'outputs.GetCameraCustomAnalyticsArtifactsItemStatusResult'):
        """
        :param _builtins.str artifact_id: Custom analytics artifact ID
        :param _builtins.str name: Custom analytics artifact name
        :param _builtins.str organization_id: Organization ID
        :param 'GetCameraCustomAnalyticsArtifactsItemStatusArgs' status: Custom analytics artifact status
        """
        pulumi.set(__self__, "artifact_id", artifact_id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "organization_id", organization_id)
        pulumi.set(__self__, "status", status)

    @_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 name(self) -> _builtins.str:
        """
        Custom analytics artifact name
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> _builtins.str:
        """
        Organization ID
        """
        return pulumi.get(self, "organization_id")

    @_builtins.property
    @pulumi.getter
    def status(self) -> 'outputs.GetCameraCustomAnalyticsArtifactsItemStatusResult':
        """
        Custom analytics artifact status
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetCameraCustomAnalyticsArtifactsItemStatusResult(dict):
    def __init__(__self__, *,
                 message: _builtins.str,
                 type: _builtins.str):
        """
        :param _builtins.str message: Status message
        :param _builtins.str type: Status type
        """
        pulumi.set(__self__, "message", message)
        pulumi.set(__self__, "type", type)

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

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


@pulumi.output_type
class GetCameraDetectionsHistoryByBoundaryByIntervalItemResult(dict):
    def __init__(__self__, *,
                 boundary_id: _builtins.str,
                 results: 'outputs.GetCameraDetectionsHistoryByBoundaryByIntervalItemResultsResult',
                 type: _builtins.str):
        """
        :param _builtins.str boundary_id: The boundary id
        :param 'GetCameraDetectionsHistoryByBoundaryByIntervalItemResultsArgs' results: The analytics data
        :param _builtins.str type: The boundary type
        """
        pulumi.set(__self__, "boundary_id", boundary_id)
        pulumi.set(__self__, "results", results)
        pulumi.set(__self__, "type", type)

    @_builtins.property
    @pulumi.getter(name="boundaryId")
    def boundary_id(self) -> _builtins.str:
        """
        The boundary id
        """
        return pulumi.get(self, "boundary_id")

    @_builtins.property
    @pulumi.getter
    def results(self) -> 'outputs.GetCameraDetectionsHistoryByBoundaryByIntervalItemResultsResult':
        """
        The analytics data
        """
        return pulumi.get(self, "results")

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


@pulumi.output_type
class GetCameraDetectionsHistoryByBoundaryByIntervalItemResultsResult(dict):
    def __init__(__self__, *,
                 end_time: _builtins.str,
                 in_: _builtins.int,
                 object_type: _builtins.str,
                 out: _builtins.int,
                 start_time: _builtins.str):
        """
        :param _builtins.str end_time: The period end time
        :param _builtins.int in_: The number of detections entered
        :param _builtins.str object_type: The detection type
        :param _builtins.int out: The number of detections exited
        :param _builtins.str start_time: The period start time
        """
        pulumi.set(__self__, "end_time", end_time)
        pulumi.set(__self__, "in_", in_)
        pulumi.set(__self__, "object_type", object_type)
        pulumi.set(__self__, "out", out)
        pulumi.set(__self__, "start_time", start_time)

    @_builtins.property
    @pulumi.getter(name="endTime")
    def end_time(self) -> _builtins.str:
        """
        The period end time
        """
        return pulumi.get(self, "end_time")

    @_builtins.property
    @pulumi.getter(name="in")
    def in_(self) -> _builtins.int:
        """
        The number of detections entered
        """
        return pulumi.get(self, "in_")

    @_builtins.property
    @pulumi.getter(name="objectType")
    def object_type(self) -> _builtins.str:
        """
        The detection type
        """
        return pulumi.get(self, "object_type")

    @_builtins.property
    @pulumi.getter
    def out(self) -> _builtins.int:
        """
        The number of detections exited
        """
        return pulumi.get(self, "out")

    @_builtins.property
    @pulumi.getter(name="startTime")
    def start_time(self) -> _builtins.str:
        """
        The period start time
        """
        return pulumi.get(self, "start_time")


@pulumi.output_type
class GetCameraPermissionsItemResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 level: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: Permission scope id
        :param _builtins.str level: Permission scope level
        :param _builtins.str name: Name of permission scope
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "level", level)
        pulumi.set(__self__, "name", name)

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

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

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


@pulumi.output_type
class GetCameraRolesItemResult(dict):
    def __init__(__self__, *,
                 applied_on_devices: Sequence['outputs.GetCameraRolesItemAppliedOnDeviceResult'],
                 applied_on_networks: Sequence['outputs.GetCameraRolesItemAppliedOnNetworkResult'],
                 applied_org_wides: Sequence['outputs.GetCameraRolesItemAppliedOrgWideResult'],
                 name: _builtins.str):
        pulumi.set(__self__, "applied_on_devices", applied_on_devices)
        pulumi.set(__self__, "applied_on_networks", applied_on_networks)
        pulumi.set(__self__, "applied_org_wides", applied_org_wides)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter(name="appliedOnDevices")
    def applied_on_devices(self) -> Sequence['outputs.GetCameraRolesItemAppliedOnDeviceResult']:
        return pulumi.get(self, "applied_on_devices")

    @_builtins.property
    @pulumi.getter(name="appliedOnNetworks")
    def applied_on_networks(self) -> Sequence['outputs.GetCameraRolesItemAppliedOnNetworkResult']:
        return pulumi.get(self, "applied_on_networks")

    @_builtins.property
    @pulumi.getter(name="appliedOrgWides")
    def applied_org_wides(self) -> Sequence['outputs.GetCameraRolesItemAppliedOrgWideResult']:
        return pulumi.get(self, "applied_org_wides")

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


@pulumi.output_type
class GetCameraRolesItemAppliedOnDeviceResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 permission_level: _builtins.str,
                 permission_scope: _builtins.str,
                 permission_scope_id: _builtins.str,
                 tag: _builtins.str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "permission_level", permission_level)
        pulumi.set(__self__, "permission_scope", permission_scope)
        pulumi.set(__self__, "permission_scope_id", permission_scope_id)
        pulumi.set(__self__, "tag", tag)

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

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

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

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

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


@pulumi.output_type
class GetCameraRolesItemAppliedOnNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 permission_level: _builtins.str,
                 permission_scope: _builtins.str,
                 permission_scope_id: _builtins.str,
                 tag: _builtins.str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "permission_level", permission_level)
        pulumi.set(__self__, "permission_scope", permission_scope)
        pulumi.set(__self__, "permission_scope_id", permission_scope_id)
        pulumi.set(__self__, "tag", tag)

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

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

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

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

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


@pulumi.output_type
class GetCameraRolesItemAppliedOrgWideResult(dict):
    def __init__(__self__, *,
                 permission_level: _builtins.str,
                 permission_scope: _builtins.str,
                 permission_scope_id: _builtins.str,
                 tag: _builtins.str):
        pulumi.set(__self__, "permission_level", permission_level)
        pulumi.set(__self__, "permission_scope", permission_scope)
        pulumi.set(__self__, "permission_scope_id", permission_scope_id)
        pulumi.set(__self__, "tag", tag)

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

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

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

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


@pulumi.output_type
class GetCellularGatewayUplinkStatusesItemResult(dict):
    def __init__(__self__, *,
                 last_reported_at: _builtins.str,
                 model: _builtins.str,
                 network_id: _builtins.str,
                 serial: _builtins.str,
                 uplinks: Sequence['outputs.GetCellularGatewayUplinkStatusesItemUplinkResult']):
        """
        :param _builtins.str last_reported_at: Last reported time for the device
        :param _builtins.str model: Device model
        :param _builtins.str network_id: Network Id
        :param _builtins.str serial: Serial number of the device
        :param Sequence['GetCellularGatewayUplinkStatusesItemUplinkArgs'] uplinks: Uplinks info
        """
        pulumi.set(__self__, "last_reported_at", last_reported_at)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "uplinks", uplinks)

    @_builtins.property
    @pulumi.getter(name="lastReportedAt")
    def last_reported_at(self) -> _builtins.str:
        """
        Last reported time for the device
        """
        return pulumi.get(self, "last_reported_at")

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

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        Network Id
        """
        return pulumi.get(self, "network_id")

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

    @_builtins.property
    @pulumi.getter
    def uplinks(self) -> Sequence['outputs.GetCellularGatewayUplinkStatusesItemUplinkResult']:
        """
        Uplinks info
        """
        return pulumi.get(self, "uplinks")


@pulumi.output_type
class GetCellularGatewayUplinkStatusesItemUplinkResult(dict):
    def __init__(__self__, *,
                 apn: _builtins.str,
                 connection_type: _builtins.str,
                 dns1: _builtins.str,
                 dns2: _builtins.str,
                 gateway: _builtins.str,
                 iccid: _builtins.str,
                 interface: _builtins.str,
                 ip: _builtins.str,
                 model: _builtins.str,
                 provider: _builtins.str,
                 public_ip: _builtins.str,
                 signal_stat: 'outputs.GetCellularGatewayUplinkStatusesItemUplinkSignalStatResult',
                 signal_type: _builtins.str,
                 status: _builtins.str):
        """
        :param _builtins.str apn: Access Point Name
        :param _builtins.str connection_type: Connection Type
        :param _builtins.str dns1: Primary DNS IP
        :param _builtins.str dns2: Secondary DNS IP
        :param _builtins.str gateway: Gateway IP
        :param _builtins.str iccid: Integrated Circuit Card Identification Number
        :param _builtins.str interface: Uplink interface
        :param _builtins.str ip: Uplink IP
        :param _builtins.str model: Uplink model
        :param _builtins.str provider: Network Provider
        :param _builtins.str public_ip: Public IP
        :param 'GetCellularGatewayUplinkStatusesItemUplinkSignalStatArgs' signal_stat: Tower Signal Status
        :param _builtins.str signal_type: Signal Type
        :param _builtins.str status: Uplink status
        """
        pulumi.set(__self__, "apn", apn)
        pulumi.set(__self__, "connection_type", connection_type)
        pulumi.set(__self__, "dns1", dns1)
        pulumi.set(__self__, "dns2", dns2)
        pulumi.set(__self__, "gateway", gateway)
        pulumi.set(__self__, "iccid", iccid)
        pulumi.set(__self__, "interface", interface)
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "provider", provider)
        pulumi.set(__self__, "public_ip", public_ip)
        pulumi.set(__self__, "signal_stat", signal_stat)
        pulumi.set(__self__, "signal_type", signal_type)
        pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter
    def apn(self) -> _builtins.str:
        """
        Access Point Name
        """
        return pulumi.get(self, "apn")

    @_builtins.property
    @pulumi.getter(name="connectionType")
    def connection_type(self) -> _builtins.str:
        """
        Connection Type
        """
        return pulumi.get(self, "connection_type")

    @_builtins.property
    @pulumi.getter
    def dns1(self) -> _builtins.str:
        """
        Primary DNS IP
        """
        return pulumi.get(self, "dns1")

    @_builtins.property
    @pulumi.getter
    def dns2(self) -> _builtins.str:
        """
        Secondary DNS IP
        """
        return pulumi.get(self, "dns2")

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

    @_builtins.property
    @pulumi.getter
    def iccid(self) -> _builtins.str:
        """
        Integrated Circuit Card Identification Number
        """
        return pulumi.get(self, "iccid")

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

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

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

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

    @_builtins.property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> _builtins.str:
        """
        Public IP
        """
        return pulumi.get(self, "public_ip")

    @_builtins.property
    @pulumi.getter(name="signalStat")
    def signal_stat(self) -> 'outputs.GetCellularGatewayUplinkStatusesItemUplinkSignalStatResult':
        """
        Tower Signal Status
        """
        return pulumi.get(self, "signal_stat")

    @_builtins.property
    @pulumi.getter(name="signalType")
    def signal_type(self) -> _builtins.str:
        """
        Signal Type
        """
        return pulumi.get(self, "signal_type")

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


@pulumi.output_type
class GetCellularGatewayUplinkStatusesItemUplinkSignalStatResult(dict):
    def __init__(__self__, *,
                 rsrp: _builtins.str,
                 rsrq: _builtins.str):
        """
        :param _builtins.str rsrp: Reference Signal Received Power
        :param _builtins.str rsrq: Reference Signal Received Quality
        """
        pulumi.set(__self__, "rsrp", rsrp)
        pulumi.set(__self__, "rsrq", rsrq)

    @_builtins.property
    @pulumi.getter
    def rsrp(self) -> _builtins.str:
        """
        Reference Signal Received Power
        """
        return pulumi.get(self, "rsrp")

    @_builtins.property
    @pulumi.getter
    def rsrq(self) -> _builtins.str:
        """
        Reference Signal Received Quality
        """
        return pulumi.get(self, "rsrq")


@pulumi.output_type
class GetClientsBandwidthUsageHistoryItemResult(dict):
    def __init__(__self__, *,
                 downstream: _builtins.int,
                 total: _builtins.int,
                 ts: _builtins.str,
                 upstream: _builtins.int):
        """
        :param _builtins.int downstream: Downloaded data, in mbps.
        :param _builtins.int total: Total bandwidth usage, in mbps.
        :param _builtins.str ts: Timestamp for the bandwidth usage snapshot.
        :param _builtins.int upstream: Uploaded data, in mbps.
        """
        pulumi.set(__self__, "downstream", downstream)
        pulumi.set(__self__, "total", total)
        pulumi.set(__self__, "ts", ts)
        pulumi.set(__self__, "upstream", upstream)

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> _builtins.int:
        """
        Downloaded data, in mbps.
        """
        return pulumi.get(self, "downstream")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total bandwidth usage, in mbps.
        """
        return pulumi.get(self, "total")

    @_builtins.property
    @pulumi.getter
    def ts(self) -> _builtins.str:
        """
        Timestamp for the bandwidth usage snapshot.
        """
        return pulumi.get(self, "ts")

    @_builtins.property
    @pulumi.getter
    def upstream(self) -> _builtins.int:
        """
        Uploaded data, in mbps.
        """
        return pulumi.get(self, "upstream")


@pulumi.output_type
class GetClientsOverviewItemResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetClientsOverviewItemCountsResult',
                 usage: 'outputs.GetClientsOverviewItemUsageResult'):
        """
        :param 'GetClientsOverviewItemCountsArgs' counts: Client count information
        :param 'GetClientsOverviewItemUsageArgs' usage: Usage information of all clients across organization
        """
        pulumi.set(__self__, "counts", counts)
        pulumi.set(__self__, "usage", usage)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> 'outputs.GetClientsOverviewItemCountsResult':
        """
        Client count information
        """
        return pulumi.get(self, "counts")

    @_builtins.property
    @pulumi.getter
    def usage(self) -> 'outputs.GetClientsOverviewItemUsageResult':
        """
        Usage information of all clients across organization
        """
        return pulumi.get(self, "usage")


@pulumi.output_type
class GetClientsOverviewItemCountsResult(dict):
    def __init__(__self__, *,
                 total: _builtins.int):
        """
        :param _builtins.int total: Total number of clients with data usage in organization
        """
        pulumi.set(__self__, "total", total)

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total number of clients with data usage in organization
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetClientsOverviewItemUsageResult(dict):
    def __init__(__self__, *,
                 average: _builtins.float,
                 overall: 'outputs.GetClientsOverviewItemUsageOverallResult'):
        """
        :param _builtins.float average: Average data usage (in kb) of each client in organization
        :param 'GetClientsOverviewItemUsageOverallArgs' overall: Overall data usage of all clients across organization
        """
        pulumi.set(__self__, "average", average)
        pulumi.set(__self__, "overall", overall)

    @_builtins.property
    @pulumi.getter
    def average(self) -> _builtins.float:
        """
        Average data usage (in kb) of each client in organization
        """
        return pulumi.get(self, "average")

    @_builtins.property
    @pulumi.getter
    def overall(self) -> 'outputs.GetClientsOverviewItemUsageOverallResult':
        """
        Overall data usage of all clients across organization
        """
        return pulumi.get(self, "overall")


@pulumi.output_type
class GetClientsOverviewItemUsageOverallResult(dict):
    def __init__(__self__, *,
                 downstream: _builtins.float,
                 total: _builtins.float,
                 upstream: _builtins.float):
        """
        :param _builtins.float downstream: Downstream data usage (in kb) of all clients across organization
        :param _builtins.float total: Total data usage (in kb) of all clients across organization
        :param _builtins.float upstream: Upstream data usage (in kb) of all clients across organization
        """
        pulumi.set(__self__, "downstream", downstream)
        pulumi.set(__self__, "total", total)
        pulumi.set(__self__, "upstream", upstream)

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> _builtins.float:
        """
        Downstream data usage (in kb) of all clients across organization
        """
        return pulumi.get(self, "downstream")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.float:
        """
        Total data usage (in kb) of all clients across organization
        """
        return pulumi.get(self, "total")

    @_builtins.property
    @pulumi.getter
    def upstream(self) -> _builtins.float:
        """
        Upstream data usage (in kb) of all clients across organization
        """
        return pulumi.get(self, "upstream")


@pulumi.output_type
class GetClientsSearchItemResult(dict):
    def __init__(__self__, *,
                 client_id: _builtins.str,
                 mac: _builtins.str,
                 manufacturer: _builtins.str,
                 records: Sequence['outputs.GetClientsSearchItemRecordResult']):
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "manufacturer", manufacturer)
        pulumi.set(__self__, "records", records)

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

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

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

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


@pulumi.output_type
class GetClientsSearchItemRecordResult(dict):
    def __init__(__self__, *,
                 cdp: _builtins.str,
                 client_vpn_connections: Sequence['outputs.GetClientsSearchItemRecordClientVpnConnectionResult'],
                 description: _builtins.str,
                 first_seen: _builtins.int,
                 ip: _builtins.str,
                 ip6: _builtins.str,
                 last_seen: _builtins.int,
                 lldps: Sequence[_builtins.str],
                 network: 'outputs.GetClientsSearchItemRecordNetworkResult',
                 os: _builtins.str,
                 sm_installed: _builtins.bool,
                 ssid: _builtins.str,
                 status: _builtins.str,
                 switchport: _builtins.str,
                 user: _builtins.str,
                 vlan: _builtins.str,
                 wireless_capabilities: _builtins.str):
        pulumi.set(__self__, "cdp", cdp)
        pulumi.set(__self__, "client_vpn_connections", client_vpn_connections)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "first_seen", first_seen)
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "ip6", ip6)
        pulumi.set(__self__, "last_seen", last_seen)
        pulumi.set(__self__, "lldps", lldps)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "os", os)
        pulumi.set(__self__, "sm_installed", sm_installed)
        pulumi.set(__self__, "ssid", ssid)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "switchport", switchport)
        pulumi.set(__self__, "user", user)
        pulumi.set(__self__, "vlan", vlan)
        pulumi.set(__self__, "wireless_capabilities", wireless_capabilities)

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

    @_builtins.property
    @pulumi.getter(name="clientVpnConnections")
    def client_vpn_connections(self) -> Sequence['outputs.GetClientsSearchItemRecordClientVpnConnectionResult']:
        return pulumi.get(self, "client_vpn_connections")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetClientsSearchItemRecordClientVpnConnectionResult(dict):
    def __init__(__self__, *,
                 connected_at: _builtins.int,
                 disconnected_at: _builtins.int,
                 remote_ip: _builtins.str):
        pulumi.set(__self__, "connected_at", connected_at)
        pulumi.set(__self__, "disconnected_at", disconnected_at)
        pulumi.set(__self__, "remote_ip", remote_ip)

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

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

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


@pulumi.output_type
class GetClientsSearchItemRecordNetworkResult(dict):
    def __init__(__self__, *,
                 enrollment_string: _builtins.str,
                 id: _builtins.str,
                 is_bound_to_config_template: _builtins.bool,
                 name: _builtins.str,
                 notes: _builtins.str,
                 organization_id: _builtins.str,
                 product_types: Sequence[_builtins.str],
                 tags: Sequence[_builtins.str],
                 time_zone: _builtins.str):
        pulumi.set(__self__, "enrollment_string", enrollment_string)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_bound_to_config_template", is_bound_to_config_template)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "notes", notes)
        pulumi.set(__self__, "organization_id", organization_id)
        pulumi.set(__self__, "product_types", product_types)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "time_zone", time_zone)

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetConfigTemplatesItemResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str,
                 product_types: Sequence[_builtins.str],
                 time_zone: _builtins.str):
        """
        :param _builtins.str id: The ID of the network or config template to copy configuration from
        :param _builtins.str name: The name of the configuration template
        :param Sequence[_builtins.str] product_types: The product types of the configuration template
        :param _builtins.str time_zone: The timezone of the configuration template. For a list of allowed timezones, please see the 'TZ' column in the table in \\n\\nthis article\\n\\n. Not applicable if copying from existing network or template
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "product_types", product_types)
        pulumi.set(__self__, "time_zone", time_zone)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        The ID of the network or config template to copy configuration from
        """
        return pulumi.get(self, "id")

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

    @_builtins.property
    @pulumi.getter(name="productTypes")
    def product_types(self) -> Sequence[_builtins.str]:
        """
        The product types of the configuration template
        """
        return pulumi.get(self, "product_types")

    @_builtins.property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> _builtins.str:
        """
        The timezone of the configuration template. For a list of allowed timezones, please see the 'TZ' column in the table in \\n\\nthis article\\n\\n. Not applicable if copying from existing network or template
        """
        return pulumi.get(self, "time_zone")


@pulumi.output_type
class GetConfigTemplatesSwitchProfilesItemResult(dict):
    def __init__(__self__, *,
                 model: _builtins.str,
                 name: _builtins.str,
                 switch_profile_id: _builtins.str):
        """
        :param _builtins.str model: Switch model
        :param _builtins.str name: Switch template name
        :param _builtins.str switch_profile_id: Switch template id
        """
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "switch_profile_id", switch_profile_id)

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

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

    @_builtins.property
    @pulumi.getter(name="switchProfileId")
    def switch_profile_id(self) -> _builtins.str:
        """
        Switch template id
        """
        return pulumi.get(self, "switch_profile_id")


@pulumi.output_type
class GetConfigTemplatesSwitchProfilesPortsItemResult(dict):
    def __init__(__self__, *,
                 access_policy_number: _builtins.int,
                 access_policy_type: _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.GetConfigTemplatesSwitchProfilesPortsItemMirrorResult',
                 module: 'outputs.GetConfigTemplatesSwitchProfilesPortsItemModuleResult',
                 name: _builtins.str,
                 poe_enabled: _builtins.bool,
                 port_id: _builtins.str,
                 port_schedule_id: _builtins.str,
                 profile: 'outputs.GetConfigTemplatesSwitchProfilesPortsItemProfileResult',
                 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 template port. Only applicable when 'accessPolicyType' is 'Custom access policy'.
        :param _builtins.str access_policy_type: The type of the access policy of the switch template 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 allowed_vlans: The VLANs allowed on the switch template 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 template 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 template port.
        :param _builtins.str link_negotiation: The link speed for the switch template port.
        :param Sequence[_builtins.str] link_negotiation_capabilities: Available link speeds for the switch template 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 'GetConfigTemplatesSwitchProfilesPortsItemMirrorArgs' mirror: Port mirror
        :param 'GetConfigTemplatesSwitchProfilesPortsItemModuleArgs' module: Expansion module
        :param _builtins.str name: The name of the switch template port.
        :param _builtins.bool poe_enabled: The PoE status of the switch template port.
        :param _builtins.str port_id: The identifier of the switch template port.
        :param _builtins.str port_schedule_id: The ID of the port schedule. A value of null will clear the port schedule.
        :param 'GetConfigTemplatesSwitchProfilesPortsItemProfileArgs' 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 template 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 template port.
        :param _builtins.str type: The type of the switch template 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 template 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 template 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__, "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__, "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 template 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 template 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="allowedVlans")
    def allowed_vlans(self) -> _builtins.str:
        """
        The VLANs allowed on the switch template 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 template 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 template 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 template 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 template 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.GetConfigTemplatesSwitchProfilesPortsItemMirrorResult':
        """
        Port mirror
        """
        return pulumi.get(self, "mirror")

    @_builtins.property
    @pulumi.getter
    def module(self) -> 'outputs.GetConfigTemplatesSwitchProfilesPortsItemModuleResult':
        """
        Expansion module
        """
        return pulumi.get(self, "module")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        The name of the switch template port.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="poeEnabled")
    def poe_enabled(self) -> _builtins.bool:
        """
        The PoE status of the switch template port.
        """
        return pulumi.get(self, "poe_enabled")

    @_builtins.property
    @pulumi.getter(name="portId")
    def port_id(self) -> _builtins.str:
        """
        The identifier of the switch template 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.GetConfigTemplatesSwitchProfilesPortsItemProfileResult':
        """
        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 template 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 template port.
        """
        return pulumi.get(self, "tags")

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        The type of the switch template 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 template 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 template port. Only applicable to access ports.
        """
        return pulumi.get(self, "voice_vlan")


@pulumi.output_type
class GetConfigTemplatesSwitchProfilesPortsItemMirrorResult(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 GetConfigTemplatesSwitchProfilesPortsItemModuleResult(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 GetConfigTemplatesSwitchProfilesPortsItemProfileResult(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 GetDevicesAvailabilitiesChangeHistoryItemResult(dict):
    def __init__(__self__, *,
                 details: 'outputs.GetDevicesAvailabilitiesChangeHistoryItemDetailsResult',
                 device: 'outputs.GetDevicesAvailabilitiesChangeHistoryItemDeviceResult',
                 network: 'outputs.GetDevicesAvailabilitiesChangeHistoryItemNetworkResult',
                 ts: _builtins.str):
        """
        :param 'GetDevicesAvailabilitiesChangeHistoryItemDetailsArgs' details: Details about the status changes
        :param 'GetDevicesAvailabilitiesChangeHistoryItemDeviceArgs' device: Device information
        :param 'GetDevicesAvailabilitiesChangeHistoryItemNetworkArgs' network: Network information
        :param _builtins.str ts: Timestamp, in iso8601 format, at which the event happened
        """
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "device", device)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "ts", ts)

    @_builtins.property
    @pulumi.getter
    def details(self) -> 'outputs.GetDevicesAvailabilitiesChangeHistoryItemDetailsResult':
        """
        Details about the status changes
        """
        return pulumi.get(self, "details")

    @_builtins.property
    @pulumi.getter
    def device(self) -> 'outputs.GetDevicesAvailabilitiesChangeHistoryItemDeviceResult':
        """
        Device information
        """
        return pulumi.get(self, "device")

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetDevicesAvailabilitiesChangeHistoryItemNetworkResult':
        """
        Network information
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter
    def ts(self) -> _builtins.str:
        """
        Timestamp, in iso8601 format, at which the event happened
        """
        return pulumi.get(self, "ts")


@pulumi.output_type
class GetDevicesAvailabilitiesChangeHistoryItemDetailsResult(dict):
    def __init__(__self__, *,
                 news: Sequence['outputs.GetDevicesAvailabilitiesChangeHistoryItemDetailsNewsResult'],
                 olds: Sequence['outputs.GetDevicesAvailabilitiesChangeHistoryItemDetailsOldResult']):
        """
        :param Sequence['GetDevicesAvailabilitiesChangeHistoryItemDetailsNewsArgs'] news: Details about the new status
        :param Sequence['GetDevicesAvailabilitiesChangeHistoryItemDetailsOldArgs'] olds: Details about the old status
        """
        pulumi.set(__self__, "news", news)
        pulumi.set(__self__, "olds", olds)

    @_builtins.property
    @pulumi.getter
    def news(self) -> Sequence['outputs.GetDevicesAvailabilitiesChangeHistoryItemDetailsNewsResult']:
        """
        Details about the new status
        """
        return pulumi.get(self, "news")

    @_builtins.property
    @pulumi.getter
    def olds(self) -> Sequence['outputs.GetDevicesAvailabilitiesChangeHistoryItemDetailsOldResult']:
        """
        Details about the old status
        """
        return pulumi.get(self, "olds")


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

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

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


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

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

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


@pulumi.output_type
class GetDevicesAvailabilitiesChangeHistoryItemDeviceResult(dict):
    def __init__(__self__, *,
                 model: _builtins.str,
                 name: _builtins.str,
                 product_type: _builtins.str,
                 serial: _builtins.str):
        """
        :param _builtins.str model: Device model
        :param _builtins.str name: Device name
        :param _builtins.str product_type: Device product type.
        :param _builtins.str serial: Device serial number
        """
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "serial", serial)

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

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

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Device product type.
        """
        return pulumi.get(self, "product_type")

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


@pulumi.output_type
class GetDevicesAvailabilitiesChangeHistoryItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str,
                 tags: Sequence[_builtins.str],
                 url: _builtins.str):
        """
        :param _builtins.str id: Network id
        :param _builtins.str name: Network name
        :param Sequence[_builtins.str] tags: Network tags
        :param _builtins.str url: Network dashboard url
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "url", url)

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

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

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

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


@pulumi.output_type
class GetDevicesAvailabilitiesItemResult(dict):
    def __init__(__self__, *,
                 mac: _builtins.str,
                 name: _builtins.str,
                 network: 'outputs.GetDevicesAvailabilitiesItemNetworkResult',
                 product_type: _builtins.str,
                 serial: _builtins.str,
                 status: _builtins.str,
                 tags: Sequence[_builtins.str]):
        """
        :param _builtins.str mac: The device MAC address.
        :param _builtins.str name: The device name.
        :param 'GetDevicesAvailabilitiesItemNetworkArgs' network: Network info.
        :param _builtins.str product_type: Device product type.
        :param _builtins.str serial: The device serial number.
        :param _builtins.str status: Status of the device. Possible values are: online, alerting, offline, dormant.
        :param Sequence[_builtins.str] tags: List of custom tags for the device.
        """
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tags", tags)

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

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetDevicesAvailabilitiesItemNetworkResult':
        """
        Network info.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Device product type.
        """
        return pulumi.get(self, "product_type")

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

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        Status of the device. Possible values are: online, alerting, offline, dormant.
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Sequence[_builtins.str]:
        """
        List of custom tags for the device.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetDevicesAvailabilitiesItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: ID for the network containing the device.
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID for the network containing the device.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetDevicesBootsHistoryItemResult(dict):
    def __init__(__self__, *,
                 network: 'outputs.GetDevicesBootsHistoryItemNetworkResult',
                 serial: _builtins.str,
                 start: 'outputs.GetDevicesBootsHistoryItemStartResult'):
        """
        :param 'GetDevicesBootsHistoryItemNetworkArgs' network: Device network
        :param _builtins.str serial: Device serial number
        :param 'GetDevicesBootsHistoryItemStartArgs' start: Device power up
        """
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "start", start)

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetDevicesBootsHistoryItemNetworkResult':
        """
        Device network
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def start(self) -> 'outputs.GetDevicesBootsHistoryItemStartResult':
        """
        Device power up
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class GetDevicesBootsHistoryItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: API-formatted network ID
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        API-formatted network ID
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetDevicesBootsHistoryItemStartResult(dict):
    def __init__(__self__, *,
                 booted_at: _builtins.str):
        """
        :param _builtins.str booted_at: Indicates when the device booted
        """
        pulumi.set(__self__, "booted_at", booted_at)

    @_builtins.property
    @pulumi.getter(name="bootedAt")
    def booted_at(self) -> _builtins.str:
        """
        Indicates when the device booted
        """
        return pulumi.get(self, "booted_at")


@pulumi.output_type
class GetDevicesItemResult(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 details: Sequence['outputs.GetDevicesItemDetailResult'],
                 firmware: _builtins.str,
                 imei: _builtins.float,
                 lan_ip: _builtins.str,
                 lat: _builtins.float,
                 lng: _builtins.float,
                 mac: _builtins.str,
                 model: _builtins.str,
                 name: _builtins.str,
                 network_id: _builtins.str,
                 notes: _builtins.str,
                 product_type: _builtins.str,
                 serial: _builtins.str,
                 tags: Sequence[_builtins.str]):
        """
        :param _builtins.str address: Physical address of the device
        :param Sequence['GetDevicesItemDetailArgs'] details: Additional device information
        :param _builtins.str firmware: Firmware version of the device
        :param _builtins.float imei: IMEI of the device, if applicable
        :param _builtins.str lan_ip: LAN IP address of the device
        :param _builtins.float lat: Latitude of the device
        :param _builtins.float lng: Longitude of the device
        :param _builtins.str mac: MAC address of the device
        :param _builtins.str model: Model of the device
        :param _builtins.str name: Name of the device
        :param _builtins.str network_id: ID of the network the device belongs to
        :param _builtins.str notes: Notes for the device, limited to 255 characters
        :param _builtins.str product_type: Product type of the device
        :param _builtins.str serial: Serial number of the device
        :param Sequence[_builtins.str] tags: List of tags assigned to the device
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "firmware", firmware)
        pulumi.set(__self__, "imei", imei)
        pulumi.set(__self__, "lan_ip", lan_ip)
        pulumi.set(__self__, "lat", lat)
        pulumi.set(__self__, "lng", lng)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "notes", notes)
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "tags", tags)

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

    @_builtins.property
    @pulumi.getter
    def details(self) -> Sequence['outputs.GetDevicesItemDetailResult']:
        """
        Additional device information
        """
        return pulumi.get(self, "details")

    @_builtins.property
    @pulumi.getter
    def firmware(self) -> _builtins.str:
        """
        Firmware version of the device
        """
        return pulumi.get(self, "firmware")

    @_builtins.property
    @pulumi.getter
    def imei(self) -> _builtins.float:
        """
        IMEI of the device, if applicable
        """
        return pulumi.get(self, "imei")

    @_builtins.property
    @pulumi.getter(name="lanIp")
    def lan_ip(self) -> _builtins.str:
        """
        LAN IP address of the device
        """
        return pulumi.get(self, "lan_ip")

    @_builtins.property
    @pulumi.getter
    def lat(self) -> _builtins.float:
        """
        Latitude of the device
        """
        return pulumi.get(self, "lat")

    @_builtins.property
    @pulumi.getter
    def lng(self) -> _builtins.float:
        """
        Longitude of the device
        """
        return pulumi.get(self, "lng")

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

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

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

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        ID of the network the device belongs to
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter
    def notes(self) -> _builtins.str:
        """
        Notes for the device, limited to 255 characters
        """
        return pulumi.get(self, "notes")

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Product type of the device
        """
        return pulumi.get(self, "product_type")

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

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Sequence[_builtins.str]:
        """
        List of tags assigned to the device
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetDevicesItemDetailResult(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 value: _builtins.str):
        """
        :param _builtins.str name: Additional property name
        :param _builtins.str value: Additional property value
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class GetDevicesPowerModulesStatusesByDeviceItemResult(dict):
    def __init__(__self__, *,
                 mac: _builtins.str,
                 name: _builtins.str,
                 network: 'outputs.GetDevicesPowerModulesStatusesByDeviceItemNetworkResult',
                 product_type: _builtins.str,
                 serial: _builtins.str,
                 slots: Sequence['outputs.GetDevicesPowerModulesStatusesByDeviceItemSlotResult'],
                 tags: Sequence[_builtins.str]):
        """
        :param _builtins.str mac: The device MAC address.
        :param _builtins.str name: The device name.
        :param 'GetDevicesPowerModulesStatusesByDeviceItemNetworkArgs' network: Network info.
        :param _builtins.str product_type: Device product type.
        :param _builtins.str serial: The device serial number.
        :param Sequence['GetDevicesPowerModulesStatusesByDeviceItemSlotArgs'] slots: Information for the device's AC power supplies.
        :param Sequence[_builtins.str] tags: List of custom tags for the device.
        """
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "slots", slots)
        pulumi.set(__self__, "tags", tags)

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

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetDevicesPowerModulesStatusesByDeviceItemNetworkResult':
        """
        Network info.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Device product type.
        """
        return pulumi.get(self, "product_type")

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

    @_builtins.property
    @pulumi.getter
    def slots(self) -> Sequence['outputs.GetDevicesPowerModulesStatusesByDeviceItemSlotResult']:
        """
        Information for the device's AC power supplies.
        """
        return pulumi.get(self, "slots")

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Sequence[_builtins.str]:
        """
        List of custom tags for the device.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetDevicesPowerModulesStatusesByDeviceItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: ID for the network that the device is associated with.
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID for the network that the device is associated with.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetDevicesPowerModulesStatusesByDeviceItemSlotResult(dict):
    def __init__(__self__, *,
                 model: _builtins.str,
                 number: _builtins.int,
                 serial: _builtins.str,
                 status: _builtins.str):
        """
        :param _builtins.str model: The power supply unit model.
        :param _builtins.int number: Which slot the AC power supply occupies. Possible values are: 0, 1, 2.
        :param _builtins.str serial: The power supply unit serial number.
        :param _builtins.str status: Status of the power supply unit. Possible values are: connected, not connected, powering.
        """
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "number", number)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter
    def model(self) -> _builtins.str:
        """
        The power supply unit model.
        """
        return pulumi.get(self, "model")

    @_builtins.property
    @pulumi.getter
    def number(self) -> _builtins.int:
        """
        Which slot the AC power supply occupies. Possible values are: 0, 1, 2.
        """
        return pulumi.get(self, "number")

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

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        Status of the power supply unit. Possible values are: connected, not connected, powering.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetDevicesProvisioningStatusesItemResult(dict):
    def __init__(__self__, *,
                 mac: _builtins.str,
                 name: _builtins.str,
                 network: 'outputs.GetDevicesProvisioningStatusesItemNetworkResult',
                 product_type: _builtins.str,
                 serial: _builtins.str,
                 status: _builtins.str,
                 tags: Sequence[_builtins.str]):
        """
        :param _builtins.str mac: The device MAC address.
        :param _builtins.str name: The device name.
        :param 'GetDevicesProvisioningStatusesItemNetworkArgs' network: Network info.
        :param _builtins.str product_type: Device product type.
        :param _builtins.str serial: The device serial number.
        :param _builtins.str status: The device provisioning status. Possible statuses: unprovisioned, incomplete, complete.
        :param Sequence[_builtins.str] tags: List of custom tags for the device.
        """
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tags", tags)

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

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetDevicesProvisioningStatusesItemNetworkResult':
        """
        Network info.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Device product type.
        """
        return pulumi.get(self, "product_type")

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

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        The device provisioning status. Possible statuses: unprovisioned, incomplete, complete.
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Sequence[_builtins.str]:
        """
        List of custom tags for the device.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetDevicesProvisioningStatusesItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: ID for the network containing the device.
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID for the network containing the device.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetDevicesStatusesItemResult(dict):
    def __init__(__self__, *,
                 components: 'outputs.GetDevicesStatusesItemComponentsResult',
                 gateway: _builtins.str,
                 ip_type: _builtins.str,
                 lan_ip: _builtins.str,
                 last_reported_at: _builtins.str,
                 mac: _builtins.str,
                 model: _builtins.str,
                 name: _builtins.str,
                 network_id: _builtins.str,
                 primary_dns: _builtins.str,
                 product_type: _builtins.str,
                 public_ip: _builtins.str,
                 secondary_dns: _builtins.str,
                 serial: _builtins.str,
                 status: _builtins.str,
                 tags: Sequence[_builtins.str]):
        """
        :param 'GetDevicesStatusesItemComponentsArgs' components: Components
        :param _builtins.str gateway: IP Gateway
        :param _builtins.str ip_type: IP Type
        :param _builtins.str lan_ip: LAN IP Address
        :param _builtins.str last_reported_at: Device Last Reported Location
        :param _builtins.str mac: MAC Address
        :param _builtins.str model: Model
        :param _builtins.str name: Device Name
        :param _builtins.str network_id: Network ID
        :param _builtins.str primary_dns: Primary DNS
        :param _builtins.str product_type: Product Type
        :param _builtins.str public_ip: Public IP Address
        :param _builtins.str secondary_dns: Secondary DNS
        :param _builtins.str serial: Device Serial Number
        :param _builtins.str status: Device Status
        :param Sequence[_builtins.str] tags: Tags
        """
        pulumi.set(__self__, "components", components)
        pulumi.set(__self__, "gateway", gateway)
        pulumi.set(__self__, "ip_type", ip_type)
        pulumi.set(__self__, "lan_ip", lan_ip)
        pulumi.set(__self__, "last_reported_at", last_reported_at)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "primary_dns", primary_dns)
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "public_ip", public_ip)
        pulumi.set(__self__, "secondary_dns", secondary_dns)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tags", tags)

    @_builtins.property
    @pulumi.getter
    def components(self) -> 'outputs.GetDevicesStatusesItemComponentsResult':
        """
        Components
        """
        return pulumi.get(self, "components")

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

    @_builtins.property
    @pulumi.getter(name="ipType")
    def ip_type(self) -> _builtins.str:
        """
        IP Type
        """
        return pulumi.get(self, "ip_type")

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

    @_builtins.property
    @pulumi.getter(name="lastReportedAt")
    def last_reported_at(self) -> _builtins.str:
        """
        Device Last Reported Location
        """
        return pulumi.get(self, "last_reported_at")

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

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

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

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        Network ID
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="primaryDns")
    def primary_dns(self) -> _builtins.str:
        """
        Primary DNS
        """
        return pulumi.get(self, "primary_dns")

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Product Type
        """
        return pulumi.get(self, "product_type")

    @_builtins.property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> _builtins.str:
        """
        Public IP Address
        """
        return pulumi.get(self, "public_ip")

    @_builtins.property
    @pulumi.getter(name="secondaryDns")
    def secondary_dns(self) -> _builtins.str:
        """
        Secondary DNS
        """
        return pulumi.get(self, "secondary_dns")

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

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

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


@pulumi.output_type
class GetDevicesStatusesItemComponentsResult(dict):
    def __init__(__self__, *,
                 power_supplies: Sequence['outputs.GetDevicesStatusesItemComponentsPowerSupplyResult']):
        """
        :param Sequence['GetDevicesStatusesItemComponentsPowerSupplyArgs'] power_supplies: Power Supplies
        """
        pulumi.set(__self__, "power_supplies", power_supplies)

    @_builtins.property
    @pulumi.getter(name="powerSupplies")
    def power_supplies(self) -> Sequence['outputs.GetDevicesStatusesItemComponentsPowerSupplyResult']:
        """
        Power Supplies
        """
        return pulumi.get(self, "power_supplies")


@pulumi.output_type
class GetDevicesStatusesItemComponentsPowerSupplyResult(dict):
    def __init__(__self__, *,
                 model: _builtins.str,
                 poe: 'outputs.GetDevicesStatusesItemComponentsPowerSupplyPoeResult',
                 serial: _builtins.str,
                 slot: _builtins.int,
                 status: _builtins.str):
        """
        :param _builtins.str model: Model of the power supply
        :param 'GetDevicesStatusesItemComponentsPowerSupplyPoeArgs' poe: PoE info of the power supply
        :param _builtins.str serial: Serial of the power supply
        :param _builtins.int slot: Slot the power supply is in
        :param _builtins.str status: Status of the power supply
        """
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "poe", poe)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "slot", slot)
        pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter
    def model(self) -> _builtins.str:
        """
        Model of the power supply
        """
        return pulumi.get(self, "model")

    @_builtins.property
    @pulumi.getter
    def poe(self) -> 'outputs.GetDevicesStatusesItemComponentsPowerSupplyPoeResult':
        """
        PoE info of the power supply
        """
        return pulumi.get(self, "poe")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        Serial of the power supply
        """
        return pulumi.get(self, "serial")

    @_builtins.property
    @pulumi.getter
    def slot(self) -> _builtins.int:
        """
        Slot the power supply is in
        """
        return pulumi.get(self, "slot")

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


@pulumi.output_type
class GetDevicesStatusesItemComponentsPowerSupplyPoeResult(dict):
    def __init__(__self__, *,
                 maximum: _builtins.int,
                 unit: _builtins.str):
        """
        :param _builtins.int maximum: Maximum PoE this power supply can provide when connected to the current switch model
        :param _builtins.str unit: Unit of the PoE maximum
        """
        pulumi.set(__self__, "maximum", maximum)
        pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter
    def maximum(self) -> _builtins.int:
        """
        Maximum PoE this power supply can provide when connected to the current switch model
        """
        return pulumi.get(self, "maximum")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> _builtins.str:
        """
        Unit of the PoE maximum
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class GetDevicesStatusesOverviewItemResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetDevicesStatusesOverviewItemCountsResult'):
        """
        :param 'GetDevicesStatusesOverviewItemCountsArgs' counts: counts
        """
        pulumi.set(__self__, "counts", counts)

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


@pulumi.output_type
class GetDevicesStatusesOverviewItemCountsResult(dict):
    def __init__(__self__, *,
                 by_status: 'outputs.GetDevicesStatusesOverviewItemCountsByStatusResult'):
        """
        :param 'GetDevicesStatusesOverviewItemCountsByStatusArgs' by_status: byStatus
        """
        pulumi.set(__self__, "by_status", by_status)

    @_builtins.property
    @pulumi.getter(name="byStatus")
    def by_status(self) -> 'outputs.GetDevicesStatusesOverviewItemCountsByStatusResult':
        """
        byStatus
        """
        return pulumi.get(self, "by_status")


@pulumi.output_type
class GetDevicesStatusesOverviewItemCountsByStatusResult(dict):
    def __init__(__self__, *,
                 alerting: _builtins.int,
                 dormant: _builtins.int,
                 offline: _builtins.int,
                 online: _builtins.int):
        """
        :param _builtins.int alerting: alerting count
        :param _builtins.int dormant: dormant count
        :param _builtins.int offline: offline count
        :param _builtins.int online: online count
        """
        pulumi.set(__self__, "alerting", alerting)
        pulumi.set(__self__, "dormant", dormant)
        pulumi.set(__self__, "offline", offline)
        pulumi.set(__self__, "online", online)

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

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

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

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


@pulumi.output_type
class GetDevicesUplinksAddressesByDeviceItemResult(dict):
    def __init__(__self__, *,
                 mac: _builtins.str,
                 name: _builtins.str,
                 network: 'outputs.GetDevicesUplinksAddressesByDeviceItemNetworkResult',
                 product_type: _builtins.str,
                 serial: _builtins.str,
                 tags: Sequence[_builtins.str],
                 uplinks: Sequence['outputs.GetDevicesUplinksAddressesByDeviceItemUplinkResult']):
        """
        :param _builtins.str mac: The device MAC address.
        :param _builtins.str name: The device name.
        :param 'GetDevicesUplinksAddressesByDeviceItemNetworkArgs' network: Network info.
        :param _builtins.str product_type: Device product type.
        :param _builtins.str serial: The device serial number.
        :param Sequence[_builtins.str] tags: List of custom tags for the device.
        :param Sequence['GetDevicesUplinksAddressesByDeviceItemUplinkArgs'] uplinks: List of device uplink addresses information.
        """
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "uplinks", uplinks)

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

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetDevicesUplinksAddressesByDeviceItemNetworkResult':
        """
        Network info.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Device product type.
        """
        return pulumi.get(self, "product_type")

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

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Sequence[_builtins.str]:
        """
        List of custom tags for the device.
        """
        return pulumi.get(self, "tags")

    @_builtins.property
    @pulumi.getter
    def uplinks(self) -> Sequence['outputs.GetDevicesUplinksAddressesByDeviceItemUplinkResult']:
        """
        List of device uplink addresses information.
        """
        return pulumi.get(self, "uplinks")


@pulumi.output_type
class GetDevicesUplinksAddressesByDeviceItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: ID for the network containing the device.
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID for the network containing the device.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetDevicesUplinksAddressesByDeviceItemUplinkResult(dict):
    def __init__(__self__, *,
                 addresses: Sequence['outputs.GetDevicesUplinksAddressesByDeviceItemUplinkAddressResult'],
                 interface: _builtins.str):
        """
        :param Sequence['GetDevicesUplinksAddressesByDeviceItemUplinkAddressArgs'] addresses: Available addresses for the interface.
        :param _builtins.str interface: Interface for the device uplink. Available options are: cellular, man1, man2, wan1, wan2
        """
        pulumi.set(__self__, "addresses", addresses)
        pulumi.set(__self__, "interface", interface)

    @_builtins.property
    @pulumi.getter
    def addresses(self) -> Sequence['outputs.GetDevicesUplinksAddressesByDeviceItemUplinkAddressResult']:
        """
        Available addresses for the interface.
        """
        return pulumi.get(self, "addresses")

    @_builtins.property
    @pulumi.getter
    def interface(self) -> _builtins.str:
        """
        Interface for the device uplink. Available options are: cellular, man1, man2, wan1, wan2
        """
        return pulumi.get(self, "interface")


@pulumi.output_type
class GetDevicesUplinksAddressesByDeviceItemUplinkAddressResult(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 assignment_mode: _builtins.str,
                 gateway: _builtins.str,
                 protocol: _builtins.str,
                 public: 'outputs.GetDevicesUplinksAddressesByDeviceItemUplinkAddressPublicResult'):
        """
        :param _builtins.str address: Device uplink address.
        :param _builtins.str assignment_mode: Indicates how the device uplink address is assigned. Available options are: static, dynamic.
        :param _builtins.str gateway: Device uplink gateway address.
        :param _builtins.str protocol: Type of address for the device uplink. Available options are: ipv4, ipv6.
        :param 'GetDevicesUplinksAddressesByDeviceItemUplinkAddressPublicArgs' public: Public interface information.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "assignment_mode", assignment_mode)
        pulumi.set(__self__, "gateway", gateway)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "public", public)

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

    @_builtins.property
    @pulumi.getter(name="assignmentMode")
    def assignment_mode(self) -> _builtins.str:
        """
        Indicates how the device uplink address is assigned. Available options are: static, dynamic.
        """
        return pulumi.get(self, "assignment_mode")

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

    @_builtins.property
    @pulumi.getter
    def protocol(self) -> _builtins.str:
        """
        Type of address for the device uplink. Available options are: ipv4, ipv6.
        """
        return pulumi.get(self, "protocol")

    @_builtins.property
    @pulumi.getter
    def public(self) -> 'outputs.GetDevicesUplinksAddressesByDeviceItemUplinkAddressPublicResult':
        """
        Public interface information.
        """
        return pulumi.get(self, "public")


@pulumi.output_type
class GetDevicesUplinksAddressesByDeviceItemUplinkAddressPublicResult(dict):
    def __init__(__self__, *,
                 address: _builtins.str):
        """
        :param _builtins.str address: The device uplink public IP address.
        """
        pulumi.set(__self__, "address", address)

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


@pulumi.output_type
class GetDevicesUplinksLossAndLatencyItemResult(dict):
    def __init__(__self__, *,
                 ip: _builtins.str,
                 network_id: _builtins.str,
                 serial: _builtins.str,
                 time_series: Sequence['outputs.GetDevicesUplinksLossAndLatencyItemTimeSeriesResult'],
                 uplink: _builtins.str):
        """
        :param _builtins.str ip: IP address of uplink
        :param _builtins.str network_id: Network ID
        :param _builtins.str serial: Serial of MX device
        :param Sequence['GetDevicesUplinksLossAndLatencyItemTimeSeriesArgs'] time_series: Loss and latency timeseries data
        :param _builtins.str uplink: Uplink interface (wan1, wan2, or cellular)
        """
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "time_series", time_series)
        pulumi.set(__self__, "uplink", uplink)

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

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        Network ID
        """
        return pulumi.get(self, "network_id")

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

    @_builtins.property
    @pulumi.getter(name="timeSeries")
    def time_series(self) -> Sequence['outputs.GetDevicesUplinksLossAndLatencyItemTimeSeriesResult']:
        """
        Loss and latency timeseries data
        """
        return pulumi.get(self, "time_series")

    @_builtins.property
    @pulumi.getter
    def uplink(self) -> _builtins.str:
        """
        Uplink interface (wan1, wan2, or cellular)
        """
        return pulumi.get(self, "uplink")


@pulumi.output_type
class GetDevicesUplinksLossAndLatencyItemTimeSeriesResult(dict):
    def __init__(__self__, *,
                 latency_ms: _builtins.float,
                 loss_percent: _builtins.float,
                 ts: _builtins.str):
        """
        :param _builtins.float latency_ms: Latency in milliseconds
        :param _builtins.float loss_percent: Loss percentage
        :param _builtins.str ts: Timestamp for this data point
        """
        pulumi.set(__self__, "latency_ms", latency_ms)
        pulumi.set(__self__, "loss_percent", loss_percent)
        pulumi.set(__self__, "ts", ts)

    @_builtins.property
    @pulumi.getter(name="latencyMs")
    def latency_ms(self) -> _builtins.float:
        """
        Latency in milliseconds
        """
        return pulumi.get(self, "latency_ms")

    @_builtins.property
    @pulumi.getter(name="lossPercent")
    def loss_percent(self) -> _builtins.float:
        """
        Loss percentage
        """
        return pulumi.get(self, "loss_percent")

    @_builtins.property
    @pulumi.getter
    def ts(self) -> _builtins.str:
        """
        Timestamp for this data point
        """
        return pulumi.get(self, "ts")


@pulumi.output_type
class GetEarlyAccessFeaturesItemResult(dict):
    def __init__(__self__, *,
                 descriptions: 'outputs.GetEarlyAccessFeaturesItemDescriptionsResult',
                 documentation_link: _builtins.str,
                 is_org_scoped_only: _builtins.bool,
                 name: _builtins.str,
                 short_name: _builtins.str,
                 support_link: _builtins.str,
                 topic: _builtins.str):
        """
        :param 'GetEarlyAccessFeaturesItemDescriptionsArgs' descriptions: Descriptions of the early access feature
        :param _builtins.str documentation_link: Link to the documentation of this early access feature
        :param _builtins.bool is_org_scoped_only: If this early access feature can only be opted in for the entire organization
        :param _builtins.str name: Name of the early access feature
        :param _builtins.str short_name: Short name of the early access feature
        :param _builtins.str support_link: Link to get support for this early access feature
        :param _builtins.str topic: Topic of the early access feature
        """
        pulumi.set(__self__, "descriptions", descriptions)
        pulumi.set(__self__, "documentation_link", documentation_link)
        pulumi.set(__self__, "is_org_scoped_only", is_org_scoped_only)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "short_name", short_name)
        pulumi.set(__self__, "support_link", support_link)
        pulumi.set(__self__, "topic", topic)

    @_builtins.property
    @pulumi.getter
    def descriptions(self) -> 'outputs.GetEarlyAccessFeaturesItemDescriptionsResult':
        """
        Descriptions of the early access feature
        """
        return pulumi.get(self, "descriptions")

    @_builtins.property
    @pulumi.getter(name="documentationLink")
    def documentation_link(self) -> _builtins.str:
        """
        Link to the documentation of this early access feature
        """
        return pulumi.get(self, "documentation_link")

    @_builtins.property
    @pulumi.getter(name="isOrgScopedOnly")
    def is_org_scoped_only(self) -> _builtins.bool:
        """
        If this early access feature can only be opted in for the entire organization
        """
        return pulumi.get(self, "is_org_scoped_only")

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

    @_builtins.property
    @pulumi.getter(name="shortName")
    def short_name(self) -> _builtins.str:
        """
        Short name of the early access feature
        """
        return pulumi.get(self, "short_name")

    @_builtins.property
    @pulumi.getter(name="supportLink")
    def support_link(self) -> _builtins.str:
        """
        Link to get support for this early access feature
        """
        return pulumi.get(self, "support_link")

    @_builtins.property
    @pulumi.getter
    def topic(self) -> _builtins.str:
        """
        Topic of the early access feature
        """
        return pulumi.get(self, "topic")


@pulumi.output_type
class GetEarlyAccessFeaturesItemDescriptionsResult(dict):
    def __init__(__self__, *,
                 long: _builtins.str,
                 short: _builtins.str):
        """
        :param _builtins.str long: Long description
        :param _builtins.str short: Short description
        """
        pulumi.set(__self__, "long", long)
        pulumi.set(__self__, "short", short)

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

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


@pulumi.output_type
class GetEarlyAccessFeaturesOptInsItemResult(dict):
    def __init__(__self__, *,
                 created_at: _builtins.str,
                 id: _builtins.str,
                 limit_scope_to_networks: Sequence['outputs.GetEarlyAccessFeaturesOptInsItemLimitScopeToNetworkResult'],
                 short_name: _builtins.str):
        """
        :param _builtins.str created_at: Time when Early Access Feature was created
        :param _builtins.str id: ID of Early Access Feature
        :param Sequence['GetEarlyAccessFeaturesOptInsItemLimitScopeToNetworkArgs'] limit_scope_to_networks: Networks assigned to the Early Access Feature
        :param _builtins.str short_name: Name of Early Access Feature
        """
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "limit_scope_to_networks", limit_scope_to_networks)
        pulumi.set(__self__, "short_name", short_name)

    @_builtins.property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> _builtins.str:
        """
        Time when Early Access Feature was created
        """
        return pulumi.get(self, "created_at")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID of Early Access Feature
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="limitScopeToNetworks")
    def limit_scope_to_networks(self) -> Sequence['outputs.GetEarlyAccessFeaturesOptInsItemLimitScopeToNetworkResult']:
        """
        Networks assigned to the Early Access Feature
        """
        return pulumi.get(self, "limit_scope_to_networks")

    @_builtins.property
    @pulumi.getter(name="shortName")
    def short_name(self) -> _builtins.str:
        """
        Name of Early Access Feature
        """
        return pulumi.get(self, "short_name")


@pulumi.output_type
class GetEarlyAccessFeaturesOptInsItemLimitScopeToNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: ID of Network
        :param _builtins.str name: Name of Network
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID of Network
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetFirmwareUpgradesByDeviceItemResult(dict):
    def __init__(__self__, *,
                 device_status: _builtins.str,
                 name: _builtins.str,
                 serial: _builtins.str,
                 upgrade: 'outputs.GetFirmwareUpgradesByDeviceItemUpgradeResult'):
        """
        :param _builtins.str device_status: Status of the device upgrade
        :param _builtins.str name: Name assigned to the device
        :param _builtins.str serial: Serial of the device
        :param 'GetFirmwareUpgradesByDeviceItemUpgradeArgs' upgrade: The devices upgrade details and status
        """
        pulumi.set(__self__, "device_status", device_status)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "upgrade", upgrade)

    @_builtins.property
    @pulumi.getter(name="deviceStatus")
    def device_status(self) -> _builtins.str:
        """
        Status of the device upgrade
        """
        return pulumi.get(self, "device_status")

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

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

    @_builtins.property
    @pulumi.getter
    def upgrade(self) -> 'outputs.GetFirmwareUpgradesByDeviceItemUpgradeResult':
        """
        The devices upgrade details and status
        """
        return pulumi.get(self, "upgrade")


@pulumi.output_type
class GetFirmwareUpgradesByDeviceItemUpgradeResult(dict):
    def __init__(__self__, *,
                 from_version: 'outputs.GetFirmwareUpgradesByDeviceItemUpgradeFromVersionResult',
                 id: _builtins.str,
                 staged: 'outputs.GetFirmwareUpgradesByDeviceItemUpgradeStagedResult',
                 status: _builtins.str,
                 time: _builtins.str,
                 to_version: 'outputs.GetFirmwareUpgradesByDeviceItemUpgradeToVersionResult',
                 upgrade_batch_id: _builtins.str):
        """
        :param 'GetFirmwareUpgradesByDeviceItemUpgradeFromVersionArgs' from_version: The initial version of the device
        :param _builtins.str id: ID of the upgrade
        :param 'GetFirmwareUpgradesByDeviceItemUpgradeStagedArgs' staged: Staged upgrade
        :param _builtins.str status: Status of the upgrade
        :param _builtins.str time: Start time of the upgrade
        :param 'GetFirmwareUpgradesByDeviceItemUpgradeToVersionArgs' to_version: Version the device is upgrading to
        :param _builtins.str upgrade_batch_id: ID of the upgrade batch
        """
        pulumi.set(__self__, "from_version", from_version)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "staged", staged)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "time", time)
        pulumi.set(__self__, "to_version", to_version)
        pulumi.set(__self__, "upgrade_batch_id", upgrade_batch_id)

    @_builtins.property
    @pulumi.getter(name="fromVersion")
    def from_version(self) -> 'outputs.GetFirmwareUpgradesByDeviceItemUpgradeFromVersionResult':
        """
        The initial version of the device
        """
        return pulumi.get(self, "from_version")

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

    @_builtins.property
    @pulumi.getter
    def staged(self) -> 'outputs.GetFirmwareUpgradesByDeviceItemUpgradeStagedResult':
        """
        Staged upgrade
        """
        return pulumi.get(self, "staged")

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

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

    @_builtins.property
    @pulumi.getter(name="toVersion")
    def to_version(self) -> 'outputs.GetFirmwareUpgradesByDeviceItemUpgradeToVersionResult':
        """
        Version the device is upgrading to
        """
        return pulumi.get(self, "to_version")

    @_builtins.property
    @pulumi.getter(name="upgradeBatchId")
    def upgrade_batch_id(self) -> _builtins.str:
        """
        ID of the upgrade batch
        """
        return pulumi.get(self, "upgrade_batch_id")


@pulumi.output_type
class GetFirmwareUpgradesByDeviceItemUpgradeFromVersionResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 release_date: _builtins.str,
                 release_type: _builtins.str,
                 short_name: _builtins.str):
        """
        :param _builtins.str id: ID of the initial firmware version
        :param _builtins.str release_date: Release date of the firmware version
        :param _builtins.str release_type: Release type of the firmware version
        :param _builtins.str short_name: Firmware version short name
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "release_date", release_date)
        pulumi.set(__self__, "release_type", release_type)
        pulumi.set(__self__, "short_name", short_name)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID of the initial firmware version
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="releaseDate")
    def release_date(self) -> _builtins.str:
        """
        Release date of the firmware version
        """
        return pulumi.get(self, "release_date")

    @_builtins.property
    @pulumi.getter(name="releaseType")
    def release_type(self) -> _builtins.str:
        """
        Release type of the firmware version
        """
        return pulumi.get(self, "release_type")

    @_builtins.property
    @pulumi.getter(name="shortName")
    def short_name(self) -> _builtins.str:
        """
        Firmware version short name
        """
        return pulumi.get(self, "short_name")


@pulumi.output_type
class GetFirmwareUpgradesByDeviceItemUpgradeStagedResult(dict):
    def __init__(__self__, *,
                 group: 'outputs.GetFirmwareUpgradesByDeviceItemUpgradeStagedGroupResult'):
        """
        :param 'GetFirmwareUpgradesByDeviceItemUpgradeStagedGroupArgs' group: The staged upgrade group
        """
        pulumi.set(__self__, "group", group)

    @_builtins.property
    @pulumi.getter
    def group(self) -> 'outputs.GetFirmwareUpgradesByDeviceItemUpgradeStagedGroupResult':
        """
        The staged upgrade group
        """
        return pulumi.get(self, "group")


@pulumi.output_type
class GetFirmwareUpgradesByDeviceItemUpgradeStagedGroupResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: Id of the staged upgrade group
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Id of the staged upgrade group
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetFirmwareUpgradesByDeviceItemUpgradeToVersionResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 release_date: _builtins.str,
                 release_type: _builtins.str,
                 short_name: _builtins.str):
        """
        :param _builtins.str id: ID of the initial firmware version
        :param _builtins.str release_date: Release date of the firmware version
        :param _builtins.str release_type: Release type of the firmware version
        :param _builtins.str short_name: Firmware version short name
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "release_date", release_date)
        pulumi.set(__self__, "release_type", release_type)
        pulumi.set(__self__, "short_name", short_name)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID of the initial firmware version
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="releaseDate")
    def release_date(self) -> _builtins.str:
        """
        Release date of the firmware version
        """
        return pulumi.get(self, "release_date")

    @_builtins.property
    @pulumi.getter(name="releaseType")
    def release_type(self) -> _builtins.str:
        """
        Release type of the firmware version
        """
        return pulumi.get(self, "release_type")

    @_builtins.property
    @pulumi.getter(name="shortName")
    def short_name(self) -> _builtins.str:
        """
        Firmware version short name
        """
        return pulumi.get(self, "short_name")


@pulumi.output_type
class GetFirmwareUpgradesItemResult(dict):
    def __init__(__self__, *,
                 completed_at: _builtins.str,
                 from_version: 'outputs.GetFirmwareUpgradesItemFromVersionResult',
                 network: 'outputs.GetFirmwareUpgradesItemNetworkResult',
                 product_types: _builtins.str,
                 status: _builtins.str,
                 time: _builtins.str,
                 to_version: 'outputs.GetFirmwareUpgradesItemToVersionResult',
                 upgrade_batch_id: _builtins.str,
                 upgrade_id: _builtins.str):
        """
        :param _builtins.str completed_at: Timestamp when upgrade completed. Null if status pending.
        :param 'GetFirmwareUpgradesItemFromVersionArgs' from_version: ID of the upgrade's starting version
        :param 'GetFirmwareUpgradesItemNetworkArgs' network: Network of the upgrade
        :param _builtins.str product_types: product upgraded [wireless, appliance, switch, systemsManager, camera, cellularGateway, sensor]
        :param _builtins.str status: Status of upgrade event: [Cancelled, Completed]
        :param _builtins.str time: Scheduled start time
        :param 'GetFirmwareUpgradesItemToVersionArgs' to_version: ID of the upgrade's target version
        :param _builtins.str upgrade_batch_id: The upgrade batch
        :param _builtins.str upgrade_id: The upgrade
        """
        pulumi.set(__self__, "completed_at", completed_at)
        pulumi.set(__self__, "from_version", from_version)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "product_types", product_types)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "time", time)
        pulumi.set(__self__, "to_version", to_version)
        pulumi.set(__self__, "upgrade_batch_id", upgrade_batch_id)
        pulumi.set(__self__, "upgrade_id", upgrade_id)

    @_builtins.property
    @pulumi.getter(name="completedAt")
    def completed_at(self) -> _builtins.str:
        """
        Timestamp when upgrade completed. Null if status pending.
        """
        return pulumi.get(self, "completed_at")

    @_builtins.property
    @pulumi.getter(name="fromVersion")
    def from_version(self) -> 'outputs.GetFirmwareUpgradesItemFromVersionResult':
        """
        ID of the upgrade's starting version
        """
        return pulumi.get(self, "from_version")

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetFirmwareUpgradesItemNetworkResult':
        """
        Network of the upgrade
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter(name="productTypes")
    def product_types(self) -> _builtins.str:
        """
        product upgraded [wireless, appliance, switch, systemsManager, camera, cellularGateway, sensor]
        """
        return pulumi.get(self, "product_types")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        Status of upgrade event: [Cancelled, Completed]
        """
        return pulumi.get(self, "status")

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

    @_builtins.property
    @pulumi.getter(name="toVersion")
    def to_version(self) -> 'outputs.GetFirmwareUpgradesItemToVersionResult':
        """
        ID of the upgrade's target version
        """
        return pulumi.get(self, "to_version")

    @_builtins.property
    @pulumi.getter(name="upgradeBatchId")
    def upgrade_batch_id(self) -> _builtins.str:
        """
        The upgrade batch
        """
        return pulumi.get(self, "upgrade_batch_id")

    @_builtins.property
    @pulumi.getter(name="upgradeId")
    def upgrade_id(self) -> _builtins.str:
        """
        The upgrade
        """
        return pulumi.get(self, "upgrade_id")


@pulumi.output_type
class GetFirmwareUpgradesItemFromVersionResult(dict):
    def __init__(__self__, *,
                 firmware: _builtins.str,
                 id: _builtins.str,
                 release_date: _builtins.str,
                 release_type: _builtins.str,
                 short_name: _builtins.str):
        """
        :param _builtins.str firmware: Firmware name
        :param _builtins.str id: Firmware version ID
        :param _builtins.str release_date: Release date of the firmware version
        :param _builtins.str release_type: Release type of the firmware version
        :param _builtins.str short_name: Firmware version short name
        """
        pulumi.set(__self__, "firmware", firmware)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "release_date", release_date)
        pulumi.set(__self__, "release_type", release_type)
        pulumi.set(__self__, "short_name", short_name)

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Firmware version ID
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="releaseDate")
    def release_date(self) -> _builtins.str:
        """
        Release date of the firmware version
        """
        return pulumi.get(self, "release_date")

    @_builtins.property
    @pulumi.getter(name="releaseType")
    def release_type(self) -> _builtins.str:
        """
        Release type of the firmware version
        """
        return pulumi.get(self, "release_type")

    @_builtins.property
    @pulumi.getter(name="shortName")
    def short_name(self) -> _builtins.str:
        """
        Firmware version short name
        """
        return pulumi.get(self, "short_name")


@pulumi.output_type
class GetFirmwareUpgradesItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: ID of network
        :param _builtins.str name: The network
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID of network
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetFirmwareUpgradesItemToVersionResult(dict):
    def __init__(__self__, *,
                 firmware: _builtins.str,
                 id: _builtins.str,
                 release_date: _builtins.str,
                 release_type: _builtins.str,
                 short_name: _builtins.str):
        """
        :param _builtins.str firmware: Firmware name
        :param _builtins.str id: Firmware version ID
        :param _builtins.str release_date: Release date of the firmware version
        :param _builtins.str release_type: Release type of the firmware version
        :param _builtins.str short_name: Firmware version short name
        """
        pulumi.set(__self__, "firmware", firmware)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "release_date", release_date)
        pulumi.set(__self__, "release_type", release_type)
        pulumi.set(__self__, "short_name", short_name)

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Firmware version ID
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="releaseDate")
    def release_date(self) -> _builtins.str:
        """
        Release date of the firmware version
        """
        return pulumi.get(self, "release_date")

    @_builtins.property
    @pulumi.getter(name="releaseType")
    def release_type(self) -> _builtins.str:
        """
        Release type of the firmware version
        """
        return pulumi.get(self, "release_type")

    @_builtins.property
    @pulumi.getter(name="shortName")
    def short_name(self) -> _builtins.str:
        """
        Firmware version short name
        """
        return pulumi.get(self, "short_name")


@pulumi.output_type
class GetInsightApplicationsItemResult(dict):
    def __init__(__self__, *,
                 application_id: _builtins.str,
                 name: _builtins.str,
                 thresholds: 'outputs.GetInsightApplicationsItemThresholdsResult'):
        """
        :param _builtins.str application_id: Application identifier
        :param _builtins.str name: Application name
        :param 'GetInsightApplicationsItemThresholdsArgs' thresholds: Thresholds defined by a user or Meraki models for each application
        """
        pulumi.set(__self__, "application_id", application_id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "thresholds", thresholds)

    @_builtins.property
    @pulumi.getter(name="applicationId")
    def application_id(self) -> _builtins.str:
        """
        Application identifier
        """
        return pulumi.get(self, "application_id")

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

    @_builtins.property
    @pulumi.getter
    def thresholds(self) -> 'outputs.GetInsightApplicationsItemThresholdsResult':
        """
        Thresholds defined by a user or Meraki models for each application
        """
        return pulumi.get(self, "thresholds")


@pulumi.output_type
class GetInsightApplicationsItemThresholdsResult(dict):
    def __init__(__self__, *,
                 by_networks: Sequence['outputs.GetInsightApplicationsItemThresholdsByNetworkResult'],
                 type: _builtins.str):
        """
        :param Sequence['GetInsightApplicationsItemThresholdsByNetworkArgs'] by_networks: Threshold for each network
        :param _builtins.str type: Threshold type (static or smart)
        """
        pulumi.set(__self__, "by_networks", by_networks)
        pulumi.set(__self__, "type", type)

    @_builtins.property
    @pulumi.getter(name="byNetworks")
    def by_networks(self) -> Sequence['outputs.GetInsightApplicationsItemThresholdsByNetworkResult']:
        """
        Threshold for each network
        """
        return pulumi.get(self, "by_networks")

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


@pulumi.output_type
class GetInsightApplicationsItemThresholdsByNetworkResult(dict):
    def __init__(__self__, *,
                 goodput: _builtins.int,
                 network_id: _builtins.str,
                 response_duration: _builtins.int):
        """
        :param _builtins.int goodput: Number of useful information bits delivered over a network per unit of time
        :param _builtins.str network_id: Network identifier
        :param _builtins.int response_duration: Duration of the response, in milliseconds
        """
        pulumi.set(__self__, "goodput", goodput)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "response_duration", response_duration)

    @_builtins.property
    @pulumi.getter
    def goodput(self) -> _builtins.int:
        """
        Number of useful information bits delivered over a network per unit of time
        """
        return pulumi.get(self, "goodput")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        Network identifier
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="responseDuration")
    def response_duration(self) -> _builtins.int:
        """
        Duration of the response, in milliseconds
        """
        return pulumi.get(self, "response_duration")


@pulumi.output_type
class GetInsightMonitoredMediaServersItemResult(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 best_effort_monitoring_enabled: _builtins.bool,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str address: The IP address (IPv4 only) or hostname of the media server to monitor
        :param _builtins.bool best_effort_monitoring_enabled: Indicates that if the media server doesn't respond to ICMP pings, the nearest hop will be used in its stead
        :param _builtins.str id: Monitored media server id
        :param _builtins.str name: The name of the VoIP provider
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "best_effort_monitoring_enabled", best_effort_monitoring_enabled)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def address(self) -> _builtins.str:
        """
        The IP address (IPv4 only) or hostname of the media server to monitor
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter(name="bestEffortMonitoringEnabled")
    def best_effort_monitoring_enabled(self) -> _builtins.bool:
        """
        Indicates that if the media server doesn't respond to ICMP pings, the nearest hop will be used in its stead
        """
        return pulumi.get(self, "best_effort_monitoring_enabled")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Monitored media server id
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetInventoryDevicesItemResult(dict):
    def __init__(__self__, *,
                 claimed_at: _builtins.str,
                 country_code: _builtins.str,
                 details: Sequence['outputs.GetInventoryDevicesItemDetailResult'],
                 license_expiration_date: _builtins.str,
                 mac: _builtins.str,
                 model: _builtins.str,
                 name: _builtins.str,
                 network_id: _builtins.str,
                 order_number: _builtins.str,
                 product_type: _builtins.str,
                 serial: _builtins.str,
                 tags: Sequence[_builtins.str]):
        """
        :param _builtins.str claimed_at: Claimed time of the device
        :param _builtins.str country_code: Country/region code from device, network, or store order
        :param Sequence['GetInventoryDevicesItemDetailArgs'] details: Additional device information
        :param _builtins.str license_expiration_date: License expiration date of the device
        :param _builtins.str mac: MAC address of the device
        :param _builtins.str model: Model type of the device
        :param _builtins.str name: Name of the device
        :param _builtins.str network_id: Network Id of the device
        :param _builtins.str order_number: Order number of the device
        :param _builtins.str product_type: Product type of the device
        :param _builtins.str serial: Serial number of the device
        :param Sequence[_builtins.str] tags: Device tags
        """
        pulumi.set(__self__, "claimed_at", claimed_at)
        pulumi.set(__self__, "country_code", country_code)
        pulumi.set(__self__, "details", details)
        pulumi.set(__self__, "license_expiration_date", license_expiration_date)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "order_number", order_number)
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "tags", tags)

    @_builtins.property
    @pulumi.getter(name="claimedAt")
    def claimed_at(self) -> _builtins.str:
        """
        Claimed time of the device
        """
        return pulumi.get(self, "claimed_at")

    @_builtins.property
    @pulumi.getter(name="countryCode")
    def country_code(self) -> _builtins.str:
        """
        Country/region code from device, network, or store order
        """
        return pulumi.get(self, "country_code")

    @_builtins.property
    @pulumi.getter
    def details(self) -> Sequence['outputs.GetInventoryDevicesItemDetailResult']:
        """
        Additional device information
        """
        return pulumi.get(self, "details")

    @_builtins.property
    @pulumi.getter(name="licenseExpirationDate")
    def license_expiration_date(self) -> _builtins.str:
        """
        License expiration date of the device
        """
        return pulumi.get(self, "license_expiration_date")

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

    @_builtins.property
    @pulumi.getter
    def model(self) -> _builtins.str:
        """
        Model type of the device
        """
        return pulumi.get(self, "model")

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

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        Network Id of the device
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="orderNumber")
    def order_number(self) -> _builtins.str:
        """
        Order number of the device
        """
        return pulumi.get(self, "order_number")

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Product type of the device
        """
        return pulumi.get(self, "product_type")

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

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


@pulumi.output_type
class GetInventoryDevicesItemDetailResult(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 value: _builtins.str):
        """
        :param _builtins.str name: Additional property name
        :param _builtins.str value: Additional property value
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class GetInventoryOnboardingCloudMonitoringImportsItemResult(dict):
    def __init__(__self__, *,
                 device: 'outputs.GetInventoryOnboardingCloudMonitoringImportsItemDeviceResult',
                 import_id: _builtins.str):
        """
        :param 'GetInventoryOnboardingCloudMonitoringImportsItemDeviceArgs' device: Represents the details of an imported device.
        :param _builtins.str import_id: Database ID for the new entity entry.
        """
        pulumi.set(__self__, "device", device)
        pulumi.set(__self__, "import_id", import_id)

    @_builtins.property
    @pulumi.getter
    def device(self) -> 'outputs.GetInventoryOnboardingCloudMonitoringImportsItemDeviceResult':
        """
        Represents the details of an imported device.
        """
        return pulumi.get(self, "device")

    @_builtins.property
    @pulumi.getter(name="importId")
    def import_id(self) -> _builtins.str:
        """
        Database ID for the new entity entry.
        """
        return pulumi.get(self, "import_id")


@pulumi.output_type
class GetInventoryOnboardingCloudMonitoringImportsItemDeviceResult(dict):
    def __init__(__self__, *,
                 created: _builtins.bool,
                 status: _builtins.str,
                 url: _builtins.str):
        """
        :param _builtins.bool created: Whether or not the device was successfully created in dashboard.
        :param _builtins.str status: Represents the current state of importing the device.
        :param _builtins.str url: The url to the device details page within dashboard.
        """
        pulumi.set(__self__, "created", created)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter
    def created(self) -> _builtins.bool:
        """
        Whether or not the device was successfully created in dashboard.
        """
        return pulumi.get(self, "created")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        Represents the current state of importing the device.
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        The url to the device details page within dashboard.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetInventoryOnboardingCloudMonitoringNetworksItemResult(dict):
    def __init__(__self__, *,
                 enrollment_string: _builtins.str,
                 id: _builtins.str,
                 is_bound_to_config_template: _builtins.bool,
                 name: _builtins.str,
                 notes: _builtins.str,
                 organization_id: _builtins.str,
                 product_types: Sequence[_builtins.str],
                 tags: Sequence[_builtins.str],
                 time_zone: _builtins.str,
                 url: _builtins.str):
        """
        :param _builtins.str enrollment_string: Enrollment string for the network
        :param _builtins.str id: Network ID
        :param _builtins.bool is_bound_to_config_template: If the network is bound to a config template
        :param _builtins.str name: Network name
        :param _builtins.str notes: Notes for the network
        :param _builtins.str organization_id: Organization ID
        :param Sequence[_builtins.str] product_types: List of the product types that the network supports
        :param Sequence[_builtins.str] tags: Network tags
        :param _builtins.str time_zone: Timezone of the network
        :param _builtins.str url: URL to the network Dashboard UI
        """
        pulumi.set(__self__, "enrollment_string", enrollment_string)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_bound_to_config_template", is_bound_to_config_template)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "notes", notes)
        pulumi.set(__self__, "organization_id", organization_id)
        pulumi.set(__self__, "product_types", product_types)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "time_zone", time_zone)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="enrollmentString")
    def enrollment_string(self) -> _builtins.str:
        """
        Enrollment string for the network
        """
        return pulumi.get(self, "enrollment_string")

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

    @_builtins.property
    @pulumi.getter(name="isBoundToConfigTemplate")
    def is_bound_to_config_template(self) -> _builtins.bool:
        """
        If the network is bound to a config template
        """
        return pulumi.get(self, "is_bound_to_config_template")

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

    @_builtins.property
    @pulumi.getter
    def notes(self) -> _builtins.str:
        """
        Notes for the network
        """
        return pulumi.get(self, "notes")

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> _builtins.str:
        """
        Organization ID
        """
        return pulumi.get(self, "organization_id")

    @_builtins.property
    @pulumi.getter(name="productTypes")
    def product_types(self) -> Sequence[_builtins.str]:
        """
        List of the product types that the network supports
        """
        return pulumi.get(self, "product_types")

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

    @_builtins.property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> _builtins.str:
        """
        Timezone of the network
        """
        return pulumi.get(self, "time_zone")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        URL to the network Dashboard UI
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetLicensesItemResult(dict):
    def __init__(__self__, *,
                 activation_date: _builtins.str,
                 claim_date: _builtins.str,
                 device_serial: _builtins.str,
                 duration_in_days: _builtins.int,
                 expiration_date: _builtins.str,
                 head_license_id: _builtins.str,
                 id: _builtins.str,
                 license_key: _builtins.str,
                 license_type: _builtins.str,
                 network_id: _builtins.str,
                 order_number: _builtins.str,
                 permanently_queued_licenses: Sequence['outputs.GetLicensesItemPermanentlyQueuedLicenseResult'],
                 seat_count: _builtins.int,
                 state: _builtins.str,
                 total_duration_in_days: _builtins.int):
        """
        :param _builtins.str activation_date: The date the license started burning
        :param _builtins.str claim_date: The date the license was claimed into the organization
        :param _builtins.str device_serial: Serial number of the device the license is assigned to
        :param _builtins.int duration_in_days: The duration of the individual license
        :param _builtins.str expiration_date: The date the license will expire
        :param _builtins.str head_license_id: The id of the head license this license is queued behind. If there is no head license, it returns nil.
        :param _builtins.str id: License ID
        :param _builtins.str license_key: License key
        :param _builtins.str license_type: License type
        :param _builtins.str network_id: ID of the network the license is assigned to
        :param _builtins.str order_number: Order number
        :param Sequence['GetLicensesItemPermanentlyQueuedLicenseArgs'] permanently_queued_licenses: DEPRECATED List of permanently queued licenses attached to the license. Instead, use /organizations/{organizationId}/licenses?deviceSerial= to retrieved queued licenses for a given device.
        :param _builtins.int seat_count: The number of seats of the license. Only applicable to SM licenses.
        :param _builtins.str state: The state of the license. All queued licenses have a status of *recentlyQueued*.
        :param _builtins.int total_duration_in_days: The duration of the license plus all permanently queued licenses associated with it
        """
        pulumi.set(__self__, "activation_date", activation_date)
        pulumi.set(__self__, "claim_date", claim_date)
        pulumi.set(__self__, "device_serial", device_serial)
        pulumi.set(__self__, "duration_in_days", duration_in_days)
        pulumi.set(__self__, "expiration_date", expiration_date)
        pulumi.set(__self__, "head_license_id", head_license_id)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "license_key", license_key)
        pulumi.set(__self__, "license_type", license_type)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "order_number", order_number)
        pulumi.set(__self__, "permanently_queued_licenses", permanently_queued_licenses)
        pulumi.set(__self__, "seat_count", seat_count)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "total_duration_in_days", total_duration_in_days)

    @_builtins.property
    @pulumi.getter(name="activationDate")
    def activation_date(self) -> _builtins.str:
        """
        The date the license started burning
        """
        return pulumi.get(self, "activation_date")

    @_builtins.property
    @pulumi.getter(name="claimDate")
    def claim_date(self) -> _builtins.str:
        """
        The date the license was claimed into the organization
        """
        return pulumi.get(self, "claim_date")

    @_builtins.property
    @pulumi.getter(name="deviceSerial")
    def device_serial(self) -> _builtins.str:
        """
        Serial number of the device the license is assigned to
        """
        return pulumi.get(self, "device_serial")

    @_builtins.property
    @pulumi.getter(name="durationInDays")
    def duration_in_days(self) -> _builtins.int:
        """
        The duration of the individual license
        """
        return pulumi.get(self, "duration_in_days")

    @_builtins.property
    @pulumi.getter(name="expirationDate")
    def expiration_date(self) -> _builtins.str:
        """
        The date the license will expire
        """
        return pulumi.get(self, "expiration_date")

    @_builtins.property
    @pulumi.getter(name="headLicenseId")
    def head_license_id(self) -> _builtins.str:
        """
        The id of the head license this license is queued behind. If there is no head license, it returns nil.
        """
        return pulumi.get(self, "head_license_id")

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

    @_builtins.property
    @pulumi.getter(name="licenseKey")
    def license_key(self) -> _builtins.str:
        """
        License key
        """
        return pulumi.get(self, "license_key")

    @_builtins.property
    @pulumi.getter(name="licenseType")
    def license_type(self) -> _builtins.str:
        """
        License type
        """
        return pulumi.get(self, "license_type")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        ID of the network the license is assigned to
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="orderNumber")
    def order_number(self) -> _builtins.str:
        """
        Order number
        """
        return pulumi.get(self, "order_number")

    @_builtins.property
    @pulumi.getter(name="permanentlyQueuedLicenses")
    def permanently_queued_licenses(self) -> Sequence['outputs.GetLicensesItemPermanentlyQueuedLicenseResult']:
        """
        DEPRECATED List of permanently queued licenses attached to the license. Instead, use /organizations/{organizationId}/licenses?deviceSerial= to retrieved queued licenses for a given device.
        """
        return pulumi.get(self, "permanently_queued_licenses")

    @_builtins.property
    @pulumi.getter(name="seatCount")
    def seat_count(self) -> _builtins.int:
        """
        The number of seats of the license. Only applicable to SM licenses.
        """
        return pulumi.get(self, "seat_count")

    @_builtins.property
    @pulumi.getter
    def state(self) -> _builtins.str:
        """
        The state of the license. All queued licenses have a status of *recentlyQueued*.
        """
        return pulumi.get(self, "state")

    @_builtins.property
    @pulumi.getter(name="totalDurationInDays")
    def total_duration_in_days(self) -> _builtins.int:
        """
        The duration of the license plus all permanently queued licenses associated with it
        """
        return pulumi.get(self, "total_duration_in_days")


@pulumi.output_type
class GetLicensesItemPermanentlyQueuedLicenseResult(dict):
    def __init__(__self__, *,
                 duration_in_days: _builtins.int,
                 id: _builtins.str,
                 license_key: _builtins.str,
                 license_type: _builtins.str,
                 order_number: _builtins.str):
        """
        :param _builtins.int duration_in_days: The duration of the individual license
        :param _builtins.str id: Permanently queued license ID
        :param _builtins.str license_key: License key
        :param _builtins.str license_type: License type
        :param _builtins.str order_number: Order number
        """
        pulumi.set(__self__, "duration_in_days", duration_in_days)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "license_key", license_key)
        pulumi.set(__self__, "license_type", license_type)
        pulumi.set(__self__, "order_number", order_number)

    @_builtins.property
    @pulumi.getter(name="durationInDays")
    def duration_in_days(self) -> _builtins.int:
        """
        The duration of the individual license
        """
        return pulumi.get(self, "duration_in_days")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Permanently queued license ID
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="licenseKey")
    def license_key(self) -> _builtins.str:
        """
        License key
        """
        return pulumi.get(self, "license_key")

    @_builtins.property
    @pulumi.getter(name="licenseType")
    def license_type(self) -> _builtins.str:
        """
        License type
        """
        return pulumi.get(self, "license_type")

    @_builtins.property
    @pulumi.getter(name="orderNumber")
    def order_number(self) -> _builtins.str:
        """
        Order number
        """
        return pulumi.get(self, "order_number")


@pulumi.output_type
class GetLicensesOverviewItemResult(dict):
    def __init__(__self__, *,
                 expiration_date: _builtins.str,
                 license_count: _builtins.int,
                 license_types: Sequence['outputs.GetLicensesOverviewItemLicenseTypeResult'],
                 licensed_device_counts: _builtins.str,
                 states: 'outputs.GetLicensesOverviewItemStatesResult',
                 status: _builtins.str,
                 systems_manager: 'outputs.GetLicensesOverviewItemSystemsManagerResult'):
        """
        :param _builtins.str expiration_date: License expiration date (Co-termination licensing only)
        :param _builtins.int license_count: Total number of licenses (Per-device licensing only)
        :param Sequence['GetLicensesOverviewItemLicenseTypeArgs'] license_types: Data by license type (Per-device licensing only)
        :param _builtins.str licensed_device_counts: License counts (Co-termination licensing only)
        :param 'GetLicensesOverviewItemStatesArgs' states: Aggregated data for licenses by state (Per-device licensing only)
        :param _builtins.str status: License status (Co-termination licensing only)
        :param 'GetLicensesOverviewItemSystemsManagerArgs' systems_manager: Aggregated data for Systems Manager licenses (Per-device licensing only)
        """
        pulumi.set(__self__, "expiration_date", expiration_date)
        pulumi.set(__self__, "license_count", license_count)
        pulumi.set(__self__, "license_types", license_types)
        pulumi.set(__self__, "licensed_device_counts", licensed_device_counts)
        pulumi.set(__self__, "states", states)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "systems_manager", systems_manager)

    @_builtins.property
    @pulumi.getter(name="expirationDate")
    def expiration_date(self) -> _builtins.str:
        """
        License expiration date (Co-termination licensing only)
        """
        return pulumi.get(self, "expiration_date")

    @_builtins.property
    @pulumi.getter(name="licenseCount")
    def license_count(self) -> _builtins.int:
        """
        Total number of licenses (Per-device licensing only)
        """
        return pulumi.get(self, "license_count")

    @_builtins.property
    @pulumi.getter(name="licenseTypes")
    def license_types(self) -> Sequence['outputs.GetLicensesOverviewItemLicenseTypeResult']:
        """
        Data by license type (Per-device licensing only)
        """
        return pulumi.get(self, "license_types")

    @_builtins.property
    @pulumi.getter(name="licensedDeviceCounts")
    def licensed_device_counts(self) -> _builtins.str:
        """
        License counts (Co-termination licensing only)
        """
        return pulumi.get(self, "licensed_device_counts")

    @_builtins.property
    @pulumi.getter
    def states(self) -> 'outputs.GetLicensesOverviewItemStatesResult':
        """
        Aggregated data for licenses by state (Per-device licensing only)
        """
        return pulumi.get(self, "states")

    @_builtins.property
    @pulumi.getter
    def status(self) -> _builtins.str:
        """
        License status (Co-termination licensing only)
        """
        return pulumi.get(self, "status")

    @_builtins.property
    @pulumi.getter(name="systemsManager")
    def systems_manager(self) -> 'outputs.GetLicensesOverviewItemSystemsManagerResult':
        """
        Aggregated data for Systems Manager licenses (Per-device licensing only)
        """
        return pulumi.get(self, "systems_manager")


@pulumi.output_type
class GetLicensesOverviewItemLicenseTypeResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetLicensesOverviewItemLicenseTypeCountsResult',
                 license_type: _builtins.str):
        """
        :param 'GetLicensesOverviewItemLicenseTypeCountsArgs' counts: Aggregated count data for the license type
        :param _builtins.str license_type: License type
        """
        pulumi.set(__self__, "counts", counts)
        pulumi.set(__self__, "license_type", license_type)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> 'outputs.GetLicensesOverviewItemLicenseTypeCountsResult':
        """
        Aggregated count data for the license type
        """
        return pulumi.get(self, "counts")

    @_builtins.property
    @pulumi.getter(name="licenseType")
    def license_type(self) -> _builtins.str:
        """
        License type
        """
        return pulumi.get(self, "license_type")


@pulumi.output_type
class GetLicensesOverviewItemLicenseTypeCountsResult(dict):
    def __init__(__self__, *,
                 unassigned: _builtins.int):
        """
        :param _builtins.int unassigned: The number of unassigned licenses
        """
        pulumi.set(__self__, "unassigned", unassigned)

    @_builtins.property
    @pulumi.getter
    def unassigned(self) -> _builtins.int:
        """
        The number of unassigned licenses
        """
        return pulumi.get(self, "unassigned")


@pulumi.output_type
class GetLicensesOverviewItemStatesResult(dict):
    def __init__(__self__, *,
                 active: 'outputs.GetLicensesOverviewItemStatesActiveResult',
                 expired: 'outputs.GetLicensesOverviewItemStatesExpiredResult',
                 expiring: 'outputs.GetLicensesOverviewItemStatesExpiringResult',
                 recently_queued: 'outputs.GetLicensesOverviewItemStatesRecentlyQueuedResult',
                 unused: 'outputs.GetLicensesOverviewItemStatesUnusedResult',
                 unused_active: 'outputs.GetLicensesOverviewItemStatesUnusedActiveResult'):
        """
        :param 'GetLicensesOverviewItemStatesActiveArgs' active: Data for active licenses
        :param 'GetLicensesOverviewItemStatesExpiredArgs' expired: Data for expired licenses
        :param 'GetLicensesOverviewItemStatesExpiringArgs' expiring: Data for expiring licenses
        :param 'GetLicensesOverviewItemStatesRecentlyQueuedArgs' recently_queued: Data for recently queued licenses
        :param 'GetLicensesOverviewItemStatesUnusedArgs' unused: Data for unused licenses
        :param 'GetLicensesOverviewItemStatesUnusedActiveArgs' unused_active: Data for unused, active licenses
        """
        pulumi.set(__self__, "active", active)
        pulumi.set(__self__, "expired", expired)
        pulumi.set(__self__, "expiring", expiring)
        pulumi.set(__self__, "recently_queued", recently_queued)
        pulumi.set(__self__, "unused", unused)
        pulumi.set(__self__, "unused_active", unused_active)

    @_builtins.property
    @pulumi.getter
    def active(self) -> 'outputs.GetLicensesOverviewItemStatesActiveResult':
        """
        Data for active licenses
        """
        return pulumi.get(self, "active")

    @_builtins.property
    @pulumi.getter
    def expired(self) -> 'outputs.GetLicensesOverviewItemStatesExpiredResult':
        """
        Data for expired licenses
        """
        return pulumi.get(self, "expired")

    @_builtins.property
    @pulumi.getter
    def expiring(self) -> 'outputs.GetLicensesOverviewItemStatesExpiringResult':
        """
        Data for expiring licenses
        """
        return pulumi.get(self, "expiring")

    @_builtins.property
    @pulumi.getter(name="recentlyQueued")
    def recently_queued(self) -> 'outputs.GetLicensesOverviewItemStatesRecentlyQueuedResult':
        """
        Data for recently queued licenses
        """
        return pulumi.get(self, "recently_queued")

    @_builtins.property
    @pulumi.getter
    def unused(self) -> 'outputs.GetLicensesOverviewItemStatesUnusedResult':
        """
        Data for unused licenses
        """
        return pulumi.get(self, "unused")

    @_builtins.property
    @pulumi.getter(name="unusedActive")
    def unused_active(self) -> 'outputs.GetLicensesOverviewItemStatesUnusedActiveResult':
        """
        Data for unused, active licenses
        """
        return pulumi.get(self, "unused_active")


@pulumi.output_type
class GetLicensesOverviewItemStatesActiveResult(dict):
    def __init__(__self__, *,
                 count: _builtins.int):
        """
        :param _builtins.int count: The number of active licenses
        """
        pulumi.set(__self__, "count", count)

    @_builtins.property
    @pulumi.getter
    def count(self) -> _builtins.int:
        """
        The number of active licenses
        """
        return pulumi.get(self, "count")


@pulumi.output_type
class GetLicensesOverviewItemStatesExpiredResult(dict):
    def __init__(__self__, *,
                 count: _builtins.int):
        """
        :param _builtins.int count: The number of expired licenses
        """
        pulumi.set(__self__, "count", count)

    @_builtins.property
    @pulumi.getter
    def count(self) -> _builtins.int:
        """
        The number of expired licenses
        """
        return pulumi.get(self, "count")


@pulumi.output_type
class GetLicensesOverviewItemStatesExpiringResult(dict):
    def __init__(__self__, *,
                 count: _builtins.int,
                 critical: 'outputs.GetLicensesOverviewItemStatesExpiringCriticalResult',
                 warning: 'outputs.GetLicensesOverviewItemStatesExpiringWarningResult'):
        """
        :param _builtins.int count: The number of expiring licenses
        :param 'GetLicensesOverviewItemStatesExpiringCriticalArgs' critical: Data for the critical threshold
        :param 'GetLicensesOverviewItemStatesExpiringWarningArgs' warning: Data for the warning threshold
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "critical", critical)
        pulumi.set(__self__, "warning", warning)

    @_builtins.property
    @pulumi.getter
    def count(self) -> _builtins.int:
        """
        The number of expiring licenses
        """
        return pulumi.get(self, "count")

    @_builtins.property
    @pulumi.getter
    def critical(self) -> 'outputs.GetLicensesOverviewItemStatesExpiringCriticalResult':
        """
        Data for the critical threshold
        """
        return pulumi.get(self, "critical")

    @_builtins.property
    @pulumi.getter
    def warning(self) -> 'outputs.GetLicensesOverviewItemStatesExpiringWarningResult':
        """
        Data for the warning threshold
        """
        return pulumi.get(self, "warning")


@pulumi.output_type
class GetLicensesOverviewItemStatesExpiringCriticalResult(dict):
    def __init__(__self__, *,
                 expiring_count: _builtins.int,
                 threshold_in_days: _builtins.int):
        """
        :param _builtins.int expiring_count: The number of licenses that will expire in this window
        :param _builtins.int threshold_in_days: The number of days from now denoting the critical threshold for an expiring license
        """
        pulumi.set(__self__, "expiring_count", expiring_count)
        pulumi.set(__self__, "threshold_in_days", threshold_in_days)

    @_builtins.property
    @pulumi.getter(name="expiringCount")
    def expiring_count(self) -> _builtins.int:
        """
        The number of licenses that will expire in this window
        """
        return pulumi.get(self, "expiring_count")

    @_builtins.property
    @pulumi.getter(name="thresholdInDays")
    def threshold_in_days(self) -> _builtins.int:
        """
        The number of days from now denoting the critical threshold for an expiring license
        """
        return pulumi.get(self, "threshold_in_days")


@pulumi.output_type
class GetLicensesOverviewItemStatesExpiringWarningResult(dict):
    def __init__(__self__, *,
                 expiring_count: _builtins.int,
                 threshold_in_days: _builtins.int):
        """
        :param _builtins.int expiring_count: The number of licenses that will expire in this window
        :param _builtins.int threshold_in_days: The number of days from now denoting the warning threshold for an expiring license
        """
        pulumi.set(__self__, "expiring_count", expiring_count)
        pulumi.set(__self__, "threshold_in_days", threshold_in_days)

    @_builtins.property
    @pulumi.getter(name="expiringCount")
    def expiring_count(self) -> _builtins.int:
        """
        The number of licenses that will expire in this window
        """
        return pulumi.get(self, "expiring_count")

    @_builtins.property
    @pulumi.getter(name="thresholdInDays")
    def threshold_in_days(self) -> _builtins.int:
        """
        The number of days from now denoting the warning threshold for an expiring license
        """
        return pulumi.get(self, "threshold_in_days")


@pulumi.output_type
class GetLicensesOverviewItemStatesRecentlyQueuedResult(dict):
    def __init__(__self__, *,
                 count: _builtins.int):
        """
        :param _builtins.int count: The number of recently queued licenses
        """
        pulumi.set(__self__, "count", count)

    @_builtins.property
    @pulumi.getter
    def count(self) -> _builtins.int:
        """
        The number of recently queued licenses
        """
        return pulumi.get(self, "count")


@pulumi.output_type
class GetLicensesOverviewItemStatesUnusedResult(dict):
    def __init__(__self__, *,
                 count: _builtins.int,
                 soonest_activation: 'outputs.GetLicensesOverviewItemStatesUnusedSoonestActivationResult'):
        """
        :param _builtins.int count: The number of unused licenses
        :param 'GetLicensesOverviewItemStatesUnusedSoonestActivationArgs' soonest_activation: Information about the soonest forthcoming license activation
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "soonest_activation", soonest_activation)

    @_builtins.property
    @pulumi.getter
    def count(self) -> _builtins.int:
        """
        The number of unused licenses
        """
        return pulumi.get(self, "count")

    @_builtins.property
    @pulumi.getter(name="soonestActivation")
    def soonest_activation(self) -> 'outputs.GetLicensesOverviewItemStatesUnusedSoonestActivationResult':
        """
        Information about the soonest forthcoming license activation
        """
        return pulumi.get(self, "soonest_activation")


@pulumi.output_type
class GetLicensesOverviewItemStatesUnusedActiveResult(dict):
    def __init__(__self__, *,
                 count: _builtins.int,
                 oldest_activation: 'outputs.GetLicensesOverviewItemStatesUnusedActiveOldestActivationResult'):
        """
        :param _builtins.int count: The number of unused, active licenses
        :param 'GetLicensesOverviewItemStatesUnusedActiveOldestActivationArgs' oldest_activation: Information about the oldest historical license activation
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "oldest_activation", oldest_activation)

    @_builtins.property
    @pulumi.getter
    def count(self) -> _builtins.int:
        """
        The number of unused, active licenses
        """
        return pulumi.get(self, "count")

    @_builtins.property
    @pulumi.getter(name="oldestActivation")
    def oldest_activation(self) -> 'outputs.GetLicensesOverviewItemStatesUnusedActiveOldestActivationResult':
        """
        Information about the oldest historical license activation
        """
        return pulumi.get(self, "oldest_activation")


@pulumi.output_type
class GetLicensesOverviewItemStatesUnusedActiveOldestActivationResult(dict):
    def __init__(__self__, *,
                 activation_date: _builtins.str,
                 active_count: _builtins.int):
        """
        :param _builtins.str activation_date: The oldest license activation date
        :param _builtins.int active_count: The number of licenses that activated on this date
        """
        pulumi.set(__self__, "activation_date", activation_date)
        pulumi.set(__self__, "active_count", active_count)

    @_builtins.property
    @pulumi.getter(name="activationDate")
    def activation_date(self) -> _builtins.str:
        """
        The oldest license activation date
        """
        return pulumi.get(self, "activation_date")

    @_builtins.property
    @pulumi.getter(name="activeCount")
    def active_count(self) -> _builtins.int:
        """
        The number of licenses that activated on this date
        """
        return pulumi.get(self, "active_count")


@pulumi.output_type
class GetLicensesOverviewItemStatesUnusedSoonestActivationResult(dict):
    def __init__(__self__, *,
                 activation_date: _builtins.str,
                 to_activate_count: _builtins.int):
        """
        :param _builtins.str activation_date: The soonest license activation date
        :param _builtins.int to_activate_count: The number of licenses that will activate on this date
        """
        pulumi.set(__self__, "activation_date", activation_date)
        pulumi.set(__self__, "to_activate_count", to_activate_count)

    @_builtins.property
    @pulumi.getter(name="activationDate")
    def activation_date(self) -> _builtins.str:
        """
        The soonest license activation date
        """
        return pulumi.get(self, "activation_date")

    @_builtins.property
    @pulumi.getter(name="toActivateCount")
    def to_activate_count(self) -> _builtins.int:
        """
        The number of licenses that will activate on this date
        """
        return pulumi.get(self, "to_activate_count")


@pulumi.output_type
class GetLicensesOverviewItemSystemsManagerResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetLicensesOverviewItemSystemsManagerCountsResult'):
        """
        :param 'GetLicensesOverviewItemSystemsManagerCountsArgs' counts: Aggregated license count data for Systems Manager
        """
        pulumi.set(__self__, "counts", counts)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> 'outputs.GetLicensesOverviewItemSystemsManagerCountsResult':
        """
        Aggregated license count data for Systems Manager
        """
        return pulumi.get(self, "counts")


@pulumi.output_type
class GetLicensesOverviewItemSystemsManagerCountsResult(dict):
    def __init__(__self__, *,
                 active_seats: _builtins.int,
                 orgwide_enrolled_devices: _builtins.int,
                 total_seats: _builtins.int,
                 unassigned_seats: _builtins.int):
        """
        :param _builtins.int active_seats: The number of Systems Manager seats in use
        :param _builtins.int orgwide_enrolled_devices: The total number of enrolled Systems Manager devices
        :param _builtins.int total_seats: The total number of Systems Manager seats
        :param _builtins.int unassigned_seats: The number of unused Systems Manager seats
        """
        pulumi.set(__self__, "active_seats", active_seats)
        pulumi.set(__self__, "orgwide_enrolled_devices", orgwide_enrolled_devices)
        pulumi.set(__self__, "total_seats", total_seats)
        pulumi.set(__self__, "unassigned_seats", unassigned_seats)

    @_builtins.property
    @pulumi.getter(name="activeSeats")
    def active_seats(self) -> _builtins.int:
        """
        The number of Systems Manager seats in use
        """
        return pulumi.get(self, "active_seats")

    @_builtins.property
    @pulumi.getter(name="orgwideEnrolledDevices")
    def orgwide_enrolled_devices(self) -> _builtins.int:
        """
        The total number of enrolled Systems Manager devices
        """
        return pulumi.get(self, "orgwide_enrolled_devices")

    @_builtins.property
    @pulumi.getter(name="totalSeats")
    def total_seats(self) -> _builtins.int:
        """
        The total number of Systems Manager seats
        """
        return pulumi.get(self, "total_seats")

    @_builtins.property
    @pulumi.getter(name="unassignedSeats")
    def unassigned_seats(self) -> _builtins.int:
        """
        The number of unused Systems Manager seats
        """
        return pulumi.get(self, "unassigned_seats")


@pulumi.output_type
class GetLicensingCotermLicensesItemResult(dict):
    def __init__(__self__, *,
                 claimed_at: _builtins.str,
                 counts: Sequence['outputs.GetLicensingCotermLicensesItemCountResult'],
                 duration: _builtins.int,
                 editions: Sequence['outputs.GetLicensingCotermLicensesItemEditionResult'],
                 expired: _builtins.bool,
                 invalidated: _builtins.bool,
                 invalidated_at: _builtins.str,
                 key: _builtins.str,
                 mode: _builtins.str,
                 organization_id: _builtins.str,
                 started_at: _builtins.str):
        """
        :param _builtins.str claimed_at: When the license was claimed into the organization
        :param Sequence['GetLicensingCotermLicensesItemCountArgs'] counts: The counts of the license by model type
        :param _builtins.int duration: The duration (term length) of the license, measured in days
        :param Sequence['GetLicensingCotermLicensesItemEditionArgs'] editions: The editions of the license for each relevant product type
        :param _builtins.bool expired: Flag to indicate if the license is expired
        :param _builtins.bool invalidated: Flag to indicated that the license is invalidated
        :param _builtins.str invalidated_at: When the license was invalidated. Will be null for active licenses
        :param _builtins.str key: The key of the license
        :param _builtins.str mode: The operation mode of the license when it was claimed
        :param _builtins.str organization_id: The ID of the organization that the license is claimed in
        :param _builtins.str started_at: When the license's term began (approximately the date when the license was created)
        """
        pulumi.set(__self__, "claimed_at", claimed_at)
        pulumi.set(__self__, "counts", counts)
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "editions", editions)
        pulumi.set(__self__, "expired", expired)
        pulumi.set(__self__, "invalidated", invalidated)
        pulumi.set(__self__, "invalidated_at", invalidated_at)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "organization_id", organization_id)
        pulumi.set(__self__, "started_at", started_at)

    @_builtins.property
    @pulumi.getter(name="claimedAt")
    def claimed_at(self) -> _builtins.str:
        """
        When the license was claimed into the organization
        """
        return pulumi.get(self, "claimed_at")

    @_builtins.property
    @pulumi.getter
    def counts(self) -> Sequence['outputs.GetLicensingCotermLicensesItemCountResult']:
        """
        The counts of the license by model type
        """
        return pulumi.get(self, "counts")

    @_builtins.property
    @pulumi.getter
    def duration(self) -> _builtins.int:
        """
        The duration (term length) of the license, measured in days
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def editions(self) -> Sequence['outputs.GetLicensingCotermLicensesItemEditionResult']:
        """
        The editions of the license for each relevant product type
        """
        return pulumi.get(self, "editions")

    @_builtins.property
    @pulumi.getter
    def expired(self) -> _builtins.bool:
        """
        Flag to indicate if the license is expired
        """
        return pulumi.get(self, "expired")

    @_builtins.property
    @pulumi.getter
    def invalidated(self) -> _builtins.bool:
        """
        Flag to indicated that the license is invalidated
        """
        return pulumi.get(self, "invalidated")

    @_builtins.property
    @pulumi.getter(name="invalidatedAt")
    def invalidated_at(self) -> _builtins.str:
        """
        When the license was invalidated. Will be null for active licenses
        """
        return pulumi.get(self, "invalidated_at")

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

    @_builtins.property
    @pulumi.getter
    def mode(self) -> _builtins.str:
        """
        The operation mode of the license when it was claimed
        """
        return pulumi.get(self, "mode")

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> _builtins.str:
        """
        The ID of the organization that the license is claimed in
        """
        return pulumi.get(self, "organization_id")

    @_builtins.property
    @pulumi.getter(name="startedAt")
    def started_at(self) -> _builtins.str:
        """
        When the license's term began (approximately the date when the license was created)
        """
        return pulumi.get(self, "started_at")


@pulumi.output_type
class GetLicensingCotermLicensesItemCountResult(dict):
    def __init__(__self__, *,
                 count: _builtins.int,
                 model: _builtins.str):
        """
        :param _builtins.int count: The number of counts the license contains of this model
        :param _builtins.str model: The license model type
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "model", model)

    @_builtins.property
    @pulumi.getter
    def count(self) -> _builtins.int:
        """
        The number of counts the license contains of this model
        """
        return pulumi.get(self, "count")

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


@pulumi.output_type
class GetLicensingCotermLicensesItemEditionResult(dict):
    def __init__(__self__, *,
                 edition: _builtins.str,
                 product_type: _builtins.str):
        """
        :param _builtins.str edition: The name of the license edition
        :param _builtins.str product_type: The product type of the license edition
        """
        pulumi.set(__self__, "edition", edition)
        pulumi.set(__self__, "product_type", product_type)

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

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        The product type of the license edition
        """
        return pulumi.get(self, "product_type")


@pulumi.output_type
class GetLoginSecurityItemResult(dict):
    def __init__(__self__, *,
                 account_lockout_attempts: _builtins.int,
                 api_authentication: 'outputs.GetLoginSecurityItemApiAuthenticationResult',
                 enforce_account_lockout: _builtins.bool,
                 enforce_different_passwords: _builtins.bool,
                 enforce_idle_timeout: _builtins.bool,
                 enforce_login_ip_ranges: _builtins.bool,
                 enforce_password_expiration: _builtins.bool,
                 enforce_strong_passwords: _builtins.bool,
                 enforce_two_factor_auth: _builtins.bool,
                 idle_timeout_minutes: _builtins.int,
                 login_ip_ranges: Sequence[_builtins.str],
                 num_different_passwords: _builtins.int,
                 password_expiration_days: _builtins.int):
        """
        :param _builtins.int account_lockout_attempts: Number of consecutive failed login attempts after which users' accounts will be locked.
        :param 'GetLoginSecurityItemApiAuthenticationArgs' api_authentication: Details for indicating whether organization will restrict access to API (but not Dashboard) to certain IP addresses.
        :param _builtins.bool enforce_account_lockout: Boolean indicating whether users' Dashboard accounts will be locked out after a specified number of consecutive failed login attempts.
        :param _builtins.bool enforce_different_passwords: Boolean indicating whether users, when setting a new password, are forced to choose a new password that is different from any past passwords.
        :param _builtins.bool enforce_idle_timeout: Boolean indicating whether users will be logged out after being idle for the specified number of minutes.
        :param _builtins.bool enforce_login_ip_ranges: Boolean indicating whether organization will restrict access to Dashboard (including the API) from certain IP addresses.
        :param _builtins.bool enforce_password_expiration: Boolean indicating whether users are forced to change their password every X number of days.
        :param _builtins.bool enforce_strong_passwords: Boolean indicating whether users will be forced to choose strong passwords for their accounts. Strong passwords are at least 8 characters that contain 3 of the following: number, uppercase letter, lowercase letter, and symbol
        :param _builtins.bool enforce_two_factor_auth: Boolean indicating whether users in this organization will be required to use an extra verification code when logging in to Dashboard. This code will be sent to their mobile phone via SMS, or can be generated by the authenticator application.
        :param _builtins.int idle_timeout_minutes: Number of minutes users can remain idle before being logged out of their accounts.
        :param Sequence[_builtins.str] login_ip_ranges: List of acceptable IP ranges. Entries can be single IP addresses, IP address ranges, and CIDR subnets.
        :param _builtins.int num_different_passwords: Number of recent passwords that new password must be distinct from.
        :param _builtins.int password_expiration_days: Number of days after which users will be forced to change their password.
        """
        pulumi.set(__self__, "account_lockout_attempts", account_lockout_attempts)
        pulumi.set(__self__, "api_authentication", api_authentication)
        pulumi.set(__self__, "enforce_account_lockout", enforce_account_lockout)
        pulumi.set(__self__, "enforce_different_passwords", enforce_different_passwords)
        pulumi.set(__self__, "enforce_idle_timeout", enforce_idle_timeout)
        pulumi.set(__self__, "enforce_login_ip_ranges", enforce_login_ip_ranges)
        pulumi.set(__self__, "enforce_password_expiration", enforce_password_expiration)
        pulumi.set(__self__, "enforce_strong_passwords", enforce_strong_passwords)
        pulumi.set(__self__, "enforce_two_factor_auth", enforce_two_factor_auth)
        pulumi.set(__self__, "idle_timeout_minutes", idle_timeout_minutes)
        pulumi.set(__self__, "login_ip_ranges", login_ip_ranges)
        pulumi.set(__self__, "num_different_passwords", num_different_passwords)
        pulumi.set(__self__, "password_expiration_days", password_expiration_days)

    @_builtins.property
    @pulumi.getter(name="accountLockoutAttempts")
    def account_lockout_attempts(self) -> _builtins.int:
        """
        Number of consecutive failed login attempts after which users' accounts will be locked.
        """
        return pulumi.get(self, "account_lockout_attempts")

    @_builtins.property
    @pulumi.getter(name="apiAuthentication")
    def api_authentication(self) -> 'outputs.GetLoginSecurityItemApiAuthenticationResult':
        """
        Details for indicating whether organization will restrict access to API (but not Dashboard) to certain IP addresses.
        """
        return pulumi.get(self, "api_authentication")

    @_builtins.property
    @pulumi.getter(name="enforceAccountLockout")
    def enforce_account_lockout(self) -> _builtins.bool:
        """
        Boolean indicating whether users' Dashboard accounts will be locked out after a specified number of consecutive failed login attempts.
        """
        return pulumi.get(self, "enforce_account_lockout")

    @_builtins.property
    @pulumi.getter(name="enforceDifferentPasswords")
    def enforce_different_passwords(self) -> _builtins.bool:
        """
        Boolean indicating whether users, when setting a new password, are forced to choose a new password that is different from any past passwords.
        """
        return pulumi.get(self, "enforce_different_passwords")

    @_builtins.property
    @pulumi.getter(name="enforceIdleTimeout")
    def enforce_idle_timeout(self) -> _builtins.bool:
        """
        Boolean indicating whether users will be logged out after being idle for the specified number of minutes.
        """
        return pulumi.get(self, "enforce_idle_timeout")

    @_builtins.property
    @pulumi.getter(name="enforceLoginIpRanges")
    def enforce_login_ip_ranges(self) -> _builtins.bool:
        """
        Boolean indicating whether organization will restrict access to Dashboard (including the API) from certain IP addresses.
        """
        return pulumi.get(self, "enforce_login_ip_ranges")

    @_builtins.property
    @pulumi.getter(name="enforcePasswordExpiration")
    def enforce_password_expiration(self) -> _builtins.bool:
        """
        Boolean indicating whether users are forced to change their password every X number of days.
        """
        return pulumi.get(self, "enforce_password_expiration")

    @_builtins.property
    @pulumi.getter(name="enforceStrongPasswords")
    def enforce_strong_passwords(self) -> _builtins.bool:
        """
        Boolean indicating whether users will be forced to choose strong passwords for their accounts. Strong passwords are at least 8 characters that contain 3 of the following: number, uppercase letter, lowercase letter, and symbol
        """
        return pulumi.get(self, "enforce_strong_passwords")

    @_builtins.property
    @pulumi.getter(name="enforceTwoFactorAuth")
    def enforce_two_factor_auth(self) -> _builtins.bool:
        """
        Boolean indicating whether users in this organization will be required to use an extra verification code when logging in to Dashboard. This code will be sent to their mobile phone via SMS, or can be generated by the authenticator application.
        """
        return pulumi.get(self, "enforce_two_factor_auth")

    @_builtins.property
    @pulumi.getter(name="idleTimeoutMinutes")
    def idle_timeout_minutes(self) -> _builtins.int:
        """
        Number of minutes users can remain idle before being logged out of their accounts.
        """
        return pulumi.get(self, "idle_timeout_minutes")

    @_builtins.property
    @pulumi.getter(name="loginIpRanges")
    def login_ip_ranges(self) -> Sequence[_builtins.str]:
        """
        List of acceptable IP ranges. Entries can be single IP addresses, IP address ranges, and CIDR subnets.
        """
        return pulumi.get(self, "login_ip_ranges")

    @_builtins.property
    @pulumi.getter(name="numDifferentPasswords")
    def num_different_passwords(self) -> _builtins.int:
        """
        Number of recent passwords that new password must be distinct from.
        """
        return pulumi.get(self, "num_different_passwords")

    @_builtins.property
    @pulumi.getter(name="passwordExpirationDays")
    def password_expiration_days(self) -> _builtins.int:
        """
        Number of days after which users will be forced to change their password.
        """
        return pulumi.get(self, "password_expiration_days")


@pulumi.output_type
class GetLoginSecurityItemApiAuthenticationResult(dict):
    def __init__(__self__, *,
                 ip_restrictions_for_keys: 'outputs.GetLoginSecurityItemApiAuthenticationIpRestrictionsForKeysResult'):
        """
        :param 'GetLoginSecurityItemApiAuthenticationIpRestrictionsForKeysArgs' ip_restrictions_for_keys: Details for API-only IP restrictions.
        """
        pulumi.set(__self__, "ip_restrictions_for_keys", ip_restrictions_for_keys)

    @_builtins.property
    @pulumi.getter(name="ipRestrictionsForKeys")
    def ip_restrictions_for_keys(self) -> 'outputs.GetLoginSecurityItemApiAuthenticationIpRestrictionsForKeysResult':
        """
        Details for API-only IP restrictions.
        """
        return pulumi.get(self, "ip_restrictions_for_keys")


@pulumi.output_type
class GetLoginSecurityItemApiAuthenticationIpRestrictionsForKeysResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 ranges: Sequence[_builtins.str]):
        """
        :param _builtins.bool enabled: Boolean indicating whether the organization will restrict API key (not Dashboard GUI) usage to a specific list of IP addresses or CIDR ranges.
        :param Sequence[_builtins.str] ranges: List of acceptable IP ranges. Entries can be single IP addresses, IP address ranges, and CIDR subnets.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "ranges", ranges)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Boolean indicating whether the organization will restrict API key (not Dashboard GUI) usage to a specific list of IP addresses or CIDR ranges.
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def ranges(self) -> Sequence[_builtins.str]:
        """
        List of acceptable IP ranges. Entries can be single IP addresses, IP address ranges, and CIDR subnets.
        """
        return pulumi.get(self, "ranges")


@pulumi.output_type
class GetOpenapiSpecItemResult(dict):
    def __init__(__self__, *,
                 info: 'outputs.GetOpenapiSpecItemInfoResult',
                 openapi: _builtins.str,
                 paths: 'outputs.GetOpenapiSpecItemPathsResult'):
        pulumi.set(__self__, "info", info)
        pulumi.set(__self__, "openapi", openapi)
        pulumi.set(__self__, "paths", paths)

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

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

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


@pulumi.output_type
class GetOpenapiSpecItemInfoResult(dict):
    def __init__(__self__, *,
                 description: _builtins.str,
                 title: _builtins.str,
                 version: _builtins.str):
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "title", title)
        pulumi.set(__self__, "version", version)

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

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

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


@pulumi.output_type
class GetOpenapiSpecItemPathsResult(dict):
    def __init__(__self__, *,
                 organizations: 'outputs.GetOpenapiSpecItemPathsOrganizationsResult'):
        pulumi.set(__self__, "organizations", organizations)

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


@pulumi.output_type
class GetOpenapiSpecItemPathsOrganizationsResult(dict):
    def __init__(__self__, *,
                 get: 'outputs.GetOpenapiSpecItemPathsOrganizationsGetResult'):
        pulumi.set(__self__, "get", get)

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


@pulumi.output_type
class GetOpenapiSpecItemPathsOrganizationsGetResult(dict):
    def __init__(__self__, *,
                 description: _builtins.str,
                 operation_id: _builtins.str,
                 responses: 'outputs.GetOpenapiSpecItemPathsOrganizationsGetResponsesResult'):
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "operation_id", operation_id)
        pulumi.set(__self__, "responses", responses)

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

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

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


@pulumi.output_type
class GetOpenapiSpecItemPathsOrganizationsGetResponsesResult(dict):
    def __init__(__self__, *,
                 status200: 'outputs.GetOpenapiSpecItemPathsOrganizationsGetResponsesStatus200Result'):
        pulumi.set(__self__, "status200", status200)

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


@pulumi.output_type
class GetOpenapiSpecItemPathsOrganizationsGetResponsesStatus200Result(dict):
    def __init__(__self__, *,
                 description: _builtins.str,
                 examples: 'outputs.GetOpenapiSpecItemPathsOrganizationsGetResponsesStatus200ExamplesResult'):
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "examples", examples)

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

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


@pulumi.output_type
class GetOpenapiSpecItemPathsOrganizationsGetResponsesStatus200ExamplesResult(dict):
    def __init__(__self__, *,
                 application_jsons: Sequence['outputs.GetOpenapiSpecItemPathsOrganizationsGetResponsesStatus200ExamplesApplicationJsonResult']):
        pulumi.set(__self__, "application_jsons", application_jsons)

    @_builtins.property
    @pulumi.getter(name="applicationJsons")
    def application_jsons(self) -> Sequence['outputs.GetOpenapiSpecItemPathsOrganizationsGetResponsesStatus200ExamplesApplicationJsonResult']:
        return pulumi.get(self, "application_jsons")


@pulumi.output_type
class GetOpenapiSpecItemPathsOrganizationsGetResponsesStatus200ExamplesApplicationJsonResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetPolicyObjectsGroupsItemResult(dict):
    def __init__(__self__, *,
                 category: _builtins.str,
                 created_at: _builtins.str,
                 id: _builtins.str,
                 name: _builtins.str,
                 network_ids: Sequence[_builtins.str],
                 object_ids: Sequence[_builtins.str],
                 updated_at: _builtins.str):
        """
        :param _builtins.str category: Type of object groups. (NetworkObjectGroup, GeoLocationGroup, PortObjectGroup, ApplicationGroup)
        :param _builtins.str created_at: Time Stamp of policy object creation.
        :param _builtins.str id: Policy object ID
        :param _builtins.str name: Name of the Policy object group.
        :param Sequence[_builtins.str] network_ids: Network ID's associated with the policy objects.
        :param Sequence[_builtins.str] object_ids: Policy objects associated with Network Object Group or Port Object Group
        :param _builtins.str updated_at: Time Stamp of policy object updation.
        """
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_ids", network_ids)
        pulumi.set(__self__, "object_ids", object_ids)
        pulumi.set(__self__, "updated_at", updated_at)

    @_builtins.property
    @pulumi.getter
    def category(self) -> _builtins.str:
        """
        Type of object groups. (NetworkObjectGroup, GeoLocationGroup, PortObjectGroup, ApplicationGroup)
        """
        return pulumi.get(self, "category")

    @_builtins.property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> _builtins.str:
        """
        Time Stamp of policy object creation.
        """
        return pulumi.get(self, "created_at")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Policy object ID
        """
        return pulumi.get(self, "id")

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

    @_builtins.property
    @pulumi.getter(name="networkIds")
    def network_ids(self) -> Sequence[_builtins.str]:
        """
        Network ID's associated with the policy objects.
        """
        return pulumi.get(self, "network_ids")

    @_builtins.property
    @pulumi.getter(name="objectIds")
    def object_ids(self) -> Sequence[_builtins.str]:
        """
        Policy objects associated with Network Object Group or Port Object Group
        """
        return pulumi.get(self, "object_ids")

    @_builtins.property
    @pulumi.getter(name="updatedAt")
    def updated_at(self) -> _builtins.str:
        """
        Time Stamp of policy object updation.
        """
        return pulumi.get(self, "updated_at")


@pulumi.output_type
class GetPolicyObjectsItemResult(dict):
    def __init__(__self__, *,
                 category: _builtins.str,
                 cidr: _builtins.str,
                 created_at: _builtins.str,
                 group_ids: Sequence[_builtins.str],
                 id: _builtins.str,
                 name: _builtins.str,
                 network_ids: Sequence[_builtins.str],
                 type: _builtins.str,
                 updated_at: _builtins.str):
        """
        :param _builtins.str category: Category of a policy object (one of: adaptivePolicy, network)
        :param _builtins.str cidr: CIDR Value of a policy object
        :param _builtins.str created_at: Time Stamp of policy object creation.
        :param Sequence[_builtins.str] group_ids: The IDs of policy object groups the policy object belongs to.
        :param _builtins.str id: Policy object ID
        :param _builtins.str name: Name of policy object (alphanumeric, space, dash, or underscore characters only).
        :param Sequence[_builtins.str] network_ids: The IDs of the networks that use the policy object.
        :param _builtins.str type: Type of a policy object (one of: adaptivePolicyIpv4Cidr, cidr, fqdn, ipAndMask)
        :param _builtins.str updated_at: Time Stamp of policy object updation.
        """
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "cidr", cidr)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "group_ids", group_ids)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_ids", network_ids)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "updated_at", updated_at)

    @_builtins.property
    @pulumi.getter
    def category(self) -> _builtins.str:
        """
        Category of a policy object (one of: adaptivePolicy, network)
        """
        return pulumi.get(self, "category")

    @_builtins.property
    @pulumi.getter
    def cidr(self) -> _builtins.str:
        """
        CIDR Value of a policy object
        """
        return pulumi.get(self, "cidr")

    @_builtins.property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> _builtins.str:
        """
        Time Stamp of policy object creation.
        """
        return pulumi.get(self, "created_at")

    @_builtins.property
    @pulumi.getter(name="groupIds")
    def group_ids(self) -> Sequence[_builtins.str]:
        """
        The IDs of policy object groups the policy object belongs to.
        """
        return pulumi.get(self, "group_ids")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Policy object ID
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        Name of policy object (alphanumeric, space, dash, or underscore characters only).
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="networkIds")
    def network_ids(self) -> Sequence[_builtins.str]:
        """
        The IDs of the networks that use the policy object.
        """
        return pulumi.get(self, "network_ids")

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        Type of a policy object (one of: adaptivePolicyIpv4Cidr, cidr, fqdn, ipAndMask)
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter(name="updatedAt")
    def updated_at(self) -> _builtins.str:
        """
        Time Stamp of policy object updation.
        """
        return pulumi.get(self, "updated_at")


@pulumi.output_type
class GetSamlIdpsItemResult(dict):
    def __init__(__self__, *,
                 consumer_url: _builtins.str,
                 idp_id: _builtins.str,
                 slo_logout_url: _builtins.str,
                 x509cert_sha1_fingerprint: _builtins.str):
        """
        :param _builtins.str consumer_url: URL that is consuming SAML Identity Provider (IdP)
        :param _builtins.str idp_id: ID associated with the SAML Identity Provider (IdP)
        :param _builtins.str slo_logout_url: Dashboard will redirect users to this URL when they sign out.
        :param _builtins.str x509cert_sha1_fingerprint: Fingerprint (SHA1) of the SAML certificate provided by your Identity Provider (IdP). This will be used for encryption / validation.
        """
        pulumi.set(__self__, "consumer_url", consumer_url)
        pulumi.set(__self__, "idp_id", idp_id)
        pulumi.set(__self__, "slo_logout_url", slo_logout_url)
        pulumi.set(__self__, "x509cert_sha1_fingerprint", x509cert_sha1_fingerprint)

    @_builtins.property
    @pulumi.getter(name="consumerUrl")
    def consumer_url(self) -> _builtins.str:
        """
        URL that is consuming SAML Identity Provider (IdP)
        """
        return pulumi.get(self, "consumer_url")

    @_builtins.property
    @pulumi.getter(name="idpId")
    def idp_id(self) -> _builtins.str:
        """
        ID associated with the SAML Identity Provider (IdP)
        """
        return pulumi.get(self, "idp_id")

    @_builtins.property
    @pulumi.getter(name="sloLogoutUrl")
    def slo_logout_url(self) -> _builtins.str:
        """
        Dashboard will redirect users to this URL when they sign out.
        """
        return pulumi.get(self, "slo_logout_url")

    @_builtins.property
    @pulumi.getter(name="x509certSha1Fingerprint")
    def x509cert_sha1_fingerprint(self) -> _builtins.str:
        """
        Fingerprint (SHA1) of the SAML certificate provided by your Identity Provider (IdP). This will be used for encryption / validation.
        """
        return pulumi.get(self, "x509cert_sha1_fingerprint")


@pulumi.output_type
class GetSamlItemResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool):
        """
        :param _builtins.bool enabled: Toggle depicting if SAML SSO settings are enabled
        """
        pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Toggle depicting if SAML SSO settings are enabled
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetSamlRolesItemResult(dict):
    def __init__(__self__, *,
                 cameras: Sequence['outputs.GetSamlRolesItemCameraResult'],
                 id: _builtins.str,
                 networks: Sequence['outputs.GetSamlRolesItemNetworkResult'],
                 org_access: _builtins.str,
                 role: _builtins.str,
                 tags: Sequence['outputs.GetSamlRolesItemTagResult']):
        """
        :param Sequence['GetSamlRolesItemCameraArgs'] cameras: The list of camera access privileges for SAML administrator
        :param _builtins.str id: ID associated with the SAML role
        :param Sequence['GetSamlRolesItemNetworkArgs'] networks: The list of networks that the SAML administrator has privileges on
        :param _builtins.str org_access: The privilege of the SAML administrator on the organization
        :param _builtins.str role: The role of the SAML administrator
        :param Sequence['GetSamlRolesItemTagArgs'] tags: The list of tags that the SAML administrator has privleges on
        """
        pulumi.set(__self__, "cameras", cameras)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "networks", networks)
        pulumi.set(__self__, "org_access", org_access)
        pulumi.set(__self__, "role", role)
        pulumi.set(__self__, "tags", tags)

    @_builtins.property
    @pulumi.getter
    def cameras(self) -> Sequence['outputs.GetSamlRolesItemCameraResult']:
        """
        The list of camera access privileges for SAML administrator
        """
        return pulumi.get(self, "cameras")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID associated with the SAML role
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter
    def networks(self) -> Sequence['outputs.GetSamlRolesItemNetworkResult']:
        """
        The list of networks that the SAML administrator has privileges on
        """
        return pulumi.get(self, "networks")

    @_builtins.property
    @pulumi.getter(name="orgAccess")
    def org_access(self) -> _builtins.str:
        """
        The privilege of the SAML administrator on the organization
        """
        return pulumi.get(self, "org_access")

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

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Sequence['outputs.GetSamlRolesItemTagResult']:
        """
        The list of tags that the SAML administrator has privleges on
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetSamlRolesItemCameraResult(dict):
    def __init__(__self__, *,
                 access: _builtins.str,
                 org_wide: _builtins.bool):
        """
        :param _builtins.str access: Camera access ability
        :param _builtins.bool org_wide: Whether or not SAML administrator has org-wide access
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "org_wide", org_wide)

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

    @_builtins.property
    @pulumi.getter(name="orgWide")
    def org_wide(self) -> _builtins.bool:
        """
        Whether or not SAML administrator has org-wide access
        """
        return pulumi.get(self, "org_wide")


@pulumi.output_type
class GetSamlRolesItemNetworkResult(dict):
    def __init__(__self__, *,
                 access: _builtins.str,
                 id: _builtins.str):
        """
        :param _builtins.str access: The privilege of the SAML administrator on the network
        :param _builtins.str id: The network ID
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def access(self) -> _builtins.str:
        """
        The privilege of the SAML administrator on the network
        """
        return pulumi.get(self, "access")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        The network ID
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSamlRolesItemTagResult(dict):
    def __init__(__self__, *,
                 access: _builtins.str,
                 tag: _builtins.str):
        """
        :param _builtins.str access: The privilege of the SAML administrator on the tag
        :param _builtins.str tag: The name of the tag
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "tag", tag)

    @_builtins.property
    @pulumi.getter
    def access(self) -> _builtins.str:
        """
        The privilege of the SAML administrator on the tag
        """
        return pulumi.get(self, "access")

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


@pulumi.output_type
class GetSensorReadingsHistoryItemResult(dict):
    def __init__(__self__, *,
                 apparent_power: 'outputs.GetSensorReadingsHistoryItemApparentPowerResult',
                 battery: 'outputs.GetSensorReadingsHistoryItemBatteryResult',
                 button: 'outputs.GetSensorReadingsHistoryItemButtonResult',
                 co2: 'outputs.GetSensorReadingsHistoryItemCo2Result',
                 current: 'outputs.GetSensorReadingsHistoryItemCurrentResult',
                 door: 'outputs.GetSensorReadingsHistoryItemDoorResult',
                 downstream_power: 'outputs.GetSensorReadingsHistoryItemDownstreamPowerResult',
                 frequency: 'outputs.GetSensorReadingsHistoryItemFrequencyResult',
                 humidity: 'outputs.GetSensorReadingsHistoryItemHumidityResult',
                 indoor_air_quality: 'outputs.GetSensorReadingsHistoryItemIndoorAirQualityResult',
                 metric: _builtins.str,
                 network: 'outputs.GetSensorReadingsHistoryItemNetworkResult',
                 noise: 'outputs.GetSensorReadingsHistoryItemNoiseResult',
                 pm25: 'outputs.GetSensorReadingsHistoryItemPm25Result',
                 power_factor: 'outputs.GetSensorReadingsHistoryItemPowerFactorResult',
                 real_power: 'outputs.GetSensorReadingsHistoryItemRealPowerResult',
                 remote_lockout_switch: 'outputs.GetSensorReadingsHistoryItemRemoteLockoutSwitchResult',
                 serial: _builtins.str,
                 temperature: 'outputs.GetSensorReadingsHistoryItemTemperatureResult',
                 ts: _builtins.str,
                 tvoc: 'outputs.GetSensorReadingsHistoryItemTvocResult',
                 voltage: 'outputs.GetSensorReadingsHistoryItemVoltageResult',
                 water: 'outputs.GetSensorReadingsHistoryItemWaterResult'):
        """
        :param 'GetSensorReadingsHistoryItemApparentPowerArgs' apparent_power: Reading for the 'apparentPower' metric. This will only be present if the 'metric' property equals 'apparentPower'.
        :param 'GetSensorReadingsHistoryItemBatteryArgs' battery: Reading for the 'battery' metric. This will only be present if the 'metric' property equals 'battery'.
        :param 'GetSensorReadingsHistoryItemButtonArgs' button: Reading for the 'button' metric. This will only be present if the 'metric' property equals 'button'.
        :param 'GetSensorReadingsHistoryItemCo2Args' co2: Reading for the 'co2' metric. This will only be present if the 'metric' property equals 'co2'.
        :param 'GetSensorReadingsHistoryItemCurrentArgs' current: Reading for the 'current' metric. This will only be present if the 'metric' property equals 'current'.
        :param 'GetSensorReadingsHistoryItemDoorArgs' door: Reading for the 'door' metric. This will only be present if the 'metric' property equals 'door'.
        :param 'GetSensorReadingsHistoryItemDownstreamPowerArgs' downstream_power: Reading for the 'downstreamPower' metric. This will only be present if the 'metric' property equals 'downstreamPower'.
        :param 'GetSensorReadingsHistoryItemFrequencyArgs' frequency: Reading for the 'frequency' metric. This will only be present if the 'metric' property equals 'frequency'.
        :param 'GetSensorReadingsHistoryItemHumidityArgs' humidity: Reading for the 'humidity' metric. This will only be present if the 'metric' property equals 'humidity'.
        :param 'GetSensorReadingsHistoryItemIndoorAirQualityArgs' indoor_air_quality: Reading for the 'indoorAirQuality' metric. This will only be present if the 'metric' property equals 'indoorAirQuality'.
        :param _builtins.str metric: Type of sensor reading.
        :param 'GetSensorReadingsHistoryItemNetworkArgs' network: Network to which the sensor belongs.
        :param 'GetSensorReadingsHistoryItemNoiseArgs' noise: Reading for the 'noise' metric. This will only be present if the 'metric' property equals 'noise'.
        :param 'GetSensorReadingsHistoryItemPm25Args' pm25: Reading for the 'pm25' metric. This will only be present if the 'metric' property equals 'pm25'.
        :param 'GetSensorReadingsHistoryItemPowerFactorArgs' power_factor: Reading for the 'powerFactor' metric. This will only be present if the 'metric' property equals 'powerFactor'.
        :param 'GetSensorReadingsHistoryItemRealPowerArgs' real_power: Reading for the 'realPower' metric. This will only be present if the 'metric' property equals 'realPower'.
        :param 'GetSensorReadingsHistoryItemRemoteLockoutSwitchArgs' remote_lockout_switch: Reading for the 'remoteLockoutSwitch' metric. This will only be present if the 'metric' property equals 'remoteLockoutSwitch'.
        :param _builtins.str serial: Serial number of the sensor that took the reading.
        :param 'GetSensorReadingsHistoryItemTemperatureArgs' temperature: Reading for the 'temperature' metric. This will only be present if the 'metric' property equals 'temperature'.
        :param _builtins.str ts: Time at which the reading occurred, in ISO8601 format.
        :param 'GetSensorReadingsHistoryItemTvocArgs' tvoc: Reading for the 'tvoc' metric. This will only be present if the 'metric' property equals 'tvoc'.
        :param 'GetSensorReadingsHistoryItemVoltageArgs' voltage: Reading for the 'voltage' metric. This will only be present if the 'metric' property equals 'voltage'.
        :param 'GetSensorReadingsHistoryItemWaterArgs' water: Reading for the 'water' metric. This will only be present if the 'metric' property equals 'water'.
        """
        pulumi.set(__self__, "apparent_power", apparent_power)
        pulumi.set(__self__, "battery", battery)
        pulumi.set(__self__, "button", button)
        pulumi.set(__self__, "co2", co2)
        pulumi.set(__self__, "current", current)
        pulumi.set(__self__, "door", door)
        pulumi.set(__self__, "downstream_power", downstream_power)
        pulumi.set(__self__, "frequency", frequency)
        pulumi.set(__self__, "humidity", humidity)
        pulumi.set(__self__, "indoor_air_quality", indoor_air_quality)
        pulumi.set(__self__, "metric", metric)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "noise", noise)
        pulumi.set(__self__, "pm25", pm25)
        pulumi.set(__self__, "power_factor", power_factor)
        pulumi.set(__self__, "real_power", real_power)
        pulumi.set(__self__, "remote_lockout_switch", remote_lockout_switch)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "temperature", temperature)
        pulumi.set(__self__, "ts", ts)
        pulumi.set(__self__, "tvoc", tvoc)
        pulumi.set(__self__, "voltage", voltage)
        pulumi.set(__self__, "water", water)

    @_builtins.property
    @pulumi.getter(name="apparentPower")
    def apparent_power(self) -> 'outputs.GetSensorReadingsHistoryItemApparentPowerResult':
        """
        Reading for the 'apparentPower' metric. This will only be present if the 'metric' property equals 'apparentPower'.
        """
        return pulumi.get(self, "apparent_power")

    @_builtins.property
    @pulumi.getter
    def battery(self) -> 'outputs.GetSensorReadingsHistoryItemBatteryResult':
        """
        Reading for the 'battery' metric. This will only be present if the 'metric' property equals 'battery'.
        """
        return pulumi.get(self, "battery")

    @_builtins.property
    @pulumi.getter
    def button(self) -> 'outputs.GetSensorReadingsHistoryItemButtonResult':
        """
        Reading for the 'button' metric. This will only be present if the 'metric' property equals 'button'.
        """
        return pulumi.get(self, "button")

    @_builtins.property
    @pulumi.getter
    def co2(self) -> 'outputs.GetSensorReadingsHistoryItemCo2Result':
        """
        Reading for the 'co2' metric. This will only be present if the 'metric' property equals 'co2'.
        """
        return pulumi.get(self, "co2")

    @_builtins.property
    @pulumi.getter
    def current(self) -> 'outputs.GetSensorReadingsHistoryItemCurrentResult':
        """
        Reading for the 'current' metric. This will only be present if the 'metric' property equals 'current'.
        """
        return pulumi.get(self, "current")

    @_builtins.property
    @pulumi.getter
    def door(self) -> 'outputs.GetSensorReadingsHistoryItemDoorResult':
        """
        Reading for the 'door' metric. This will only be present if the 'metric' property equals 'door'.
        """
        return pulumi.get(self, "door")

    @_builtins.property
    @pulumi.getter(name="downstreamPower")
    def downstream_power(self) -> 'outputs.GetSensorReadingsHistoryItemDownstreamPowerResult':
        """
        Reading for the 'downstreamPower' metric. This will only be present if the 'metric' property equals 'downstreamPower'.
        """
        return pulumi.get(self, "downstream_power")

    @_builtins.property
    @pulumi.getter
    def frequency(self) -> 'outputs.GetSensorReadingsHistoryItemFrequencyResult':
        """
        Reading for the 'frequency' metric. This will only be present if the 'metric' property equals 'frequency'.
        """
        return pulumi.get(self, "frequency")

    @_builtins.property
    @pulumi.getter
    def humidity(self) -> 'outputs.GetSensorReadingsHistoryItemHumidityResult':
        """
        Reading for the 'humidity' metric. This will only be present if the 'metric' property equals 'humidity'.
        """
        return pulumi.get(self, "humidity")

    @_builtins.property
    @pulumi.getter(name="indoorAirQuality")
    def indoor_air_quality(self) -> 'outputs.GetSensorReadingsHistoryItemIndoorAirQualityResult':
        """
        Reading for the 'indoorAirQuality' metric. This will only be present if the 'metric' property equals 'indoorAirQuality'.
        """
        return pulumi.get(self, "indoor_air_quality")

    @_builtins.property
    @pulumi.getter
    def metric(self) -> _builtins.str:
        """
        Type of sensor reading.
        """
        return pulumi.get(self, "metric")

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetSensorReadingsHistoryItemNetworkResult':
        """
        Network to which the sensor belongs.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter
    def noise(self) -> 'outputs.GetSensorReadingsHistoryItemNoiseResult':
        """
        Reading for the 'noise' metric. This will only be present if the 'metric' property equals 'noise'.
        """
        return pulumi.get(self, "noise")

    @_builtins.property
    @pulumi.getter
    def pm25(self) -> 'outputs.GetSensorReadingsHistoryItemPm25Result':
        """
        Reading for the 'pm25' metric. This will only be present if the 'metric' property equals 'pm25'.
        """
        return pulumi.get(self, "pm25")

    @_builtins.property
    @pulumi.getter(name="powerFactor")
    def power_factor(self) -> 'outputs.GetSensorReadingsHistoryItemPowerFactorResult':
        """
        Reading for the 'powerFactor' metric. This will only be present if the 'metric' property equals 'powerFactor'.
        """
        return pulumi.get(self, "power_factor")

    @_builtins.property
    @pulumi.getter(name="realPower")
    def real_power(self) -> 'outputs.GetSensorReadingsHistoryItemRealPowerResult':
        """
        Reading for the 'realPower' metric. This will only be present if the 'metric' property equals 'realPower'.
        """
        return pulumi.get(self, "real_power")

    @_builtins.property
    @pulumi.getter(name="remoteLockoutSwitch")
    def remote_lockout_switch(self) -> 'outputs.GetSensorReadingsHistoryItemRemoteLockoutSwitchResult':
        """
        Reading for the 'remoteLockoutSwitch' metric. This will only be present if the 'metric' property equals 'remoteLockoutSwitch'.
        """
        return pulumi.get(self, "remote_lockout_switch")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        Serial number of the sensor that took the reading.
        """
        return pulumi.get(self, "serial")

    @_builtins.property
    @pulumi.getter
    def temperature(self) -> 'outputs.GetSensorReadingsHistoryItemTemperatureResult':
        """
        Reading for the 'temperature' metric. This will only be present if the 'metric' property equals 'temperature'.
        """
        return pulumi.get(self, "temperature")

    @_builtins.property
    @pulumi.getter
    def ts(self) -> _builtins.str:
        """
        Time at which the reading occurred, in ISO8601 format.
        """
        return pulumi.get(self, "ts")

    @_builtins.property
    @pulumi.getter
    def tvoc(self) -> 'outputs.GetSensorReadingsHistoryItemTvocResult':
        """
        Reading for the 'tvoc' metric. This will only be present if the 'metric' property equals 'tvoc'.
        """
        return pulumi.get(self, "tvoc")

    @_builtins.property
    @pulumi.getter
    def voltage(self) -> 'outputs.GetSensorReadingsHistoryItemVoltageResult':
        """
        Reading for the 'voltage' metric. This will only be present if the 'metric' property equals 'voltage'.
        """
        return pulumi.get(self, "voltage")

    @_builtins.property
    @pulumi.getter
    def water(self) -> 'outputs.GetSensorReadingsHistoryItemWaterResult':
        """
        Reading for the 'water' metric. This will only be present if the 'metric' property equals 'water'.
        """
        return pulumi.get(self, "water")


@pulumi.output_type
class GetSensorReadingsHistoryItemApparentPowerResult(dict):
    def __init__(__self__, *,
                 draw: _builtins.float):
        """
        :param _builtins.float draw: Apparent power reading in volt-amperes.
        """
        pulumi.set(__self__, "draw", draw)

    @_builtins.property
    @pulumi.getter
    def draw(self) -> _builtins.float:
        """
        Apparent power reading in volt-amperes.
        """
        return pulumi.get(self, "draw")


@pulumi.output_type
class GetSensorReadingsHistoryItemBatteryResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.int):
        """
        :param _builtins.int percentage: Remaining battery life.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.int:
        """
        Remaining battery life.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetSensorReadingsHistoryItemButtonResult(dict):
    def __init__(__self__, *,
                 press_type: _builtins.str):
        """
        :param _builtins.str press_type: Type of button press that occurred.
        """
        pulumi.set(__self__, "press_type", press_type)

    @_builtins.property
    @pulumi.getter(name="pressType")
    def press_type(self) -> _builtins.str:
        """
        Type of button press that occurred.
        """
        return pulumi.get(self, "press_type")


@pulumi.output_type
class GetSensorReadingsHistoryItemCo2Result(dict):
    def __init__(__self__, *,
                 concentration: _builtins.int):
        """
        :param _builtins.int concentration: CO2 reading in parts per million.
        """
        pulumi.set(__self__, "concentration", concentration)

    @_builtins.property
    @pulumi.getter
    def concentration(self) -> _builtins.int:
        """
        CO2 reading in parts per million.
        """
        return pulumi.get(self, "concentration")


@pulumi.output_type
class GetSensorReadingsHistoryItemCurrentResult(dict):
    def __init__(__self__, *,
                 draw: _builtins.float):
        """
        :param _builtins.float draw: Electrical current reading in amperes.
        """
        pulumi.set(__self__, "draw", draw)

    @_builtins.property
    @pulumi.getter
    def draw(self) -> _builtins.float:
        """
        Electrical current reading in amperes.
        """
        return pulumi.get(self, "draw")


@pulumi.output_type
class GetSensorReadingsHistoryItemDoorResult(dict):
    def __init__(__self__, *,
                 open: _builtins.bool):
        """
        :param _builtins.bool open: True if the door is open.
        """
        pulumi.set(__self__, "open", open)

    @_builtins.property
    @pulumi.getter
    def open(self) -> _builtins.bool:
        """
        True if the door is open.
        """
        return pulumi.get(self, "open")


@pulumi.output_type
class GetSensorReadingsHistoryItemDownstreamPowerResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool):
        """
        :param _builtins.bool enabled: True if power is turned on to the device that is connected downstream of the MT40 power monitor.
        """
        pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        True if power is turned on to the device that is connected downstream of the MT40 power monitor.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetSensorReadingsHistoryItemFrequencyResult(dict):
    def __init__(__self__, *,
                 level: _builtins.float):
        """
        :param _builtins.float level: Electrical current frequency reading in hertz.
        """
        pulumi.set(__self__, "level", level)

    @_builtins.property
    @pulumi.getter
    def level(self) -> _builtins.float:
        """
        Electrical current frequency reading in hertz.
        """
        return pulumi.get(self, "level")


@pulumi.output_type
class GetSensorReadingsHistoryItemHumidityResult(dict):
    def __init__(__self__, *,
                 relative_percentage: _builtins.int):
        """
        :param _builtins.int relative_percentage: Humidity reading in %RH.
        """
        pulumi.set(__self__, "relative_percentage", relative_percentage)

    @_builtins.property
    @pulumi.getter(name="relativePercentage")
    def relative_percentage(self) -> _builtins.int:
        """
        Humidity reading in %RH.
        """
        return pulumi.get(self, "relative_percentage")


@pulumi.output_type
class GetSensorReadingsHistoryItemIndoorAirQualityResult(dict):
    def __init__(__self__, *,
                 score: _builtins.int):
        """
        :param _builtins.int score: Indoor air quality score between 0 and 100.
        """
        pulumi.set(__self__, "score", score)

    @_builtins.property
    @pulumi.getter
    def score(self) -> _builtins.int:
        """
        Indoor air quality score between 0 and 100.
        """
        return pulumi.get(self, "score")


@pulumi.output_type
class GetSensorReadingsHistoryItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: ID of the network.
        :param _builtins.str name: Name of the network.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetSensorReadingsHistoryItemNoiseResult(dict):
    def __init__(__self__, *,
                 ambient: 'outputs.GetSensorReadingsHistoryItemNoiseAmbientResult'):
        """
        :param 'GetSensorReadingsHistoryItemNoiseAmbientArgs' ambient: Ambient noise reading.
        """
        pulumi.set(__self__, "ambient", ambient)

    @_builtins.property
    @pulumi.getter
    def ambient(self) -> 'outputs.GetSensorReadingsHistoryItemNoiseAmbientResult':
        """
        Ambient noise reading.
        """
        return pulumi.get(self, "ambient")


@pulumi.output_type
class GetSensorReadingsHistoryItemNoiseAmbientResult(dict):
    def __init__(__self__, *,
                 level: _builtins.int):
        """
        :param _builtins.int level: Ambient noise reading in adjusted decibels.
        """
        pulumi.set(__self__, "level", level)

    @_builtins.property
    @pulumi.getter
    def level(self) -> _builtins.int:
        """
        Ambient noise reading in adjusted decibels.
        """
        return pulumi.get(self, "level")


@pulumi.output_type
class GetSensorReadingsHistoryItemPm25Result(dict):
    def __init__(__self__, *,
                 concentration: _builtins.int):
        """
        :param _builtins.int concentration: PM2.5 reading in micrograms per cubic meter.
        """
        pulumi.set(__self__, "concentration", concentration)

    @_builtins.property
    @pulumi.getter
    def concentration(self) -> _builtins.int:
        """
        PM2.5 reading in micrograms per cubic meter.
        """
        return pulumi.get(self, "concentration")


@pulumi.output_type
class GetSensorReadingsHistoryItemPowerFactorResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.int):
        """
        :param _builtins.int percentage: Power factor reading as a percentage.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.int:
        """
        Power factor reading as a percentage.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetSensorReadingsHistoryItemRealPowerResult(dict):
    def __init__(__self__, *,
                 draw: _builtins.float):
        """
        :param _builtins.float draw: Real power reading in watts.
        """
        pulumi.set(__self__, "draw", draw)

    @_builtins.property
    @pulumi.getter
    def draw(self) -> _builtins.float:
        """
        Real power reading in watts.
        """
        return pulumi.get(self, "draw")


@pulumi.output_type
class GetSensorReadingsHistoryItemRemoteLockoutSwitchResult(dict):
    def __init__(__self__, *,
                 locked: _builtins.bool):
        """
        :param _builtins.bool locked: True if power controls are disabled via the MT40's physical remote lockout switch.
        """
        pulumi.set(__self__, "locked", locked)

    @_builtins.property
    @pulumi.getter
    def locked(self) -> _builtins.bool:
        """
        True if power controls are disabled via the MT40's physical remote lockout switch.
        """
        return pulumi.get(self, "locked")


@pulumi.output_type
class GetSensorReadingsHistoryItemTemperatureResult(dict):
    def __init__(__self__, *,
                 celsius: _builtins.float,
                 fahrenheit: _builtins.float):
        """
        :param _builtins.float celsius: Temperature reading in degrees Celsius.
        :param _builtins.float fahrenheit: Temperature reading in degrees Fahrenheit.
        """
        pulumi.set(__self__, "celsius", celsius)
        pulumi.set(__self__, "fahrenheit", fahrenheit)

    @_builtins.property
    @pulumi.getter
    def celsius(self) -> _builtins.float:
        """
        Temperature reading in degrees Celsius.
        """
        return pulumi.get(self, "celsius")

    @_builtins.property
    @pulumi.getter
    def fahrenheit(self) -> _builtins.float:
        """
        Temperature reading in degrees Fahrenheit.
        """
        return pulumi.get(self, "fahrenheit")


@pulumi.output_type
class GetSensorReadingsHistoryItemTvocResult(dict):
    def __init__(__self__, *,
                 concentration: _builtins.int):
        """
        :param _builtins.int concentration: TVOC reading in micrograms per cubic meter.
        """
        pulumi.set(__self__, "concentration", concentration)

    @_builtins.property
    @pulumi.getter
    def concentration(self) -> _builtins.int:
        """
        TVOC reading in micrograms per cubic meter.
        """
        return pulumi.get(self, "concentration")


@pulumi.output_type
class GetSensorReadingsHistoryItemVoltageResult(dict):
    def __init__(__self__, *,
                 level: _builtins.float):
        """
        :param _builtins.float level: Voltage reading in volts.
        """
        pulumi.set(__self__, "level", level)

    @_builtins.property
    @pulumi.getter
    def level(self) -> _builtins.float:
        """
        Voltage reading in volts.
        """
        return pulumi.get(self, "level")


@pulumi.output_type
class GetSensorReadingsHistoryItemWaterResult(dict):
    def __init__(__self__, *,
                 present: _builtins.bool):
        """
        :param _builtins.bool present: True if water is detected.
        """
        pulumi.set(__self__, "present", present)

    @_builtins.property
    @pulumi.getter
    def present(self) -> _builtins.bool:
        """
        True if water is detected.
        """
        return pulumi.get(self, "present")


@pulumi.output_type
class GetSensorReadingsLatestItemResult(dict):
    def __init__(__self__, *,
                 network: 'outputs.GetSensorReadingsLatestItemNetworkResult',
                 readings: Sequence['outputs.GetSensorReadingsLatestItemReadingResult'],
                 serial: _builtins.str):
        """
        :param 'GetSensorReadingsLatestItemNetworkArgs' network: Network to which the sensor belongs.
        :param Sequence['GetSensorReadingsLatestItemReadingArgs'] readings: Array of latest readings from the sensor. Each object represents a single reading for a single metric.
        :param _builtins.str serial: Serial number of the sensor that took the readings.
        """
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "readings", readings)
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetSensorReadingsLatestItemNetworkResult':
        """
        Network to which the sensor belongs.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter
    def readings(self) -> Sequence['outputs.GetSensorReadingsLatestItemReadingResult']:
        """
        Array of latest readings from the sensor. Each object represents a single reading for a single metric.
        """
        return pulumi.get(self, "readings")

    @_builtins.property
    @pulumi.getter
    def serial(self) -> _builtins.str:
        """
        Serial number of the sensor that took the readings.
        """
        return pulumi.get(self, "serial")


@pulumi.output_type
class GetSensorReadingsLatestItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: ID of the network.
        :param _builtins.str name: Name of the network.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetSensorReadingsLatestItemReadingResult(dict):
    def __init__(__self__, *,
                 apparent_power: 'outputs.GetSensorReadingsLatestItemReadingApparentPowerResult',
                 battery: 'outputs.GetSensorReadingsLatestItemReadingBatteryResult',
                 button: 'outputs.GetSensorReadingsLatestItemReadingButtonResult',
                 co2: 'outputs.GetSensorReadingsLatestItemReadingCo2Result',
                 current: 'outputs.GetSensorReadingsLatestItemReadingCurrentResult',
                 door: 'outputs.GetSensorReadingsLatestItemReadingDoorResult',
                 downstream_power: 'outputs.GetSensorReadingsLatestItemReadingDownstreamPowerResult',
                 frequency: 'outputs.GetSensorReadingsLatestItemReadingFrequencyResult',
                 humidity: 'outputs.GetSensorReadingsLatestItemReadingHumidityResult',
                 indoor_air_quality: 'outputs.GetSensorReadingsLatestItemReadingIndoorAirQualityResult',
                 metric: _builtins.str,
                 noise: 'outputs.GetSensorReadingsLatestItemReadingNoiseResult',
                 pm25: 'outputs.GetSensorReadingsLatestItemReadingPm25Result',
                 power_factor: 'outputs.GetSensorReadingsLatestItemReadingPowerFactorResult',
                 real_power: 'outputs.GetSensorReadingsLatestItemReadingRealPowerResult',
                 remote_lockout_switch: 'outputs.GetSensorReadingsLatestItemReadingRemoteLockoutSwitchResult',
                 temperature: 'outputs.GetSensorReadingsLatestItemReadingTemperatureResult',
                 ts: _builtins.str,
                 tvoc: 'outputs.GetSensorReadingsLatestItemReadingTvocResult',
                 voltage: 'outputs.GetSensorReadingsLatestItemReadingVoltageResult',
                 water: 'outputs.GetSensorReadingsLatestItemReadingWaterResult'):
        """
        :param 'GetSensorReadingsLatestItemReadingApparentPowerArgs' apparent_power: Reading for the 'apparentPower' metric. This will only be present if the 'metric' property equals 'apparentPower'.
        :param 'GetSensorReadingsLatestItemReadingBatteryArgs' battery: Reading for the 'battery' metric. This will only be present if the 'metric' property equals 'battery'.
        :param 'GetSensorReadingsLatestItemReadingButtonArgs' button: Reading for the 'button' metric. This will only be present if the 'metric' property equals 'button'.
        :param 'GetSensorReadingsLatestItemReadingCo2Args' co2: Reading for the 'co2' metric. This will only be present if the 'metric' property equals 'co2'.
        :param 'GetSensorReadingsLatestItemReadingCurrentArgs' current: Reading for the 'current' metric. This will only be present if the 'metric' property equals 'current'.
        :param 'GetSensorReadingsLatestItemReadingDoorArgs' door: Reading for the 'door' metric. This will only be present if the 'metric' property equals 'door'.
        :param 'GetSensorReadingsLatestItemReadingDownstreamPowerArgs' downstream_power: Reading for the 'downstreamPower' metric. This will only be present if the 'metric' property equals 'downstreamPower'.
        :param 'GetSensorReadingsLatestItemReadingFrequencyArgs' frequency: Reading for the 'frequency' metric. This will only be present if the 'metric' property equals 'frequency'.
        :param 'GetSensorReadingsLatestItemReadingHumidityArgs' humidity: Reading for the 'humidity' metric. This will only be present if the 'metric' property equals 'humidity'.
        :param 'GetSensorReadingsLatestItemReadingIndoorAirQualityArgs' indoor_air_quality: Reading for the 'indoorAirQuality' metric. This will only be present if the 'metric' property equals 'indoorAirQuality'.
        :param _builtins.str metric: Type of sensor reading.
        :param 'GetSensorReadingsLatestItemReadingNoiseArgs' noise: Reading for the 'noise' metric. This will only be present if the 'metric' property equals 'noise'.
        :param 'GetSensorReadingsLatestItemReadingPm25Args' pm25: Reading for the 'pm25' metric. This will only be present if the 'metric' property equals 'pm25'.
        :param 'GetSensorReadingsLatestItemReadingPowerFactorArgs' power_factor: Reading for the 'powerFactor' metric. This will only be present if the 'metric' property equals 'powerFactor'.
        :param 'GetSensorReadingsLatestItemReadingRealPowerArgs' real_power: Reading for the 'realPower' metric. This will only be present if the 'metric' property equals 'realPower'.
        :param 'GetSensorReadingsLatestItemReadingRemoteLockoutSwitchArgs' remote_lockout_switch: Reading for the 'remoteLockoutSwitch' metric. This will only be present if the 'metric' property equals 'remoteLockoutSwitch'.
        :param 'GetSensorReadingsLatestItemReadingTemperatureArgs' temperature: Reading for the 'temperature' metric. This will only be present if the 'metric' property equals 'temperature'.
        :param _builtins.str ts: Time at which the reading occurred, in ISO8601 format.
        :param 'GetSensorReadingsLatestItemReadingTvocArgs' tvoc: Reading for the 'tvoc' metric. This will only be present if the 'metric' property equals 'tvoc'.
        :param 'GetSensorReadingsLatestItemReadingVoltageArgs' voltage: Reading for the 'voltage' metric. This will only be present if the 'metric' property equals 'voltage'.
        :param 'GetSensorReadingsLatestItemReadingWaterArgs' water: Reading for the 'water' metric. This will only be present if the 'metric' property equals 'water'.
        """
        pulumi.set(__self__, "apparent_power", apparent_power)
        pulumi.set(__self__, "battery", battery)
        pulumi.set(__self__, "button", button)
        pulumi.set(__self__, "co2", co2)
        pulumi.set(__self__, "current", current)
        pulumi.set(__self__, "door", door)
        pulumi.set(__self__, "downstream_power", downstream_power)
        pulumi.set(__self__, "frequency", frequency)
        pulumi.set(__self__, "humidity", humidity)
        pulumi.set(__self__, "indoor_air_quality", indoor_air_quality)
        pulumi.set(__self__, "metric", metric)
        pulumi.set(__self__, "noise", noise)
        pulumi.set(__self__, "pm25", pm25)
        pulumi.set(__self__, "power_factor", power_factor)
        pulumi.set(__self__, "real_power", real_power)
        pulumi.set(__self__, "remote_lockout_switch", remote_lockout_switch)
        pulumi.set(__self__, "temperature", temperature)
        pulumi.set(__self__, "ts", ts)
        pulumi.set(__self__, "tvoc", tvoc)
        pulumi.set(__self__, "voltage", voltage)
        pulumi.set(__self__, "water", water)

    @_builtins.property
    @pulumi.getter(name="apparentPower")
    def apparent_power(self) -> 'outputs.GetSensorReadingsLatestItemReadingApparentPowerResult':
        """
        Reading for the 'apparentPower' metric. This will only be present if the 'metric' property equals 'apparentPower'.
        """
        return pulumi.get(self, "apparent_power")

    @_builtins.property
    @pulumi.getter
    def battery(self) -> 'outputs.GetSensorReadingsLatestItemReadingBatteryResult':
        """
        Reading for the 'battery' metric. This will only be present if the 'metric' property equals 'battery'.
        """
        return pulumi.get(self, "battery")

    @_builtins.property
    @pulumi.getter
    def button(self) -> 'outputs.GetSensorReadingsLatestItemReadingButtonResult':
        """
        Reading for the 'button' metric. This will only be present if the 'metric' property equals 'button'.
        """
        return pulumi.get(self, "button")

    @_builtins.property
    @pulumi.getter
    def co2(self) -> 'outputs.GetSensorReadingsLatestItemReadingCo2Result':
        """
        Reading for the 'co2' metric. This will only be present if the 'metric' property equals 'co2'.
        """
        return pulumi.get(self, "co2")

    @_builtins.property
    @pulumi.getter
    def current(self) -> 'outputs.GetSensorReadingsLatestItemReadingCurrentResult':
        """
        Reading for the 'current' metric. This will only be present if the 'metric' property equals 'current'.
        """
        return pulumi.get(self, "current")

    @_builtins.property
    @pulumi.getter
    def door(self) -> 'outputs.GetSensorReadingsLatestItemReadingDoorResult':
        """
        Reading for the 'door' metric. This will only be present if the 'metric' property equals 'door'.
        """
        return pulumi.get(self, "door")

    @_builtins.property
    @pulumi.getter(name="downstreamPower")
    def downstream_power(self) -> 'outputs.GetSensorReadingsLatestItemReadingDownstreamPowerResult':
        """
        Reading for the 'downstreamPower' metric. This will only be present if the 'metric' property equals 'downstreamPower'.
        """
        return pulumi.get(self, "downstream_power")

    @_builtins.property
    @pulumi.getter
    def frequency(self) -> 'outputs.GetSensorReadingsLatestItemReadingFrequencyResult':
        """
        Reading for the 'frequency' metric. This will only be present if the 'metric' property equals 'frequency'.
        """
        return pulumi.get(self, "frequency")

    @_builtins.property
    @pulumi.getter
    def humidity(self) -> 'outputs.GetSensorReadingsLatestItemReadingHumidityResult':
        """
        Reading for the 'humidity' metric. This will only be present if the 'metric' property equals 'humidity'.
        """
        return pulumi.get(self, "humidity")

    @_builtins.property
    @pulumi.getter(name="indoorAirQuality")
    def indoor_air_quality(self) -> 'outputs.GetSensorReadingsLatestItemReadingIndoorAirQualityResult':
        """
        Reading for the 'indoorAirQuality' metric. This will only be present if the 'metric' property equals 'indoorAirQuality'.
        """
        return pulumi.get(self, "indoor_air_quality")

    @_builtins.property
    @pulumi.getter
    def metric(self) -> _builtins.str:
        """
        Type of sensor reading.
        """
        return pulumi.get(self, "metric")

    @_builtins.property
    @pulumi.getter
    def noise(self) -> 'outputs.GetSensorReadingsLatestItemReadingNoiseResult':
        """
        Reading for the 'noise' metric. This will only be present if the 'metric' property equals 'noise'.
        """
        return pulumi.get(self, "noise")

    @_builtins.property
    @pulumi.getter
    def pm25(self) -> 'outputs.GetSensorReadingsLatestItemReadingPm25Result':
        """
        Reading for the 'pm25' metric. This will only be present if the 'metric' property equals 'pm25'.
        """
        return pulumi.get(self, "pm25")

    @_builtins.property
    @pulumi.getter(name="powerFactor")
    def power_factor(self) -> 'outputs.GetSensorReadingsLatestItemReadingPowerFactorResult':
        """
        Reading for the 'powerFactor' metric. This will only be present if the 'metric' property equals 'powerFactor'.
        """
        return pulumi.get(self, "power_factor")

    @_builtins.property
    @pulumi.getter(name="realPower")
    def real_power(self) -> 'outputs.GetSensorReadingsLatestItemReadingRealPowerResult':
        """
        Reading for the 'realPower' metric. This will only be present if the 'metric' property equals 'realPower'.
        """
        return pulumi.get(self, "real_power")

    @_builtins.property
    @pulumi.getter(name="remoteLockoutSwitch")
    def remote_lockout_switch(self) -> 'outputs.GetSensorReadingsLatestItemReadingRemoteLockoutSwitchResult':
        """
        Reading for the 'remoteLockoutSwitch' metric. This will only be present if the 'metric' property equals 'remoteLockoutSwitch'.
        """
        return pulumi.get(self, "remote_lockout_switch")

    @_builtins.property
    @pulumi.getter
    def temperature(self) -> 'outputs.GetSensorReadingsLatestItemReadingTemperatureResult':
        """
        Reading for the 'temperature' metric. This will only be present if the 'metric' property equals 'temperature'.
        """
        return pulumi.get(self, "temperature")

    @_builtins.property
    @pulumi.getter
    def ts(self) -> _builtins.str:
        """
        Time at which the reading occurred, in ISO8601 format.
        """
        return pulumi.get(self, "ts")

    @_builtins.property
    @pulumi.getter
    def tvoc(self) -> 'outputs.GetSensorReadingsLatestItemReadingTvocResult':
        """
        Reading for the 'tvoc' metric. This will only be present if the 'metric' property equals 'tvoc'.
        """
        return pulumi.get(self, "tvoc")

    @_builtins.property
    @pulumi.getter
    def voltage(self) -> 'outputs.GetSensorReadingsLatestItemReadingVoltageResult':
        """
        Reading for the 'voltage' metric. This will only be present if the 'metric' property equals 'voltage'.
        """
        return pulumi.get(self, "voltage")

    @_builtins.property
    @pulumi.getter
    def water(self) -> 'outputs.GetSensorReadingsLatestItemReadingWaterResult':
        """
        Reading for the 'water' metric. This will only be present if the 'metric' property equals 'water'.
        """
        return pulumi.get(self, "water")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingApparentPowerResult(dict):
    def __init__(__self__, *,
                 draw: _builtins.float):
        """
        :param _builtins.float draw: Apparent power reading in volt-amperes.
        """
        pulumi.set(__self__, "draw", draw)

    @_builtins.property
    @pulumi.getter
    def draw(self) -> _builtins.float:
        """
        Apparent power reading in volt-amperes.
        """
        return pulumi.get(self, "draw")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingBatteryResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.int):
        """
        :param _builtins.int percentage: Remaining battery life.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.int:
        """
        Remaining battery life.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingButtonResult(dict):
    def __init__(__self__, *,
                 press_type: _builtins.str):
        """
        :param _builtins.str press_type: Type of button press that occurred.
        """
        pulumi.set(__self__, "press_type", press_type)

    @_builtins.property
    @pulumi.getter(name="pressType")
    def press_type(self) -> _builtins.str:
        """
        Type of button press that occurred.
        """
        return pulumi.get(self, "press_type")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingCo2Result(dict):
    def __init__(__self__, *,
                 concentration: _builtins.int):
        """
        :param _builtins.int concentration: CO2 reading in parts per million.
        """
        pulumi.set(__self__, "concentration", concentration)

    @_builtins.property
    @pulumi.getter
    def concentration(self) -> _builtins.int:
        """
        CO2 reading in parts per million.
        """
        return pulumi.get(self, "concentration")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingCurrentResult(dict):
    def __init__(__self__, *,
                 draw: _builtins.float):
        """
        :param _builtins.float draw: Electrical current reading in amperes.
        """
        pulumi.set(__self__, "draw", draw)

    @_builtins.property
    @pulumi.getter
    def draw(self) -> _builtins.float:
        """
        Electrical current reading in amperes.
        """
        return pulumi.get(self, "draw")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingDoorResult(dict):
    def __init__(__self__, *,
                 open: _builtins.bool):
        """
        :param _builtins.bool open: True if the door is open.
        """
        pulumi.set(__self__, "open", open)

    @_builtins.property
    @pulumi.getter
    def open(self) -> _builtins.bool:
        """
        True if the door is open.
        """
        return pulumi.get(self, "open")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingDownstreamPowerResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool):
        """
        :param _builtins.bool enabled: True if power is turned on to the device that is connected downstream of the MT40 power monitor.
        """
        pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        True if power is turned on to the device that is connected downstream of the MT40 power monitor.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingFrequencyResult(dict):
    def __init__(__self__, *,
                 level: _builtins.float):
        """
        :param _builtins.float level: Electrical current frequency reading in hertz.
        """
        pulumi.set(__self__, "level", level)

    @_builtins.property
    @pulumi.getter
    def level(self) -> _builtins.float:
        """
        Electrical current frequency reading in hertz.
        """
        return pulumi.get(self, "level")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingHumidityResult(dict):
    def __init__(__self__, *,
                 relative_percentage: _builtins.int):
        """
        :param _builtins.int relative_percentage: Humidity reading in %RH.
        """
        pulumi.set(__self__, "relative_percentage", relative_percentage)

    @_builtins.property
    @pulumi.getter(name="relativePercentage")
    def relative_percentage(self) -> _builtins.int:
        """
        Humidity reading in %RH.
        """
        return pulumi.get(self, "relative_percentage")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingIndoorAirQualityResult(dict):
    def __init__(__self__, *,
                 score: _builtins.int):
        """
        :param _builtins.int score: Indoor air quality score between 0 and 100.
        """
        pulumi.set(__self__, "score", score)

    @_builtins.property
    @pulumi.getter
    def score(self) -> _builtins.int:
        """
        Indoor air quality score between 0 and 100.
        """
        return pulumi.get(self, "score")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingNoiseResult(dict):
    def __init__(__self__, *,
                 ambient: 'outputs.GetSensorReadingsLatestItemReadingNoiseAmbientResult'):
        """
        :param 'GetSensorReadingsLatestItemReadingNoiseAmbientArgs' ambient: Ambient noise reading.
        """
        pulumi.set(__self__, "ambient", ambient)

    @_builtins.property
    @pulumi.getter
    def ambient(self) -> 'outputs.GetSensorReadingsLatestItemReadingNoiseAmbientResult':
        """
        Ambient noise reading.
        """
        return pulumi.get(self, "ambient")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingNoiseAmbientResult(dict):
    def __init__(__self__, *,
                 level: _builtins.int):
        """
        :param _builtins.int level: Ambient noise reading in adjusted decibels.
        """
        pulumi.set(__self__, "level", level)

    @_builtins.property
    @pulumi.getter
    def level(self) -> _builtins.int:
        """
        Ambient noise reading in adjusted decibels.
        """
        return pulumi.get(self, "level")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingPm25Result(dict):
    def __init__(__self__, *,
                 concentration: _builtins.int):
        """
        :param _builtins.int concentration: PM2.5 reading in micrograms per cubic meter.
        """
        pulumi.set(__self__, "concentration", concentration)

    @_builtins.property
    @pulumi.getter
    def concentration(self) -> _builtins.int:
        """
        PM2.5 reading in micrograms per cubic meter.
        """
        return pulumi.get(self, "concentration")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingPowerFactorResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.int):
        """
        :param _builtins.int percentage: Power factor reading as a percentage.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.int:
        """
        Power factor reading as a percentage.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingRealPowerResult(dict):
    def __init__(__self__, *,
                 draw: _builtins.float):
        """
        :param _builtins.float draw: Real power reading in watts.
        """
        pulumi.set(__self__, "draw", draw)

    @_builtins.property
    @pulumi.getter
    def draw(self) -> _builtins.float:
        """
        Real power reading in watts.
        """
        return pulumi.get(self, "draw")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingRemoteLockoutSwitchResult(dict):
    def __init__(__self__, *,
                 locked: _builtins.bool):
        """
        :param _builtins.bool locked: True if power controls are disabled via the MT40's physical remote lockout switch.
        """
        pulumi.set(__self__, "locked", locked)

    @_builtins.property
    @pulumi.getter
    def locked(self) -> _builtins.bool:
        """
        True if power controls are disabled via the MT40's physical remote lockout switch.
        """
        return pulumi.get(self, "locked")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingTemperatureResult(dict):
    def __init__(__self__, *,
                 celsius: _builtins.float,
                 fahrenheit: _builtins.float):
        """
        :param _builtins.float celsius: Temperature reading in degrees Celsius.
        :param _builtins.float fahrenheit: Temperature reading in degrees Fahrenheit.
        """
        pulumi.set(__self__, "celsius", celsius)
        pulumi.set(__self__, "fahrenheit", fahrenheit)

    @_builtins.property
    @pulumi.getter
    def celsius(self) -> _builtins.float:
        """
        Temperature reading in degrees Celsius.
        """
        return pulumi.get(self, "celsius")

    @_builtins.property
    @pulumi.getter
    def fahrenheit(self) -> _builtins.float:
        """
        Temperature reading in degrees Fahrenheit.
        """
        return pulumi.get(self, "fahrenheit")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingTvocResult(dict):
    def __init__(__self__, *,
                 concentration: _builtins.int):
        """
        :param _builtins.int concentration: TVOC reading in micrograms per cubic meter.
        """
        pulumi.set(__self__, "concentration", concentration)

    @_builtins.property
    @pulumi.getter
    def concentration(self) -> _builtins.int:
        """
        TVOC reading in micrograms per cubic meter.
        """
        return pulumi.get(self, "concentration")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingVoltageResult(dict):
    def __init__(__self__, *,
                 level: _builtins.float):
        """
        :param _builtins.float level: Voltage reading in volts.
        """
        pulumi.set(__self__, "level", level)

    @_builtins.property
    @pulumi.getter
    def level(self) -> _builtins.float:
        """
        Voltage reading in volts.
        """
        return pulumi.get(self, "level")


@pulumi.output_type
class GetSensorReadingsLatestItemReadingWaterResult(dict):
    def __init__(__self__, *,
                 present: _builtins.bool):
        """
        :param _builtins.bool present: True if water is detected.
        """
        pulumi.set(__self__, "present", present)

    @_builtins.property
    @pulumi.getter
    def present(self) -> _builtins.bool:
        """
        True if water is detected.
        """
        return pulumi.get(self, "present")


@pulumi.output_type
class GetSmAdminsRolesItemResult(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 role_id: _builtins.str,
                 scope: _builtins.str,
                 tags: Sequence[_builtins.str]):
        """
        :param _builtins.str name: The name of the limited access role
        :param _builtins.str role_id: The Id of the limited access role
        :param _builtins.str scope: The scope of the limited access role
        :param Sequence[_builtins.str] tags: The tags of the limited access role
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "role_id", role_id)
        pulumi.set(__self__, "scope", scope)
        pulumi.set(__self__, "tags", tags)

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        The name of the limited access role
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="roleId")
    def role_id(self) -> _builtins.str:
        """
        The Id of the limited access role
        """
        return pulumi.get(self, "role_id")

    @_builtins.property
    @pulumi.getter
    def scope(self) -> _builtins.str:
        """
        The scope of the limited access role
        """
        return pulumi.get(self, "scope")

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Sequence[_builtins.str]:
        """
        The tags of the limited access role
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetSmApnsCertItemResult(dict):
    def __init__(__self__, *,
                 certificate: _builtins.str):
        """
        :param _builtins.str certificate: Organization APNS Certificate used by devices to communication with Apple
        """
        pulumi.set(__self__, "certificate", certificate)

    @_builtins.property
    @pulumi.getter
    def certificate(self) -> _builtins.str:
        """
        Organization APNS Certificate used by devices to communication with Apple
        """
        return pulumi.get(self, "certificate")


@pulumi.output_type
class GetSmSentryPoliciesAssignmentsByNetworkItemResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetSmSentryPoliciesAssignmentsByNetworkItemItemResult'],
                 meta: 'outputs.GetSmSentryPoliciesAssignmentsByNetworkItemMetaResult'):
        """
        :param Sequence['GetSmSentryPoliciesAssignmentsByNetworkItemItemArgs'] items: Sentry Group Policies for the Organization keyed by the Network or Locale Id the Policy belongs to
        :param 'GetSmSentryPoliciesAssignmentsByNetworkItemMetaArgs' meta: Metadata relevant to the paginated dataset
        """
        pulumi.set(__self__, "items", items)
        pulumi.set(__self__, "meta", meta)

    @_builtins.property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetSmSentryPoliciesAssignmentsByNetworkItemItemResult']:
        """
        Sentry Group Policies for the Organization keyed by the Network or Locale Id the Policy belongs to
        """
        return pulumi.get(self, "items")

    @_builtins.property
    @pulumi.getter
    def meta(self) -> 'outputs.GetSmSentryPoliciesAssignmentsByNetworkItemMetaResult':
        """
        Metadata relevant to the paginated dataset
        """
        return pulumi.get(self, "meta")


@pulumi.output_type
class GetSmSentryPoliciesAssignmentsByNetworkItemItemResult(dict):
    def __init__(__self__, *,
                 network_id: _builtins.str,
                 policies: Sequence['outputs.GetSmSentryPoliciesAssignmentsByNetworkItemItemPolicyResult']):
        """
        :param _builtins.str network_id: The Id of the Network
        :param Sequence['GetSmSentryPoliciesAssignmentsByNetworkItemItemPolicyArgs'] policies: Array of Sentry Group Policies for the Network
        """
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "policies", policies)

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        The Id of the Network
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter
    def policies(self) -> Sequence['outputs.GetSmSentryPoliciesAssignmentsByNetworkItemItemPolicyResult']:
        """
        Array of Sentry Group Policies for the Network
        """
        return pulumi.get(self, "policies")


@pulumi.output_type
class GetSmSentryPoliciesAssignmentsByNetworkItemItemPolicyResult(dict):
    def __init__(__self__, *,
                 created_at: _builtins.str,
                 group_number: _builtins.str,
                 group_policy_id: _builtins.str,
                 last_updated_at: _builtins.str,
                 network_id: _builtins.str,
                 policy_id: _builtins.str,
                 priority: _builtins.str,
                 scope: _builtins.str,
                 sm_network_id: _builtins.str,
                 tags: Sequence[_builtins.str]):
        """
        :param _builtins.str created_at: The creation time of the Sentry Policy
        :param _builtins.str group_number: The number of the Group Policy
        :param _builtins.str group_policy_id: The Id of the Group Policy. This is associated with the network specified by the networkId.
        :param _builtins.str last_updated_at: The last update time of the Sentry Policy
        :param _builtins.str network_id: The Id of the Network the Sentry Policy is associated with. In a locale, this should be the Wireless Group if present, otherwise the Wired Group.
        :param _builtins.str policy_id: The Id of the Sentry Policy
        :param _builtins.str priority: The priority of the Sentry Policy
        :param _builtins.str scope: The scope of the Sentry Policy
        :param _builtins.str sm_network_id: The Id of the Systems Manager Network the Sentry Policy is assigned to
        :param Sequence[_builtins.str] tags: The tags of the Sentry Policy
        """
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "group_number", group_number)
        pulumi.set(__self__, "group_policy_id", group_policy_id)
        pulumi.set(__self__, "last_updated_at", last_updated_at)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "policy_id", policy_id)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "scope", scope)
        pulumi.set(__self__, "sm_network_id", sm_network_id)
        pulumi.set(__self__, "tags", tags)

    @_builtins.property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> _builtins.str:
        """
        The creation time of the Sentry Policy
        """
        return pulumi.get(self, "created_at")

    @_builtins.property
    @pulumi.getter(name="groupNumber")
    def group_number(self) -> _builtins.str:
        """
        The number of the Group Policy
        """
        return pulumi.get(self, "group_number")

    @_builtins.property
    @pulumi.getter(name="groupPolicyId")
    def group_policy_id(self) -> _builtins.str:
        """
        The Id of the Group Policy. This is associated with the network specified by the networkId.
        """
        return pulumi.get(self, "group_policy_id")

    @_builtins.property
    @pulumi.getter(name="lastUpdatedAt")
    def last_updated_at(self) -> _builtins.str:
        """
        The last update time of the Sentry Policy
        """
        return pulumi.get(self, "last_updated_at")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        The Id of the Network the Sentry Policy is associated with. In a locale, this should be the Wireless Group if present, otherwise the Wired Group.
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="policyId")
    def policy_id(self) -> _builtins.str:
        """
        The Id of the Sentry Policy
        """
        return pulumi.get(self, "policy_id")

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

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

    @_builtins.property
    @pulumi.getter(name="smNetworkId")
    def sm_network_id(self) -> _builtins.str:
        """
        The Id of the Systems Manager Network the Sentry Policy is assigned to
        """
        return pulumi.get(self, "sm_network_id")

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Sequence[_builtins.str]:
        """
        The tags of the Sentry Policy
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetSmSentryPoliciesAssignmentsByNetworkItemMetaResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetSmSentryPoliciesAssignmentsByNetworkItemMetaCountsResult'):
        """
        :param 'GetSmSentryPoliciesAssignmentsByNetworkItemMetaCountsArgs' counts: Counts relating to the paginated dataset
        """
        pulumi.set(__self__, "counts", counts)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> 'outputs.GetSmSentryPoliciesAssignmentsByNetworkItemMetaCountsResult':
        """
        Counts relating to the paginated dataset
        """
        return pulumi.get(self, "counts")


@pulumi.output_type
class GetSmSentryPoliciesAssignmentsByNetworkItemMetaCountsResult(dict):
    def __init__(__self__, *,
                 items: 'outputs.GetSmSentryPoliciesAssignmentsByNetworkItemMetaCountsItemsResult'):
        """
        :param 'GetSmSentryPoliciesAssignmentsByNetworkItemMetaCountsItemsArgs' items: Counts relating to the paginated items
        """
        pulumi.set(__self__, "items", items)

    @_builtins.property
    @pulumi.getter
    def items(self) -> 'outputs.GetSmSentryPoliciesAssignmentsByNetworkItemMetaCountsItemsResult':
        """
        Counts relating to the paginated items
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class GetSmSentryPoliciesAssignmentsByNetworkItemMetaCountsItemsResult(dict):
    def __init__(__self__, *,
                 remaining: _builtins.int,
                 total: _builtins.int):
        """
        :param _builtins.int remaining: The number of items in the dataset that are available on subsequent pages
        :param _builtins.int total: The total number of items in the dataset
        """
        pulumi.set(__self__, "remaining", remaining)
        pulumi.set(__self__, "total", total)

    @_builtins.property
    @pulumi.getter
    def remaining(self) -> _builtins.int:
        """
        The number of items in the dataset that are available on subsequent pages
        """
        return pulumi.get(self, "remaining")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        The total number of items in the dataset
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetSmVppAccountsItemResult(dict):
    def __init__(__self__, *,
                 allowed_admins: _builtins.str,
                 assignable_network_ids: Sequence[_builtins.str],
                 assignable_networks: _builtins.str,
                 content_token: _builtins.str,
                 email: _builtins.str,
                 id: _builtins.str,
                 last_force_synced_at: _builtins.str,
                 last_synced_at: _builtins.str,
                 name: _builtins.str,
                 network_id_admins: _builtins.str,
                 parsed_token: 'outputs.GetSmVppAccountsItemParsedTokenResult',
                 vpp_account_id: _builtins.str,
                 vpp_location_id: _builtins.str,
                 vpp_location_name: _builtins.str,
                 vpp_service_token: _builtins.str):
        """
        :param _builtins.str allowed_admins: The allowed admins for the VPP account
        :param Sequence[_builtins.str] assignable_network_ids: The network IDs of the assignable networks for the VPP account
        :param _builtins.str assignable_networks: The assignable networks for the VPP account
        :param _builtins.str content_token: The VPP service token
        :param _builtins.str email: The email address associated with the VPP account
        :param _builtins.str id: The id of the VPP Account
        :param _builtins.str last_force_synced_at: The last time the VPP account was force synced
        :param _builtins.str last_synced_at: The last time the VPP account was synced
        :param _builtins.str name: The name of the VPP account
        :param _builtins.str network_id_admins: The network IDs of the admins for the VPP account
        :param 'GetSmVppAccountsItemParsedTokenArgs' parsed_token: The parsed VPP service token
        :param _builtins.str vpp_account_id: The id of the VPP Account
        :param _builtins.str vpp_location_id: The VPP location ID
        :param _builtins.str vpp_location_name: The VPP location name
        :param _builtins.str vpp_service_token: The VPP Account's Service Token
        """
        pulumi.set(__self__, "allowed_admins", allowed_admins)
        pulumi.set(__self__, "assignable_network_ids", assignable_network_ids)
        pulumi.set(__self__, "assignable_networks", assignable_networks)
        pulumi.set(__self__, "content_token", content_token)
        pulumi.set(__self__, "email", email)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "last_force_synced_at", last_force_synced_at)
        pulumi.set(__self__, "last_synced_at", last_synced_at)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_id_admins", network_id_admins)
        pulumi.set(__self__, "parsed_token", parsed_token)
        pulumi.set(__self__, "vpp_account_id", vpp_account_id)
        pulumi.set(__self__, "vpp_location_id", vpp_location_id)
        pulumi.set(__self__, "vpp_location_name", vpp_location_name)
        pulumi.set(__self__, "vpp_service_token", vpp_service_token)

    @_builtins.property
    @pulumi.getter(name="allowedAdmins")
    def allowed_admins(self) -> _builtins.str:
        """
        The allowed admins for the VPP account
        """
        return pulumi.get(self, "allowed_admins")

    @_builtins.property
    @pulumi.getter(name="assignableNetworkIds")
    def assignable_network_ids(self) -> Sequence[_builtins.str]:
        """
        The network IDs of the assignable networks for the VPP account
        """
        return pulumi.get(self, "assignable_network_ids")

    @_builtins.property
    @pulumi.getter(name="assignableNetworks")
    def assignable_networks(self) -> _builtins.str:
        """
        The assignable networks for the VPP account
        """
        return pulumi.get(self, "assignable_networks")

    @_builtins.property
    @pulumi.getter(name="contentToken")
    def content_token(self) -> _builtins.str:
        """
        The VPP service token
        """
        return pulumi.get(self, "content_token")

    @_builtins.property
    @pulumi.getter
    def email(self) -> _builtins.str:
        """
        The email address associated with the VPP account
        """
        return pulumi.get(self, "email")

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

    @_builtins.property
    @pulumi.getter(name="lastForceSyncedAt")
    def last_force_synced_at(self) -> _builtins.str:
        """
        The last time the VPP account was force synced
        """
        return pulumi.get(self, "last_force_synced_at")

    @_builtins.property
    @pulumi.getter(name="lastSyncedAt")
    def last_synced_at(self) -> _builtins.str:
        """
        The last time the VPP account was synced
        """
        return pulumi.get(self, "last_synced_at")

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

    @_builtins.property
    @pulumi.getter(name="networkIdAdmins")
    def network_id_admins(self) -> _builtins.str:
        """
        The network IDs of the admins for the VPP account
        """
        return pulumi.get(self, "network_id_admins")

    @_builtins.property
    @pulumi.getter(name="parsedToken")
    def parsed_token(self) -> 'outputs.GetSmVppAccountsItemParsedTokenResult':
        """
        The parsed VPP service token
        """
        return pulumi.get(self, "parsed_token")

    @_builtins.property
    @pulumi.getter(name="vppAccountId")
    def vpp_account_id(self) -> _builtins.str:
        """
        The id of the VPP Account
        """
        return pulumi.get(self, "vpp_account_id")

    @_builtins.property
    @pulumi.getter(name="vppLocationId")
    def vpp_location_id(self) -> _builtins.str:
        """
        The VPP location ID
        """
        return pulumi.get(self, "vpp_location_id")

    @_builtins.property
    @pulumi.getter(name="vppLocationName")
    def vpp_location_name(self) -> _builtins.str:
        """
        The VPP location name
        """
        return pulumi.get(self, "vpp_location_name")

    @_builtins.property
    @pulumi.getter(name="vppServiceToken")
    def vpp_service_token(self) -> _builtins.str:
        """
        The VPP Account's Service Token
        """
        return pulumi.get(self, "vpp_service_token")


@pulumi.output_type
class GetSmVppAccountsItemParsedTokenResult(dict):
    def __init__(__self__, *,
                 expires_at: _builtins.str,
                 hashed_token: _builtins.str,
                 org_name: _builtins.str):
        """
        :param _builtins.str expires_at: The expiration time of the token
        :param _builtins.str hashed_token: The hashed token
        :param _builtins.str org_name: The organization name
        """
        pulumi.set(__self__, "expires_at", expires_at)
        pulumi.set(__self__, "hashed_token", hashed_token)
        pulumi.set(__self__, "org_name", org_name)

    @_builtins.property
    @pulumi.getter(name="expiresAt")
    def expires_at(self) -> _builtins.str:
        """
        The expiration time of the token
        """
        return pulumi.get(self, "expires_at")

    @_builtins.property
    @pulumi.getter(name="hashedToken")
    def hashed_token(self) -> _builtins.str:
        """
        The hashed token
        """
        return pulumi.get(self, "hashed_token")

    @_builtins.property
    @pulumi.getter(name="orgName")
    def org_name(self) -> _builtins.str:
        """
        The organization name
        """
        return pulumi.get(self, "org_name")


@pulumi.output_type
class GetSnmpItemResult(dict):
    def __init__(__self__, *,
                 hostname: _builtins.str,
                 peer_ips: Sequence[_builtins.str],
                 port: _builtins.int,
                 v2_community_string: _builtins.str,
                 v2c_enabled: _builtins.bool,
                 v3_auth_mode: _builtins.str,
                 v3_enabled: _builtins.bool,
                 v3_priv_mode: _builtins.str,
                 v3_user: _builtins.str):
        """
        :param _builtins.str hostname: The hostname of the SNMP server.
        :param Sequence[_builtins.str] peer_ips: The list of IPv4 addresses that are allowed to access the SNMP server.
        :param _builtins.int port: The port of the SNMP server.
        :param _builtins.str v2_community_string: The community string for SNMP version 2c, if enabled.
        :param _builtins.bool v2c_enabled: Boolean indicating whether SNMP version 2c is enabled for the organization.
        :param _builtins.str v3_auth_mode: The SNMP version 3 authentication mode. Can be either 'MD5' or 'SHA'.
        :param _builtins.bool v3_enabled: Boolean indicating whether SNMP version 3 is enabled for the organization.
        :param _builtins.str v3_priv_mode: The SNMP version 3 privacy mode. Can be either 'DES' or 'AES128'.
        :param _builtins.str v3_user: The user for SNMP version 3, if enabled.
        """
        pulumi.set(__self__, "hostname", hostname)
        pulumi.set(__self__, "peer_ips", peer_ips)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "v2_community_string", v2_community_string)
        pulumi.set(__self__, "v2c_enabled", v2c_enabled)
        pulumi.set(__self__, "v3_auth_mode", v3_auth_mode)
        pulumi.set(__self__, "v3_enabled", v3_enabled)
        pulumi.set(__self__, "v3_priv_mode", v3_priv_mode)
        pulumi.set(__self__, "v3_user", v3_user)

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

    @_builtins.property
    @pulumi.getter(name="peerIps")
    def peer_ips(self) -> Sequence[_builtins.str]:
        """
        The list of IPv4 addresses that are allowed to access the SNMP server.
        """
        return pulumi.get(self, "peer_ips")

    @_builtins.property
    @pulumi.getter
    def port(self) -> _builtins.int:
        """
        The port of the SNMP server.
        """
        return pulumi.get(self, "port")

    @_builtins.property
    @pulumi.getter(name="v2CommunityString")
    def v2_community_string(self) -> _builtins.str:
        """
        The community string for SNMP version 2c, if enabled.
        """
        return pulumi.get(self, "v2_community_string")

    @_builtins.property
    @pulumi.getter(name="v2cEnabled")
    def v2c_enabled(self) -> _builtins.bool:
        """
        Boolean indicating whether SNMP version 2c is enabled for the organization.
        """
        return pulumi.get(self, "v2c_enabled")

    @_builtins.property
    @pulumi.getter(name="v3AuthMode")
    def v3_auth_mode(self) -> _builtins.str:
        """
        The SNMP version 3 authentication mode. Can be either 'MD5' or 'SHA'.
        """
        return pulumi.get(self, "v3_auth_mode")

    @_builtins.property
    @pulumi.getter(name="v3Enabled")
    def v3_enabled(self) -> _builtins.bool:
        """
        Boolean indicating whether SNMP version 3 is enabled for the organization.
        """
        return pulumi.get(self, "v3_enabled")

    @_builtins.property
    @pulumi.getter(name="v3PrivMode")
    def v3_priv_mode(self) -> _builtins.str:
        """
        The SNMP version 3 privacy mode. Can be either 'DES' or 'AES128'.
        """
        return pulumi.get(self, "v3_priv_mode")

    @_builtins.property
    @pulumi.getter(name="v3User")
    def v3_user(self) -> _builtins.str:
        """
        The user for SNMP version 3, if enabled.
        """
        return pulumi.get(self, "v3_user")


@pulumi.output_type
class GetSummaryTopAppliancesByUtilizationItemResult(dict):
    def __init__(__self__, *,
                 mac: _builtins.str,
                 model: _builtins.str,
                 name: _builtins.str,
                 network: 'outputs.GetSummaryTopAppliancesByUtilizationItemNetworkResult',
                 serial: _builtins.str,
                 utilization: 'outputs.GetSummaryTopAppliancesByUtilizationItemUtilizationResult'):
        """
        :param _builtins.str mac: Mac address of the appliance
        :param _builtins.str model: Model of the appliance
        :param _builtins.str name: Name of the appliance
        :param 'GetSummaryTopAppliancesByUtilizationItemNetworkArgs' network: Network info
        :param _builtins.str serial: Serial number of the appliance
        :param 'GetSummaryTopAppliancesByUtilizationItemUtilizationArgs' utilization: Utilization of the appliance
        """
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "utilization", utilization)

    @_builtins.property
    @pulumi.getter
    def mac(self) -> _builtins.str:
        """
        Mac address of the appliance
        """
        return pulumi.get(self, "mac")

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

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetSummaryTopAppliancesByUtilizationItemNetworkResult':
        """
        Network info
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def utilization(self) -> 'outputs.GetSummaryTopAppliancesByUtilizationItemUtilizationResult':
        """
        Utilization of the appliance
        """
        return pulumi.get(self, "utilization")


@pulumi.output_type
class GetSummaryTopAppliancesByUtilizationItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: Network id
        :param _builtins.str name: Network name
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetSummaryTopAppliancesByUtilizationItemUtilizationResult(dict):
    def __init__(__self__, *,
                 average: 'outputs.GetSummaryTopAppliancesByUtilizationItemUtilizationAverageResult'):
        """
        :param 'GetSummaryTopAppliancesByUtilizationItemUtilizationAverageArgs' average: Average utilization of the appliance
        """
        pulumi.set(__self__, "average", average)

    @_builtins.property
    @pulumi.getter
    def average(self) -> 'outputs.GetSummaryTopAppliancesByUtilizationItemUtilizationAverageResult':
        """
        Average utilization of the appliance
        """
        return pulumi.get(self, "average")


@pulumi.output_type
class GetSummaryTopAppliancesByUtilizationItemUtilizationAverageResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Average percentage utilization of the appliance
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Average percentage utilization of the appliance
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetSummaryTopClientsByUsageItemResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 mac: _builtins.str,
                 name: _builtins.str,
                 network: 'outputs.GetSummaryTopClientsByUsageItemNetworkResult',
                 usage: 'outputs.GetSummaryTopClientsByUsageItemUsageResult'):
        """
        :param _builtins.str id: ID of client
        :param _builtins.str mac: MAC address of client
        :param _builtins.str name: Name of client
        :param 'GetSummaryTopClientsByUsageItemUsageArgs' usage: Data usage information
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "usage", usage)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID of client
        """
        return pulumi.get(self, "id")

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

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

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

    @_builtins.property
    @pulumi.getter
    def usage(self) -> 'outputs.GetSummaryTopClientsByUsageItemUsageResult':
        """
        Data usage information
        """
        return pulumi.get(self, "usage")


@pulumi.output_type
class GetSummaryTopClientsByUsageItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: ID of network
        :param _builtins.str name: Name of network
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        ID of network
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetSummaryTopClientsByUsageItemUsageResult(dict):
    def __init__(__self__, *,
                 downstream: _builtins.float,
                 percentage: _builtins.float,
                 total: _builtins.float,
                 upstream: _builtins.float):
        """
        :param _builtins.float downstream: Downstream data usage by client
        :param _builtins.float percentage: Percentage of total data usage by client
        :param _builtins.float total: Total data usage by client
        :param _builtins.float upstream: Upstream data usage by client
        """
        pulumi.set(__self__, "downstream", downstream)
        pulumi.set(__self__, "percentage", percentage)
        pulumi.set(__self__, "total", total)
        pulumi.set(__self__, "upstream", upstream)

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> _builtins.float:
        """
        Downstream data usage by client
        """
        return pulumi.get(self, "downstream")

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of total data usage by client
        """
        return pulumi.get(self, "percentage")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.float:
        """
        Total data usage by client
        """
        return pulumi.get(self, "total")

    @_builtins.property
    @pulumi.getter
    def upstream(self) -> _builtins.float:
        """
        Upstream data usage by client
        """
        return pulumi.get(self, "upstream")


@pulumi.output_type
class GetSummaryTopClientsManufacturersByUsageItemResult(dict):
    def __init__(__self__, *,
                 clients: 'outputs.GetSummaryTopClientsManufacturersByUsageItemClientsResult',
                 name: _builtins.str,
                 usage: 'outputs.GetSummaryTopClientsManufacturersByUsageItemUsageResult'):
        """
        :param 'GetSummaryTopClientsManufacturersByUsageItemClientsArgs' clients: Clients info
        :param _builtins.str name: Name of the manufacturer
        :param 'GetSummaryTopClientsManufacturersByUsageItemUsageArgs' usage: Clients usage
        """
        pulumi.set(__self__, "clients", clients)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "usage", usage)

    @_builtins.property
    @pulumi.getter
    def clients(self) -> 'outputs.GetSummaryTopClientsManufacturersByUsageItemClientsResult':
        """
        Clients info
        """
        return pulumi.get(self, "clients")

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

    @_builtins.property
    @pulumi.getter
    def usage(self) -> 'outputs.GetSummaryTopClientsManufacturersByUsageItemUsageResult':
        """
        Clients usage
        """
        return pulumi.get(self, "usage")


@pulumi.output_type
class GetSummaryTopClientsManufacturersByUsageItemClientsResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetSummaryTopClientsManufacturersByUsageItemClientsCountsResult'):
        """
        :param 'GetSummaryTopClientsManufacturersByUsageItemClientsCountsArgs' counts: Counts of clients
        """
        pulumi.set(__self__, "counts", counts)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> 'outputs.GetSummaryTopClientsManufacturersByUsageItemClientsCountsResult':
        """
        Counts of clients
        """
        return pulumi.get(self, "counts")


@pulumi.output_type
class GetSummaryTopClientsManufacturersByUsageItemClientsCountsResult(dict):
    def __init__(__self__, *,
                 total: _builtins.int):
        """
        :param _builtins.int total: Total counts of clients
        """
        pulumi.set(__self__, "total", total)

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total counts of clients
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetSummaryTopClientsManufacturersByUsageItemUsageResult(dict):
    def __init__(__self__, *,
                 downstream: _builtins.float,
                 total: _builtins.float,
                 upstream: _builtins.float):
        """
        :param _builtins.float downstream: Downstream data usage by client
        :param _builtins.float total: Total data usage by client
        :param _builtins.float upstream: Upstream data usage by client
        """
        pulumi.set(__self__, "downstream", downstream)
        pulumi.set(__self__, "total", total)
        pulumi.set(__self__, "upstream", upstream)

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> _builtins.float:
        """
        Downstream data usage by client
        """
        return pulumi.get(self, "downstream")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.float:
        """
        Total data usage by client
        """
        return pulumi.get(self, "total")

    @_builtins.property
    @pulumi.getter
    def upstream(self) -> _builtins.float:
        """
        Upstream data usage by client
        """
        return pulumi.get(self, "upstream")


@pulumi.output_type
class GetSummaryTopDevicesByUsageItemResult(dict):
    def __init__(__self__, *,
                 clients: 'outputs.GetSummaryTopDevicesByUsageItemClientsResult',
                 mac: _builtins.str,
                 model: _builtins.str,
                 name: _builtins.str,
                 network: 'outputs.GetSummaryTopDevicesByUsageItemNetworkResult',
                 product_type: _builtins.str,
                 serial: _builtins.str,
                 usage: 'outputs.GetSummaryTopDevicesByUsageItemUsageResult'):
        """
        :param 'GetSummaryTopDevicesByUsageItemClientsArgs' clients: Clients
        :param _builtins.str mac: Mac address of the device
        :param _builtins.str model: Model of the device
        :param _builtins.str name: Name of the device
        :param 'GetSummaryTopDevicesByUsageItemNetworkArgs' network: Network info
        :param _builtins.str product_type: Product type of the device
        :param _builtins.str serial: Serial number of the device
        :param 'GetSummaryTopDevicesByUsageItemUsageArgs' usage: Data usage of the device
        """
        pulumi.set(__self__, "clients", clients)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "usage", usage)

    @_builtins.property
    @pulumi.getter
    def clients(self) -> 'outputs.GetSummaryTopDevicesByUsageItemClientsResult':
        """
        Clients
        """
        return pulumi.get(self, "clients")

    @_builtins.property
    @pulumi.getter
    def mac(self) -> _builtins.str:
        """
        Mac address of the device
        """
        return pulumi.get(self, "mac")

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

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetSummaryTopDevicesByUsageItemNetworkResult':
        """
        Network info
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Product type of the device
        """
        return pulumi.get(self, "product_type")

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

    @_builtins.property
    @pulumi.getter
    def usage(self) -> 'outputs.GetSummaryTopDevicesByUsageItemUsageResult':
        """
        Data usage of the device
        """
        return pulumi.get(self, "usage")


@pulumi.output_type
class GetSummaryTopDevicesByUsageItemClientsResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetSummaryTopDevicesByUsageItemClientsCountsResult'):
        """
        :param 'GetSummaryTopDevicesByUsageItemClientsCountsArgs' counts: Counts of clients
        """
        pulumi.set(__self__, "counts", counts)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> 'outputs.GetSummaryTopDevicesByUsageItemClientsCountsResult':
        """
        Counts of clients
        """
        return pulumi.get(self, "counts")


@pulumi.output_type
class GetSummaryTopDevicesByUsageItemClientsCountsResult(dict):
    def __init__(__self__, *,
                 total: _builtins.int):
        """
        :param _builtins.int total: Total counts of clients
        """
        pulumi.set(__self__, "total", total)

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total counts of clients
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetSummaryTopDevicesByUsageItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: Network id
        :param _builtins.str name: Network name
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetSummaryTopDevicesByUsageItemUsageResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float,
                 total: _builtins.float):
        """
        :param _builtins.float percentage: Data usage of the device by percentage
        :param _builtins.float total: Total data usage of the device
        """
        pulumi.set(__self__, "percentage", percentage)
        pulumi.set(__self__, "total", total)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Data usage of the device by percentage
        """
        return pulumi.get(self, "percentage")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.float:
        """
        Total data usage of the device
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetSummaryTopDevicesModelsByUsageItemResult(dict):
    def __init__(__self__, *,
                 count: _builtins.int,
                 model: _builtins.str,
                 usage: 'outputs.GetSummaryTopDevicesModelsByUsageItemUsageResult'):
        """
        :param _builtins.int count: Total number of devices per model
        :param _builtins.str model: The device model
        :param 'GetSummaryTopDevicesModelsByUsageItemUsageArgs' usage: Usage info in megabytes
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "usage", usage)

    @_builtins.property
    @pulumi.getter
    def count(self) -> _builtins.int:
        """
        Total number of devices per model
        """
        return pulumi.get(self, "count")

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

    @_builtins.property
    @pulumi.getter
    def usage(self) -> 'outputs.GetSummaryTopDevicesModelsByUsageItemUsageResult':
        """
        Usage info in megabytes
        """
        return pulumi.get(self, "usage")


@pulumi.output_type
class GetSummaryTopDevicesModelsByUsageItemUsageResult(dict):
    def __init__(__self__, *,
                 average: _builtins.float,
                 total: _builtins.float):
        """
        :param _builtins.float average: Average usage in megabytes
        :param _builtins.float total: Total usage in megabytes
        """
        pulumi.set(__self__, "average", average)
        pulumi.set(__self__, "total", total)

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

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.float:
        """
        Total usage in megabytes
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetSummaryTopNetworksByStatusItemResult(dict):
    def __init__(__self__, *,
                 clients: 'outputs.GetSummaryTopNetworksByStatusItemClientsResult',
                 devices: 'outputs.GetSummaryTopNetworksByStatusItemDevicesResult',
                 name: _builtins.str,
                 network_id: _builtins.str,
                 product_types: Sequence[_builtins.str],
                 statuses: 'outputs.GetSummaryTopNetworksByStatusItemStatusesResult',
                 tags: Sequence[_builtins.str],
                 url: _builtins.str):
        """
        :param 'GetSummaryTopNetworksByStatusItemClientsArgs' clients: Network clients data
        :param 'GetSummaryTopNetworksByStatusItemDevicesArgs' devices: Network device information
        :param _builtins.str name: Network name
        :param _builtins.str network_id: Network identifier
        :param Sequence[_builtins.str] product_types: Product types in network
        :param 'GetSummaryTopNetworksByStatusItemStatusesArgs' statuses: Network device statuses
        :param Sequence[_builtins.str] tags: Network tags
        :param _builtins.str url: Network clients list URL
        """
        pulumi.set(__self__, "clients", clients)
        pulumi.set(__self__, "devices", devices)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "product_types", product_types)
        pulumi.set(__self__, "statuses", statuses)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter
    def clients(self) -> 'outputs.GetSummaryTopNetworksByStatusItemClientsResult':
        """
        Network clients data
        """
        return pulumi.get(self, "clients")

    @_builtins.property
    @pulumi.getter
    def devices(self) -> 'outputs.GetSummaryTopNetworksByStatusItemDevicesResult':
        """
        Network device information
        """
        return pulumi.get(self, "devices")

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

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        Network identifier
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="productTypes")
    def product_types(self) -> Sequence[_builtins.str]:
        """
        Product types in network
        """
        return pulumi.get(self, "product_types")

    @_builtins.property
    @pulumi.getter
    def statuses(self) -> 'outputs.GetSummaryTopNetworksByStatusItemStatusesResult':
        """
        Network device statuses
        """
        return pulumi.get(self, "statuses")

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

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


@pulumi.output_type
class GetSummaryTopNetworksByStatusItemClientsResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetSummaryTopNetworksByStatusItemClientsCountsResult',
                 usage: 'outputs.GetSummaryTopNetworksByStatusItemClientsUsageResult'):
        """
        :param 'GetSummaryTopNetworksByStatusItemClientsCountsArgs' counts: Network client counts
        :param 'GetSummaryTopNetworksByStatusItemClientsUsageArgs' usage: Network client usage data
        """
        pulumi.set(__self__, "counts", counts)
        pulumi.set(__self__, "usage", usage)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> 'outputs.GetSummaryTopNetworksByStatusItemClientsCountsResult':
        """
        Network client counts
        """
        return pulumi.get(self, "counts")

    @_builtins.property
    @pulumi.getter
    def usage(self) -> 'outputs.GetSummaryTopNetworksByStatusItemClientsUsageResult':
        """
        Network client usage data
        """
        return pulumi.get(self, "usage")


@pulumi.output_type
class GetSummaryTopNetworksByStatusItemClientsCountsResult(dict):
    def __init__(__self__, *,
                 total: _builtins.int):
        """
        :param _builtins.int total: Total count of clients in network
        """
        pulumi.set(__self__, "total", total)

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total count of clients in network
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetSummaryTopNetworksByStatusItemClientsUsageResult(dict):
    def __init__(__self__, *,
                 downstream: _builtins.float,
                 upstream: _builtins.float):
        """
        :param _builtins.float downstream: Total downstream usage in network, in KB
        :param _builtins.float upstream: Total upstream usage in network, in KB
        """
        pulumi.set(__self__, "downstream", downstream)
        pulumi.set(__self__, "upstream", upstream)

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> _builtins.float:
        """
        Total downstream usage in network, in KB
        """
        return pulumi.get(self, "downstream")

    @_builtins.property
    @pulumi.getter
    def upstream(self) -> _builtins.float:
        """
        Total upstream usage in network, in KB
        """
        return pulumi.get(self, "upstream")


@pulumi.output_type
class GetSummaryTopNetworksByStatusItemDevicesResult(dict):
    def __init__(__self__, *,
                 by_product_types: Sequence['outputs.GetSummaryTopNetworksByStatusItemDevicesByProductTypeResult']):
        """
        :param Sequence['GetSummaryTopNetworksByStatusItemDevicesByProductTypeArgs'] by_product_types: URLs by product type
        """
        pulumi.set(__self__, "by_product_types", by_product_types)

    @_builtins.property
    @pulumi.getter(name="byProductTypes")
    def by_product_types(self) -> Sequence['outputs.GetSummaryTopNetworksByStatusItemDevicesByProductTypeResult']:
        """
        URLs by product type
        """
        return pulumi.get(self, "by_product_types")


@pulumi.output_type
class GetSummaryTopNetworksByStatusItemDevicesByProductTypeResult(dict):
    def __init__(__self__, *,
                 product_type: _builtins.str,
                 url: _builtins.str):
        """
        :param _builtins.str product_type: Product type
        :param _builtins.str url: URL to clients list for the relevant product type
        """
        pulumi.set(__self__, "product_type", product_type)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Product type
        """
        return pulumi.get(self, "product_type")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        URL to clients list for the relevant product type
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetSummaryTopNetworksByStatusItemStatusesResult(dict):
    def __init__(__self__, *,
                 by_product_types: Sequence['outputs.GetSummaryTopNetworksByStatusItemStatusesByProductTypeResult'],
                 overall: _builtins.str):
        """
        :param Sequence['GetSummaryTopNetworksByStatusItemStatusesByProductTypeArgs'] by_product_types: List of status counts by product type
        :param _builtins.str overall: Overall status of network
        """
        pulumi.set(__self__, "by_product_types", by_product_types)
        pulumi.set(__self__, "overall", overall)

    @_builtins.property
    @pulumi.getter(name="byProductTypes")
    def by_product_types(self) -> Sequence['outputs.GetSummaryTopNetworksByStatusItemStatusesByProductTypeResult']:
        """
        List of status counts by product type
        """
        return pulumi.get(self, "by_product_types")

    @_builtins.property
    @pulumi.getter
    def overall(self) -> _builtins.str:
        """
        Overall status of network
        """
        return pulumi.get(self, "overall")


@pulumi.output_type
class GetSummaryTopNetworksByStatusItemStatusesByProductTypeResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetSummaryTopNetworksByStatusItemStatusesByProductTypeCountsResult',
                 product_type: _builtins.str):
        """
        :param 'GetSummaryTopNetworksByStatusItemStatusesByProductTypeCountsArgs' counts: Counts of devices by status
        :param _builtins.str product_type: Product type
        """
        pulumi.set(__self__, "counts", counts)
        pulumi.set(__self__, "product_type", product_type)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> 'outputs.GetSummaryTopNetworksByStatusItemStatusesByProductTypeCountsResult':
        """
        Counts of devices by status
        """
        return pulumi.get(self, "counts")

    @_builtins.property
    @pulumi.getter(name="productType")
    def product_type(self) -> _builtins.str:
        """
        Product type
        """
        return pulumi.get(self, "product_type")


@pulumi.output_type
class GetSummaryTopNetworksByStatusItemStatusesByProductTypeCountsResult(dict):
    def __init__(__self__, *,
                 alerting: _builtins.int,
                 dormant: _builtins.int,
                 offline: _builtins.int,
                 online: _builtins.int):
        """
        :param _builtins.int alerting: Count of alerting devices
        :param _builtins.int dormant: Count of dormant devices
        :param _builtins.int offline: Count of offline devices
        :param _builtins.int online: Count of online devices
        """
        pulumi.set(__self__, "alerting", alerting)
        pulumi.set(__self__, "dormant", dormant)
        pulumi.set(__self__, "offline", offline)
        pulumi.set(__self__, "online", online)

    @_builtins.property
    @pulumi.getter
    def alerting(self) -> _builtins.int:
        """
        Count of alerting devices
        """
        return pulumi.get(self, "alerting")

    @_builtins.property
    @pulumi.getter
    def dormant(self) -> _builtins.int:
        """
        Count of dormant devices
        """
        return pulumi.get(self, "dormant")

    @_builtins.property
    @pulumi.getter
    def offline(self) -> _builtins.int:
        """
        Count of offline devices
        """
        return pulumi.get(self, "offline")

    @_builtins.property
    @pulumi.getter
    def online(self) -> _builtins.int:
        """
        Count of online devices
        """
        return pulumi.get(self, "online")


@pulumi.output_type
class GetSummaryTopSsidsByUsageItemResult(dict):
    def __init__(__self__, *,
                 clients: 'outputs.GetSummaryTopSsidsByUsageItemClientsResult',
                 name: _builtins.str,
                 usage: 'outputs.GetSummaryTopSsidsByUsageItemUsageResult'):
        """
        :param 'GetSummaryTopSsidsByUsageItemClientsArgs' clients: Clients info of the SSID
        :param _builtins.str name: Name of the SSID
        :param 'GetSummaryTopSsidsByUsageItemUsageArgs' usage: Date usage of the SSID, in megabytes
        """
        pulumi.set(__self__, "clients", clients)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "usage", usage)

    @_builtins.property
    @pulumi.getter
    def clients(self) -> 'outputs.GetSummaryTopSsidsByUsageItemClientsResult':
        """
        Clients info of the SSID
        """
        return pulumi.get(self, "clients")

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

    @_builtins.property
    @pulumi.getter
    def usage(self) -> 'outputs.GetSummaryTopSsidsByUsageItemUsageResult':
        """
        Date usage of the SSID, in megabytes
        """
        return pulumi.get(self, "usage")


@pulumi.output_type
class GetSummaryTopSsidsByUsageItemClientsResult(dict):
    def __init__(__self__, *,
                 counts: 'outputs.GetSummaryTopSsidsByUsageItemClientsCountsResult'):
        """
        :param 'GetSummaryTopSsidsByUsageItemClientsCountsArgs' counts: Counts of the clients
        """
        pulumi.set(__self__, "counts", counts)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> 'outputs.GetSummaryTopSsidsByUsageItemClientsCountsResult':
        """
        Counts of the clients
        """
        return pulumi.get(self, "counts")


@pulumi.output_type
class GetSummaryTopSsidsByUsageItemClientsCountsResult(dict):
    def __init__(__self__, *,
                 total: _builtins.int):
        """
        :param _builtins.int total: Total counts of the clients
        """
        pulumi.set(__self__, "total", total)

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total counts of the clients
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetSummaryTopSsidsByUsageItemUsageResult(dict):
    def __init__(__self__, *,
                 downstream: _builtins.float,
                 percentage: _builtins.float,
                 total: _builtins.float,
                 upstream: _builtins.float):
        """
        :param _builtins.float downstream: Downstream usage of the SSID
        :param _builtins.float percentage: Percentage usage of the SSID
        :param _builtins.float total: Total usage of the SSID
        :param _builtins.float upstream: Upstream usage of the SSID
        """
        pulumi.set(__self__, "downstream", downstream)
        pulumi.set(__self__, "percentage", percentage)
        pulumi.set(__self__, "total", total)
        pulumi.set(__self__, "upstream", upstream)

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> _builtins.float:
        """
        Downstream usage of the SSID
        """
        return pulumi.get(self, "downstream")

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

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.float:
        """
        Total usage of the SSID
        """
        return pulumi.get(self, "total")

    @_builtins.property
    @pulumi.getter
    def upstream(self) -> _builtins.float:
        """
        Upstream usage of the SSID
        """
        return pulumi.get(self, "upstream")


@pulumi.output_type
class GetSummaryTopSwitchesByEnergyUsageItemResult(dict):
    def __init__(__self__, *,
                 mac: _builtins.str,
                 model: _builtins.str,
                 name: _builtins.str,
                 network: 'outputs.GetSummaryTopSwitchesByEnergyUsageItemNetworkResult',
                 usage: 'outputs.GetSummaryTopSwitchesByEnergyUsageItemUsageResult'):
        """
        :param _builtins.str mac: Mac address of the switch
        :param _builtins.str model: Model of the switch
        :param _builtins.str name: Name of the switch
        :param 'GetSummaryTopSwitchesByEnergyUsageItemNetworkArgs' network: Network info
        :param 'GetSummaryTopSwitchesByEnergyUsageItemUsageArgs' usage: Energy usage of the switch
        """
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "usage", usage)

    @_builtins.property
    @pulumi.getter
    def mac(self) -> _builtins.str:
        """
        Mac address of the switch
        """
        return pulumi.get(self, "mac")

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

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetSummaryTopSwitchesByEnergyUsageItemNetworkResult':
        """
        Network info
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter
    def usage(self) -> 'outputs.GetSummaryTopSwitchesByEnergyUsageItemUsageResult':
        """
        Energy usage of the switch
        """
        return pulumi.get(self, "usage")


@pulumi.output_type
class GetSummaryTopSwitchesByEnergyUsageItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: Network id
        :param _builtins.str name: Network name
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetSummaryTopSwitchesByEnergyUsageItemUsageResult(dict):
    def __init__(__self__, *,
                 total: _builtins.float):
        """
        :param _builtins.float total: Total energy usage of the switch
        """
        pulumi.set(__self__, "total", total)

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.float:
        """
        Total energy usage of the switch
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetSwitchPortsBySwitchItemResult(dict):
    def __init__(__self__, *,
                 mac: _builtins.str,
                 model: _builtins.str,
                 name: _builtins.str,
                 network: 'outputs.GetSwitchPortsBySwitchItemNetworkResult',
                 ports: Sequence['outputs.GetSwitchPortsBySwitchItemPortResult'],
                 serial: _builtins.str):
        """
        :param _builtins.str mac: The MAC address of the switch.
        :param _builtins.str model: The model of the switch.
        :param _builtins.str name: The name of the switch.
        :param 'GetSwitchPortsBySwitchItemNetworkArgs' network: Identifying information of the switch's network.
        :param Sequence['GetSwitchPortsBySwitchItemPortArgs'] ports: Ports belonging to the switch
        :param _builtins.str serial: The serial number of the switch.
        """
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "ports", ports)
        pulumi.set(__self__, "serial", serial)

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

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

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetSwitchPortsBySwitchItemNetworkResult':
        """
        Identifying information of the switch's network.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter
    def ports(self) -> Sequence['outputs.GetSwitchPortsBySwitchItemPortResult']:
        """
        Ports belonging to the switch
        """
        return pulumi.get(self, "ports")

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


@pulumi.output_type
class GetSwitchPortsBySwitchItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: The ID of the network.
        :param _builtins.str name: The name of the network.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetSwitchPortsBySwitchItemPortResult(dict):
    def __init__(__self__, *,
                 access_policy_type: _builtins.str,
                 allowed_vlans: _builtins.str,
                 enabled: _builtins.bool,
                 link_negotiation: _builtins.str,
                 name: _builtins.str,
                 poe_enabled: _builtins.bool,
                 port_id: _builtins.str,
                 rstp_enabled: _builtins.bool,
                 sticky_mac_allow_list_limit: _builtins.int,
                 sticky_mac_allow_lists: Sequence[_builtins.str],
                 stp_guard: _builtins.str,
                 tags: Sequence[_builtins.str],
                 type: _builtins.str,
                 vlan: _builtins.int,
                 voice_vlan: _builtins.int):
        """
        :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 allowed_vlans: The VLANs allowed on the switch port. Only applicable to trunk ports.
        :param _builtins.bool enabled: The status of the switch port.
        :param _builtins.str link_negotiation: The link speed for the switch port.
        :param _builtins.str name: The name of the switch port.
        :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.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.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.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_type", access_policy_type)
        pulumi.set(__self__, "allowed_vlans", allowed_vlans)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "link_negotiation", link_negotiation)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "poe_enabled", poe_enabled)
        pulumi.set(__self__, "port_id", port_id)
        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__, "stp_guard", stp_guard)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "vlan", vlan)
        pulumi.set(__self__, "voice_vlan", voice_vlan)

    @_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="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
    def enabled(self) -> _builtins.bool:
        """
        The status of the switch port.
        """
        return pulumi.get(self, "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
    def name(self) -> _builtins.str:
        """
        The name of the switch port.
        """
        return pulumi.get(self, "name")

    @_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="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="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 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 GetUplinksStatusesItemResult(dict):
    def __init__(__self__, *,
                 high_availability: 'outputs.GetUplinksStatusesItemHighAvailabilityResult',
                 last_reported_at: _builtins.str,
                 model: _builtins.str,
                 network_id: _builtins.str,
                 serial: _builtins.str,
                 uplinks: Sequence['outputs.GetUplinksStatusesItemUplinkResult']):
        """
        :param 'GetUplinksStatusesItemHighAvailabilityArgs' high_availability: Device High Availability Capabilities
        :param _builtins.str last_reported_at: Last reported time for the device
        :param _builtins.str model: The uplink model
        :param _builtins.str network_id: Network identifier
        :param _builtins.str serial: The uplink serial
        :param Sequence['GetUplinksStatusesItemUplinkArgs'] uplinks: Uplinks
        """
        pulumi.set(__self__, "high_availability", high_availability)
        pulumi.set(__self__, "last_reported_at", last_reported_at)
        pulumi.set(__self__, "model", model)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "uplinks", uplinks)

    @_builtins.property
    @pulumi.getter(name="highAvailability")
    def high_availability(self) -> 'outputs.GetUplinksStatusesItemHighAvailabilityResult':
        """
        Device High Availability Capabilities
        """
        return pulumi.get(self, "high_availability")

    @_builtins.property
    @pulumi.getter(name="lastReportedAt")
    def last_reported_at(self) -> _builtins.str:
        """
        Last reported time for the device
        """
        return pulumi.get(self, "last_reported_at")

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

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        Network identifier
        """
        return pulumi.get(self, "network_id")

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

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


@pulumi.output_type
class GetUplinksStatusesItemHighAvailabilityResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 role: _builtins.str):
        """
        :param _builtins.bool enabled: Indicates whether High Availability is enabled for the device. For devices that do not support HA, this will be 'false'
        :param _builtins.str role: The HA role of the device on the network. For devices that do not support HA, this will be 'primary'
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "role", role)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> _builtins.bool:
        """
        Indicates whether High Availability is enabled for the device. For devices that do not support HA, this will be 'false'
        """
        return pulumi.get(self, "enabled")

    @_builtins.property
    @pulumi.getter
    def role(self) -> _builtins.str:
        """
        The HA role of the device on the network. For devices that do not support HA, this will be 'primary'
        """
        return pulumi.get(self, "role")


@pulumi.output_type
class GetUplinksStatusesItemUplinkResult(dict):
    def __init__(__self__, *,
                 apn: _builtins.str,
                 connection_type: _builtins.str,
                 dns1: _builtins.str,
                 dns2: _builtins.str,
                 gateway: _builtins.str,
                 iccid: _builtins.str,
                 interface: _builtins.str,
                 ip: _builtins.str,
                 ip_assigned_by: _builtins.str,
                 primary_dns: _builtins.str,
                 provider: _builtins.str,
                 public_ip: _builtins.str,
                 secondary_dns: _builtins.str,
                 signal_stat: 'outputs.GetUplinksStatusesItemUplinkSignalStatResult',
                 signal_type: _builtins.str,
                 status: _builtins.str):
        """
        :param _builtins.str apn: Access Point Name
        :param _builtins.str connection_type: Connection Type
        :param _builtins.str dns1: Primary DNS IP
        :param _builtins.str dns2: Secondary DNS IP
        :param _builtins.str gateway: Gateway IP
        :param _builtins.str iccid: Integrated Circuit Card Identification Number
        :param _builtins.str interface: Uplink interface
        :param _builtins.str ip: Uplink IP
        :param _builtins.str ip_assigned_by: The way in which the IP is assigned
        :param _builtins.str primary_dns: Primary DNS IP
        :param _builtins.str provider: Network Provider
        :param _builtins.str public_ip: Public IP
        :param _builtins.str secondary_dns: Secondary DNS IP
        :param 'GetUplinksStatusesItemUplinkSignalStatArgs' signal_stat: Tower Signal Status
        :param _builtins.str signal_type: Signal Type
        :param _builtins.str status: Uplink status
        """
        pulumi.set(__self__, "apn", apn)
        pulumi.set(__self__, "connection_type", connection_type)
        pulumi.set(__self__, "dns1", dns1)
        pulumi.set(__self__, "dns2", dns2)
        pulumi.set(__self__, "gateway", gateway)
        pulumi.set(__self__, "iccid", iccid)
        pulumi.set(__self__, "interface", interface)
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "ip_assigned_by", ip_assigned_by)
        pulumi.set(__self__, "primary_dns", primary_dns)
        pulumi.set(__self__, "provider", provider)
        pulumi.set(__self__, "public_ip", public_ip)
        pulumi.set(__self__, "secondary_dns", secondary_dns)
        pulumi.set(__self__, "signal_stat", signal_stat)
        pulumi.set(__self__, "signal_type", signal_type)
        pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter
    def apn(self) -> _builtins.str:
        """
        Access Point Name
        """
        return pulumi.get(self, "apn")

    @_builtins.property
    @pulumi.getter(name="connectionType")
    def connection_type(self) -> _builtins.str:
        """
        Connection Type
        """
        return pulumi.get(self, "connection_type")

    @_builtins.property
    @pulumi.getter
    def dns1(self) -> _builtins.str:
        """
        Primary DNS IP
        """
        return pulumi.get(self, "dns1")

    @_builtins.property
    @pulumi.getter
    def dns2(self) -> _builtins.str:
        """
        Secondary DNS IP
        """
        return pulumi.get(self, "dns2")

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

    @_builtins.property
    @pulumi.getter
    def iccid(self) -> _builtins.str:
        """
        Integrated Circuit Card Identification Number
        """
        return pulumi.get(self, "iccid")

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

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

    @_builtins.property
    @pulumi.getter(name="ipAssignedBy")
    def ip_assigned_by(self) -> _builtins.str:
        """
        The way in which the IP is assigned
        """
        return pulumi.get(self, "ip_assigned_by")

    @_builtins.property
    @pulumi.getter(name="primaryDns")
    def primary_dns(self) -> _builtins.str:
        """
        Primary DNS IP
        """
        return pulumi.get(self, "primary_dns")

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

    @_builtins.property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> _builtins.str:
        """
        Public IP
        """
        return pulumi.get(self, "public_ip")

    @_builtins.property
    @pulumi.getter(name="secondaryDns")
    def secondary_dns(self) -> _builtins.str:
        """
        Secondary DNS IP
        """
        return pulumi.get(self, "secondary_dns")

    @_builtins.property
    @pulumi.getter(name="signalStat")
    def signal_stat(self) -> 'outputs.GetUplinksStatusesItemUplinkSignalStatResult':
        """
        Tower Signal Status
        """
        return pulumi.get(self, "signal_stat")

    @_builtins.property
    @pulumi.getter(name="signalType")
    def signal_type(self) -> _builtins.str:
        """
        Signal Type
        """
        return pulumi.get(self, "signal_type")

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


@pulumi.output_type
class GetUplinksStatusesItemUplinkSignalStatResult(dict):
    def __init__(__self__, *,
                 rsrp: _builtins.str,
                 rsrq: _builtins.str):
        """
        :param _builtins.str rsrp: Reference Signal Received Power
        :param _builtins.str rsrq: Reference Signal Received Quality
        """
        pulumi.set(__self__, "rsrp", rsrp)
        pulumi.set(__self__, "rsrq", rsrq)

    @_builtins.property
    @pulumi.getter
    def rsrp(self) -> _builtins.str:
        """
        Reference Signal Received Power
        """
        return pulumi.get(self, "rsrp")

    @_builtins.property
    @pulumi.getter
    def rsrq(self) -> _builtins.str:
        """
        Reference Signal Received Quality
        """
        return pulumi.get(self, "rsrq")


@pulumi.output_type
class GetWebhooksCallbacksStatusesItemResult(dict):
    def __init__(__self__, *,
                 callback_id: _builtins.str,
                 created_by: 'outputs.GetWebhooksCallbacksStatusesItemCreatedByResult',
                 errors: Sequence[_builtins.str],
                 status: _builtins.str,
                 webhook: 'outputs.GetWebhooksCallbacksStatusesItemWebhookResult'):
        """
        :param _builtins.str callback_id: The ID of the callback
        :param 'GetWebhooksCallbacksStatusesItemCreatedByArgs' created_by: Information around who initiated the callback
        :param Sequence[_builtins.str] errors: The errors returned by the callback
        :param _builtins.str status: The status of the callback
        :param 'GetWebhooksCallbacksStatusesItemWebhookArgs' webhook: The webhook receiver used by the callback to send results
        """
        pulumi.set(__self__, "callback_id", callback_id)
        pulumi.set(__self__, "created_by", created_by)
        pulumi.set(__self__, "errors", errors)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "webhook", webhook)

    @_builtins.property
    @pulumi.getter(name="callbackId")
    def callback_id(self) -> _builtins.str:
        """
        The ID of the callback
        """
        return pulumi.get(self, "callback_id")

    @_builtins.property
    @pulumi.getter(name="createdBy")
    def created_by(self) -> 'outputs.GetWebhooksCallbacksStatusesItemCreatedByResult':
        """
        Information around who initiated the callback
        """
        return pulumi.get(self, "created_by")

    @_builtins.property
    @pulumi.getter
    def errors(self) -> Sequence[_builtins.str]:
        """
        The errors returned by the callback
        """
        return pulumi.get(self, "errors")

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

    @_builtins.property
    @pulumi.getter
    def webhook(self) -> 'outputs.GetWebhooksCallbacksStatusesItemWebhookResult':
        """
        The webhook receiver used by the callback to send results
        """
        return pulumi.get(self, "webhook")


@pulumi.output_type
class GetWebhooksCallbacksStatusesItemCreatedByResult(dict):
    def __init__(__self__, *,
                 admin_id: _builtins.str):
        """
        :param _builtins.str admin_id: The ID of the user who initiated the callback
        """
        pulumi.set(__self__, "admin_id", admin_id)

    @_builtins.property
    @pulumi.getter(name="adminId")
    def admin_id(self) -> _builtins.str:
        """
        The ID of the user who initiated the callback
        """
        return pulumi.get(self, "admin_id")


@pulumi.output_type
class GetWebhooksCallbacksStatusesItemWebhookResult(dict):
    def __init__(__self__, *,
                 http_server: 'outputs.GetWebhooksCallbacksStatusesItemWebhookHttpServerResult',
                 payload_template: 'outputs.GetWebhooksCallbacksStatusesItemWebhookPayloadTemplateResult',
                 sent_at: _builtins.str,
                 url: _builtins.str):
        """
        :param 'GetWebhooksCallbacksStatusesItemWebhookHttpServerArgs' http_server: The webhook receiver used for the callback webhook
        :param 'GetWebhooksCallbacksStatusesItemWebhookPayloadTemplateArgs' payload_template: The payload template of the webhook used for the callback
        :param _builtins.str sent_at: The timestamp the callback was sent to the webhook receiver
        :param _builtins.str url: The webhook receiver URL where the callback will be sent
        """
        pulumi.set(__self__, "http_server", http_server)
        pulumi.set(__self__, "payload_template", payload_template)
        pulumi.set(__self__, "sent_at", sent_at)
        pulumi.set(__self__, "url", url)

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

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

    @_builtins.property
    @pulumi.getter(name="sentAt")
    def sent_at(self) -> _builtins.str:
        """
        The timestamp the callback was sent to the webhook receiver
        """
        return pulumi.get(self, "sent_at")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        The webhook receiver URL where the callback will be sent
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetWebhooksCallbacksStatusesItemWebhookHttpServerResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: The webhook receiver ID that will receive information
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        The webhook receiver ID that will receive information
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetWebhooksCallbacksStatusesItemWebhookPayloadTemplateResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: The ID of the payload template
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        The ID of the payload template
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetWebhooksLogsItemResult(dict):
    def __init__(__self__, *,
                 alert_type: _builtins.str,
                 logged_at: _builtins.str,
                 network_id: _builtins.str,
                 organization_id: _builtins.str,
                 response_code: _builtins.int,
                 response_duration: _builtins.int,
                 sent_at: _builtins.str,
                 url: _builtins.str):
        """
        :param _builtins.str alert_type: Type of alert that the webhook is delivering
        :param _builtins.str logged_at: When the webhook log was created, in ISO8601 format
        :param _builtins.str network_id: Network ID for the webhook log
        :param _builtins.str organization_id: ID for the webhook log's organization
        :param _builtins.int response_code: Response code from the webhook
        :param _builtins.int response_duration: Duration of the response, in milliseconds
        :param _builtins.str sent_at: When the webhook was sent, in ISO8601 format
        :param _builtins.str url: URL where the webhook was sent
        """
        pulumi.set(__self__, "alert_type", alert_type)
        pulumi.set(__self__, "logged_at", logged_at)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "organization_id", organization_id)
        pulumi.set(__self__, "response_code", response_code)
        pulumi.set(__self__, "response_duration", response_duration)
        pulumi.set(__self__, "sent_at", sent_at)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="alertType")
    def alert_type(self) -> _builtins.str:
        """
        Type of alert that the webhook is delivering
        """
        return pulumi.get(self, "alert_type")

    @_builtins.property
    @pulumi.getter(name="loggedAt")
    def logged_at(self) -> _builtins.str:
        """
        When the webhook log was created, in ISO8601 format
        """
        return pulumi.get(self, "logged_at")

    @_builtins.property
    @pulumi.getter(name="networkId")
    def network_id(self) -> _builtins.str:
        """
        Network ID for the webhook log
        """
        return pulumi.get(self, "network_id")

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> _builtins.str:
        """
        ID for the webhook log's organization
        """
        return pulumi.get(self, "organization_id")

    @_builtins.property
    @pulumi.getter(name="responseCode")
    def response_code(self) -> _builtins.int:
        """
        Response code from the webhook
        """
        return pulumi.get(self, "response_code")

    @_builtins.property
    @pulumi.getter(name="responseDuration")
    def response_duration(self) -> _builtins.int:
        """
        Duration of the response, in milliseconds
        """
        return pulumi.get(self, "response_duration")

    @_builtins.property
    @pulumi.getter(name="sentAt")
    def sent_at(self) -> _builtins.str:
        """
        When the webhook was sent, in ISO8601 format
        """
        return pulumi.get(self, "sent_at")

    @_builtins.property
    @pulumi.getter
    def url(self) -> _builtins.str:
        """
        URL where the webhook was sent
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByDeviceItemResult(dict):
    def __init__(__self__, *,
                 by_bands: Sequence['outputs.GetWirelessDevicesChannelUtilizationByDeviceItemByBandResult'],
                 mac: _builtins.str,
                 network: 'outputs.GetWirelessDevicesChannelUtilizationByDeviceItemNetworkResult',
                 serial: _builtins.str):
        """
        :param Sequence['GetWirelessDevicesChannelUtilizationByDeviceItemByBandArgs'] by_bands: Channel utilization broken down by band.
        :param _builtins.str mac: The MAC address of the device.
        :param 'GetWirelessDevicesChannelUtilizationByDeviceItemNetworkArgs' network: Network for the given utilization metrics.
        :param _builtins.str serial: The serial number for the device.
        """
        pulumi.set(__self__, "by_bands", by_bands)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter(name="byBands")
    def by_bands(self) -> Sequence['outputs.GetWirelessDevicesChannelUtilizationByDeviceItemByBandResult']:
        """
        Channel utilization broken down by band.
        """
        return pulumi.get(self, "by_bands")

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetWirelessDevicesChannelUtilizationByDeviceItemNetworkResult':
        """
        Network for the given utilization metrics.
        """
        return pulumi.get(self, "network")

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


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByDeviceItemByBandResult(dict):
    def __init__(__self__, *,
                 band: _builtins.str,
                 non_wifi: 'outputs.GetWirelessDevicesChannelUtilizationByDeviceItemByBandNonWifiResult',
                 total: 'outputs.GetWirelessDevicesChannelUtilizationByDeviceItemByBandTotalResult',
                 wifi: 'outputs.GetWirelessDevicesChannelUtilizationByDeviceItemByBandWifiResult'):
        """
        :param _builtins.str band: The band for the given metrics.
        :param 'GetWirelessDevicesChannelUtilizationByDeviceItemByBandNonWifiArgs' non_wifi: An object containing non-wifi utilization.
        :param 'GetWirelessDevicesChannelUtilizationByDeviceItemByBandTotalArgs' total: An object containing total channel utilization.
        :param 'GetWirelessDevicesChannelUtilizationByDeviceItemByBandWifiArgs' wifi: An object containing wifi utilization.
        """
        pulumi.set(__self__, "band", band)
        pulumi.set(__self__, "non_wifi", non_wifi)
        pulumi.set(__self__, "total", total)
        pulumi.set(__self__, "wifi", wifi)

    @_builtins.property
    @pulumi.getter
    def band(self) -> _builtins.str:
        """
        The band for the given metrics.
        """
        return pulumi.get(self, "band")

    @_builtins.property
    @pulumi.getter(name="nonWifi")
    def non_wifi(self) -> 'outputs.GetWirelessDevicesChannelUtilizationByDeviceItemByBandNonWifiResult':
        """
        An object containing non-wifi utilization.
        """
        return pulumi.get(self, "non_wifi")

    @_builtins.property
    @pulumi.getter
    def total(self) -> 'outputs.GetWirelessDevicesChannelUtilizationByDeviceItemByBandTotalResult':
        """
        An object containing total channel utilization.
        """
        return pulumi.get(self, "total")

    @_builtins.property
    @pulumi.getter
    def wifi(self) -> 'outputs.GetWirelessDevicesChannelUtilizationByDeviceItemByBandWifiResult':
        """
        An object containing wifi utilization.
        """
        return pulumi.get(self, "wifi")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByDeviceItemByBandNonWifiResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of non-wifi channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of non-wifi channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByDeviceItemByBandTotalResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of total channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of total channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByDeviceItemByBandWifiResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of wifi channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of wifi channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByDeviceItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: Network ID of the given utilization metrics.
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Network ID of the given utilization metrics.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByNetworkItemResult(dict):
    def __init__(__self__, *,
                 by_bands: Sequence['outputs.GetWirelessDevicesChannelUtilizationByNetworkItemByBandResult'],
                 network: 'outputs.GetWirelessDevicesChannelUtilizationByNetworkItemNetworkResult'):
        """
        :param Sequence['GetWirelessDevicesChannelUtilizationByNetworkItemByBandArgs'] by_bands: Channel utilization broken down by band.
        :param 'GetWirelessDevicesChannelUtilizationByNetworkItemNetworkArgs' network: Network for the given utilization metrics.
        """
        pulumi.set(__self__, "by_bands", by_bands)
        pulumi.set(__self__, "network", network)

    @_builtins.property
    @pulumi.getter(name="byBands")
    def by_bands(self) -> Sequence['outputs.GetWirelessDevicesChannelUtilizationByNetworkItemByBandResult']:
        """
        Channel utilization broken down by band.
        """
        return pulumi.get(self, "by_bands")

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetWirelessDevicesChannelUtilizationByNetworkItemNetworkResult':
        """
        Network for the given utilization metrics.
        """
        return pulumi.get(self, "network")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByNetworkItemByBandResult(dict):
    def __init__(__self__, *,
                 band: _builtins.str,
                 non_wifi: 'outputs.GetWirelessDevicesChannelUtilizationByNetworkItemByBandNonWifiResult',
                 total: 'outputs.GetWirelessDevicesChannelUtilizationByNetworkItemByBandTotalResult',
                 wifi: 'outputs.GetWirelessDevicesChannelUtilizationByNetworkItemByBandWifiResult'):
        """
        :param _builtins.str band: The band for the given metrics.
        :param 'GetWirelessDevicesChannelUtilizationByNetworkItemByBandNonWifiArgs' non_wifi: An object containing non-wifi utilization.
        :param 'GetWirelessDevicesChannelUtilizationByNetworkItemByBandTotalArgs' total: An object containing total channel utilization.
        :param 'GetWirelessDevicesChannelUtilizationByNetworkItemByBandWifiArgs' wifi: An object containing wifi utilization.
        """
        pulumi.set(__self__, "band", band)
        pulumi.set(__self__, "non_wifi", non_wifi)
        pulumi.set(__self__, "total", total)
        pulumi.set(__self__, "wifi", wifi)

    @_builtins.property
    @pulumi.getter
    def band(self) -> _builtins.str:
        """
        The band for the given metrics.
        """
        return pulumi.get(self, "band")

    @_builtins.property
    @pulumi.getter(name="nonWifi")
    def non_wifi(self) -> 'outputs.GetWirelessDevicesChannelUtilizationByNetworkItemByBandNonWifiResult':
        """
        An object containing non-wifi utilization.
        """
        return pulumi.get(self, "non_wifi")

    @_builtins.property
    @pulumi.getter
    def total(self) -> 'outputs.GetWirelessDevicesChannelUtilizationByNetworkItemByBandTotalResult':
        """
        An object containing total channel utilization.
        """
        return pulumi.get(self, "total")

    @_builtins.property
    @pulumi.getter
    def wifi(self) -> 'outputs.GetWirelessDevicesChannelUtilizationByNetworkItemByBandWifiResult':
        """
        An object containing wifi utilization.
        """
        return pulumi.get(self, "wifi")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByNetworkItemByBandNonWifiResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of non-wifi channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of non-wifi channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByNetworkItemByBandTotalResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of total channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of total channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByNetworkItemByBandWifiResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of wifi channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of wifi channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationByNetworkItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: Network ID of the given utilization metrics.
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Network ID of the given utilization metrics.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemResult(dict):
    def __init__(__self__, *,
                 by_bands: Sequence['outputs.GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandResult'],
                 end_ts: _builtins.str,
                 mac: _builtins.str,
                 network: 'outputs.GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemNetworkResult',
                 serial: _builtins.str,
                 start_ts: _builtins.str):
        """
        :param Sequence['GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandArgs'] by_bands: Channel utilization broken down by band.
        :param _builtins.str end_ts: The end time of the channel utilization interval.
        :param _builtins.str mac: The MAC address of the device.
        :param 'GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemNetworkArgs' network: Network for the given utilization metrics.
        :param _builtins.str serial: The serial number for the device.
        :param _builtins.str start_ts: The start time of the channel utilization interval.
        """
        pulumi.set(__self__, "by_bands", by_bands)
        pulumi.set(__self__, "end_ts", end_ts)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "serial", serial)
        pulumi.set(__self__, "start_ts", start_ts)

    @_builtins.property
    @pulumi.getter(name="byBands")
    def by_bands(self) -> Sequence['outputs.GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandResult']:
        """
        Channel utilization broken down by band.
        """
        return pulumi.get(self, "by_bands")

    @_builtins.property
    @pulumi.getter(name="endTs")
    def end_ts(self) -> _builtins.str:
        """
        The end time of the channel utilization interval.
        """
        return pulumi.get(self, "end_ts")

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemNetworkResult':
        """
        Network for the given utilization metrics.
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter(name="startTs")
    def start_ts(self) -> _builtins.str:
        """
        The start time of the channel utilization interval.
        """
        return pulumi.get(self, "start_ts")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandResult(dict):
    def __init__(__self__, *,
                 band: _builtins.str,
                 non_wifi: 'outputs.GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandNonWifiResult',
                 total: 'outputs.GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandTotalResult',
                 wifi: 'outputs.GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandWifiResult'):
        """
        :param _builtins.str band: The band for the given metrics.
        :param 'GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandNonWifiArgs' non_wifi: An object containing non-wifi utilization.
        :param 'GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandTotalArgs' total: An object containing total channel utilization.
        :param 'GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandWifiArgs' wifi: An object containing wifi utilization.
        """
        pulumi.set(__self__, "band", band)
        pulumi.set(__self__, "non_wifi", non_wifi)
        pulumi.set(__self__, "total", total)
        pulumi.set(__self__, "wifi", wifi)

    @_builtins.property
    @pulumi.getter
    def band(self) -> _builtins.str:
        """
        The band for the given metrics.
        """
        return pulumi.get(self, "band")

    @_builtins.property
    @pulumi.getter(name="nonWifi")
    def non_wifi(self) -> 'outputs.GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandNonWifiResult':
        """
        An object containing non-wifi utilization.
        """
        return pulumi.get(self, "non_wifi")

    @_builtins.property
    @pulumi.getter
    def total(self) -> 'outputs.GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandTotalResult':
        """
        An object containing total channel utilization.
        """
        return pulumi.get(self, "total")

    @_builtins.property
    @pulumi.getter
    def wifi(self) -> 'outputs.GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandWifiResult':
        """
        An object containing wifi utilization.
        """
        return pulumi.get(self, "wifi")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandNonWifiResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of non-wifi channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of non-wifi channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandTotalResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of total channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of total channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemByBandWifiResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of wifi channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of wifi channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByDeviceByIntervalItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: Network ID of the given utilization metrics.
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Network ID of the given utilization metrics.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemResult(dict):
    def __init__(__self__, *,
                 by_bands: Sequence['outputs.GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandResult'],
                 end_ts: _builtins.str,
                 network: 'outputs.GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemNetworkResult',
                 start_ts: _builtins.str):
        """
        :param Sequence['GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandArgs'] by_bands: Channel utilization broken down by band.
        :param _builtins.str end_ts: The end time of the channel utilization interval.
        :param 'GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemNetworkArgs' network: Network for the given utilization metrics.
        :param _builtins.str start_ts: The start time of the channel utilization interval.
        """
        pulumi.set(__self__, "by_bands", by_bands)
        pulumi.set(__self__, "end_ts", end_ts)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "start_ts", start_ts)

    @_builtins.property
    @pulumi.getter(name="byBands")
    def by_bands(self) -> Sequence['outputs.GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandResult']:
        """
        Channel utilization broken down by band.
        """
        return pulumi.get(self, "by_bands")

    @_builtins.property
    @pulumi.getter(name="endTs")
    def end_ts(self) -> _builtins.str:
        """
        The end time of the channel utilization interval.
        """
        return pulumi.get(self, "end_ts")

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemNetworkResult':
        """
        Network for the given utilization metrics.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter(name="startTs")
    def start_ts(self) -> _builtins.str:
        """
        The start time of the channel utilization interval.
        """
        return pulumi.get(self, "start_ts")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandResult(dict):
    def __init__(__self__, *,
                 band: _builtins.str,
                 non_wifi: 'outputs.GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandNonWifiResult',
                 total: 'outputs.GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandTotalResult',
                 wifi: 'outputs.GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandWifiResult'):
        """
        :param _builtins.str band: The band for the given metrics.
        :param 'GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandNonWifiArgs' non_wifi: An object containing non-wifi utilization.
        :param 'GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandTotalArgs' total: An object containing total channel utilization.
        :param 'GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandWifiArgs' wifi: An object containing wifi utilization.
        """
        pulumi.set(__self__, "band", band)
        pulumi.set(__self__, "non_wifi", non_wifi)
        pulumi.set(__self__, "total", total)
        pulumi.set(__self__, "wifi", wifi)

    @_builtins.property
    @pulumi.getter
    def band(self) -> _builtins.str:
        """
        The band for the given metrics.
        """
        return pulumi.get(self, "band")

    @_builtins.property
    @pulumi.getter(name="nonWifi")
    def non_wifi(self) -> 'outputs.GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandNonWifiResult':
        """
        An object containing non-wifi utilization.
        """
        return pulumi.get(self, "non_wifi")

    @_builtins.property
    @pulumi.getter
    def total(self) -> 'outputs.GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandTotalResult':
        """
        An object containing total channel utilization.
        """
        return pulumi.get(self, "total")

    @_builtins.property
    @pulumi.getter
    def wifi(self) -> 'outputs.GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandWifiResult':
        """
        An object containing wifi utilization.
        """
        return pulumi.get(self, "wifi")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandNonWifiResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of non-wifi channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of non-wifi channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandTotalResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of total channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of total channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemByBandWifiResult(dict):
    def __init__(__self__, *,
                 percentage: _builtins.float):
        """
        :param _builtins.float percentage: Percentage of wifi channel utiliation for the given band.
        """
        pulumi.set(__self__, "percentage", percentage)

    @_builtins.property
    @pulumi.getter
    def percentage(self) -> _builtins.float:
        """
        Percentage of wifi channel utiliation for the given band.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class GetWirelessDevicesChannelUtilizationHistoryByNetworkByIntervalItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: Network ID of the given utilization metrics.
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        Network ID of the given utilization metrics.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetWirelessDevicesEthernetStatusesItemResult(dict):
    def __init__(__self__, *,
                 aggregation: 'outputs.GetWirelessDevicesEthernetStatusesItemAggregationResult',
                 name: _builtins.str,
                 network: 'outputs.GetWirelessDevicesEthernetStatusesItemNetworkResult',
                 ports: Sequence['outputs.GetWirelessDevicesEthernetStatusesItemPortResult'],
                 power: 'outputs.GetWirelessDevicesEthernetStatusesItemPowerResult',
                 serial: _builtins.str):
        """
        :param 'GetWirelessDevicesEthernetStatusesItemAggregationArgs' aggregation: Aggregation details object
        :param _builtins.str name: The name of the AP
        :param 'GetWirelessDevicesEthernetStatusesItemNetworkArgs' network: Network details object
        :param Sequence['GetWirelessDevicesEthernetStatusesItemPortArgs'] ports: List of port details
        :param 'GetWirelessDevicesEthernetStatusesItemPowerArgs' power: Power details object
        :param _builtins.str serial: The serial number of the AP
        """
        pulumi.set(__self__, "aggregation", aggregation)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "ports", ports)
        pulumi.set(__self__, "power", power)
        pulumi.set(__self__, "serial", serial)

    @_builtins.property
    @pulumi.getter
    def aggregation(self) -> 'outputs.GetWirelessDevicesEthernetStatusesItemAggregationResult':
        """
        Aggregation details object
        """
        return pulumi.get(self, "aggregation")

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

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetWirelessDevicesEthernetStatusesItemNetworkResult':
        """
        Network details object
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter
    def ports(self) -> Sequence['outputs.GetWirelessDevicesEthernetStatusesItemPortResult']:
        """
        List of port details
        """
        return pulumi.get(self, "ports")

    @_builtins.property
    @pulumi.getter
    def power(self) -> 'outputs.GetWirelessDevicesEthernetStatusesItemPowerResult':
        """
        Power details object
        """
        return pulumi.get(self, "power")

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


@pulumi.output_type
class GetWirelessDevicesEthernetStatusesItemAggregationResult(dict):
    def __init__(__self__, *,
                 enabled: _builtins.bool,
                 speed: _builtins.int):
        """
        :param _builtins.bool enabled: Link Aggregation enabled flag
        :param _builtins.int speed: Link Aggregation speed
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "speed", speed)

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

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


@pulumi.output_type
class GetWirelessDevicesEthernetStatusesItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str):
        """
        :param _builtins.str id: The network ID the AP is associated to
        """
        pulumi.set(__self__, "id", id)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        The network ID the AP is associated to
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetWirelessDevicesEthernetStatusesItemPortResult(dict):
    def __init__(__self__, *,
                 link_negotiation: 'outputs.GetWirelessDevicesEthernetStatusesItemPortLinkNegotiationResult',
                 name: _builtins.str,
                 poe: 'outputs.GetWirelessDevicesEthernetStatusesItemPortPoeResult'):
        """
        :param 'GetWirelessDevicesEthernetStatusesItemPortLinkNegotiationArgs' link_negotiation: Link negotiation details object for the port
        :param _builtins.str name: Label of the port
        :param 'GetWirelessDevicesEthernetStatusesItemPortPoeArgs' poe: PoE details object for the port
        """
        pulumi.set(__self__, "link_negotiation", link_negotiation)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "poe", poe)

    @_builtins.property
    @pulumi.getter(name="linkNegotiation")
    def link_negotiation(self) -> 'outputs.GetWirelessDevicesEthernetStatusesItemPortLinkNegotiationResult':
        """
        Link negotiation details object for the port
        """
        return pulumi.get(self, "link_negotiation")

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

    @_builtins.property
    @pulumi.getter
    def poe(self) -> 'outputs.GetWirelessDevicesEthernetStatusesItemPortPoeResult':
        """
        PoE details object for the port
        """
        return pulumi.get(self, "poe")


@pulumi.output_type
class GetWirelessDevicesEthernetStatusesItemPortLinkNegotiationResult(dict):
    def __init__(__self__, *,
                 duplex: _builtins.str,
                 speed: _builtins.int):
        """
        :param _builtins.str duplex: The duplex mode of the port. Can be 'full' or 'half'
        :param _builtins.int speed: The speed of the port
        """
        pulumi.set(__self__, "duplex", duplex)
        pulumi.set(__self__, "speed", speed)

    @_builtins.property
    @pulumi.getter
    def duplex(self) -> _builtins.str:
        """
        The duplex mode of the port. Can be 'full' or 'half'
        """
        return pulumi.get(self, "duplex")

    @_builtins.property
    @pulumi.getter
    def speed(self) -> _builtins.int:
        """
        The speed of the port
        """
        return pulumi.get(self, "speed")


@pulumi.output_type
class GetWirelessDevicesEthernetStatusesItemPortPoeResult(dict):
    def __init__(__self__, *,
                 standard: _builtins.str):
        """
        :param _builtins.str standard: The PoE Standard for the port. Can be '802.3at', '802.3af', '802.3bt', or null
        """
        pulumi.set(__self__, "standard", standard)

    @_builtins.property
    @pulumi.getter
    def standard(self) -> _builtins.str:
        """
        The PoE Standard for the port. Can be '802.3at', '802.3af', '802.3bt', or null
        """
        return pulumi.get(self, "standard")


@pulumi.output_type
class GetWirelessDevicesEthernetStatusesItemPowerResult(dict):
    def __init__(__self__, *,
                 ac: 'outputs.GetWirelessDevicesEthernetStatusesItemPowerAcResult',
                 mode: _builtins.str,
                 poe: 'outputs.GetWirelessDevicesEthernetStatusesItemPowerPoeResult'):
        """
        :param 'GetWirelessDevicesEthernetStatusesItemPowerAcArgs' ac: AC power details object
        :param _builtins.str mode: The PoE power mode for the AP. Can be 'full' or 'low'
        :param 'GetWirelessDevicesEthernetStatusesItemPowerPoeArgs' poe: PoE power details object
        """
        pulumi.set(__self__, "ac", ac)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "poe", poe)

    @_builtins.property
    @pulumi.getter
    def ac(self) -> 'outputs.GetWirelessDevicesEthernetStatusesItemPowerAcResult':
        """
        AC power details object
        """
        return pulumi.get(self, "ac")

    @_builtins.property
    @pulumi.getter
    def mode(self) -> _builtins.str:
        """
        The PoE power mode for the AP. Can be 'full' or 'low'
        """
        return pulumi.get(self, "mode")

    @_builtins.property
    @pulumi.getter
    def poe(self) -> 'outputs.GetWirelessDevicesEthernetStatusesItemPowerPoeResult':
        """
        PoE power details object
        """
        return pulumi.get(self, "poe")


@pulumi.output_type
class GetWirelessDevicesEthernetStatusesItemPowerAcResult(dict):
    def __init__(__self__, *,
                 is_connected: _builtins.bool):
        """
        :param _builtins.bool is_connected: AC power connected
        """
        pulumi.set(__self__, "is_connected", is_connected)

    @_builtins.property
    @pulumi.getter(name="isConnected")
    def is_connected(self) -> _builtins.bool:
        """
        AC power connected
        """
        return pulumi.get(self, "is_connected")


@pulumi.output_type
class GetWirelessDevicesEthernetStatusesItemPowerPoeResult(dict):
    def __init__(__self__, *,
                 is_connected: _builtins.bool):
        """
        :param _builtins.bool is_connected: PoE power connected
        """
        pulumi.set(__self__, "is_connected", is_connected)

    @_builtins.property
    @pulumi.getter(name="isConnected")
    def is_connected(self) -> _builtins.bool:
        """
        PoE power connected
        """
        return pulumi.get(self, "is_connected")


@pulumi.output_type
class GetWirelessDevicesPacketLossByClientItemResult(dict):
    def __init__(__self__, *,
                 client: 'outputs.GetWirelessDevicesPacketLossByClientItemClientResult',
                 downstream: 'outputs.GetWirelessDevicesPacketLossByClientItemDownstreamResult',
                 network: 'outputs.GetWirelessDevicesPacketLossByClientItemNetworkResult',
                 upstream: 'outputs.GetWirelessDevicesPacketLossByClientItemUpstreamResult'):
        """
        :param 'GetWirelessDevicesPacketLossByClientItemClientArgs' client: Client.
        :param 'GetWirelessDevicesPacketLossByClientItemDownstreamArgs' downstream: Packets sent from an AP to a client.
        :param 'GetWirelessDevicesPacketLossByClientItemNetworkArgs' network: Network.
        :param 'GetWirelessDevicesPacketLossByClientItemUpstreamArgs' upstream: Packets sent from a client to an AP.
        """
        pulumi.set(__self__, "client", client)
        pulumi.set(__self__, "downstream", downstream)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "upstream", upstream)

    @_builtins.property
    @pulumi.getter
    def client(self) -> 'outputs.GetWirelessDevicesPacketLossByClientItemClientResult':
        """
        Client.
        """
        return pulumi.get(self, "client")

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> 'outputs.GetWirelessDevicesPacketLossByClientItemDownstreamResult':
        """
        Packets sent from an AP to a client.
        """
        return pulumi.get(self, "downstream")

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetWirelessDevicesPacketLossByClientItemNetworkResult':
        """
        Network.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter
    def upstream(self) -> 'outputs.GetWirelessDevicesPacketLossByClientItemUpstreamResult':
        """
        Packets sent from a client to an AP.
        """
        return pulumi.get(self, "upstream")


@pulumi.output_type
class GetWirelessDevicesPacketLossByClientItemClientResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 mac: _builtins.str):
        """
        :param _builtins.str id: Client ID.
        :param _builtins.str mac: MAC address.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "mac", mac)

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

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


@pulumi.output_type
class GetWirelessDevicesPacketLossByClientItemDownstreamResult(dict):
    def __init__(__self__, *,
                 loss_percentage: _builtins.float,
                 lost: _builtins.int,
                 total: _builtins.int):
        """
        :param _builtins.float loss_percentage: Percentage of lost packets.
        :param _builtins.int lost: Total packets sent by an AP that did not reach the client.
        :param _builtins.int total: Total packets received by a client.
        """
        pulumi.set(__self__, "loss_percentage", loss_percentage)
        pulumi.set(__self__, "lost", lost)
        pulumi.set(__self__, "total", total)

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

    @_builtins.property
    @pulumi.getter
    def lost(self) -> _builtins.int:
        """
        Total packets sent by an AP that did not reach the client.
        """
        return pulumi.get(self, "lost")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total packets received by a client.
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetWirelessDevicesPacketLossByClientItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: Network ID.
        :param _builtins.str name: Name of the network.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetWirelessDevicesPacketLossByClientItemUpstreamResult(dict):
    def __init__(__self__, *,
                 loss_percentage: _builtins.float,
                 lost: _builtins.int,
                 total: _builtins.int):
        """
        :param _builtins.float loss_percentage: Percentage of lost packets.
        :param _builtins.int lost: Total packets sent by a client and did not reach the AP.
        :param _builtins.int total: Total packets sent by a client to an AP.
        """
        pulumi.set(__self__, "loss_percentage", loss_percentage)
        pulumi.set(__self__, "lost", lost)
        pulumi.set(__self__, "total", total)

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

    @_builtins.property
    @pulumi.getter
    def lost(self) -> _builtins.int:
        """
        Total packets sent by a client and did not reach the AP.
        """
        return pulumi.get(self, "lost")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total packets sent by a client to an AP.
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetWirelessDevicesPacketLossByDeviceItemResult(dict):
    def __init__(__self__, *,
                 device: 'outputs.GetWirelessDevicesPacketLossByDeviceItemDeviceResult',
                 downstream: 'outputs.GetWirelessDevicesPacketLossByDeviceItemDownstreamResult',
                 network: 'outputs.GetWirelessDevicesPacketLossByDeviceItemNetworkResult',
                 upstream: 'outputs.GetWirelessDevicesPacketLossByDeviceItemUpstreamResult'):
        """
        :param 'GetWirelessDevicesPacketLossByDeviceItemDeviceArgs' device: Device.
        :param 'GetWirelessDevicesPacketLossByDeviceItemDownstreamArgs' downstream: Packets sent from an AP to a client.
        :param 'GetWirelessDevicesPacketLossByDeviceItemNetworkArgs' network: Network.
        :param 'GetWirelessDevicesPacketLossByDeviceItemUpstreamArgs' upstream: Packets sent from a client to an AP.
        """
        pulumi.set(__self__, "device", device)
        pulumi.set(__self__, "downstream", downstream)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "upstream", upstream)

    @_builtins.property
    @pulumi.getter
    def device(self) -> 'outputs.GetWirelessDevicesPacketLossByDeviceItemDeviceResult':
        """
        Device.
        """
        return pulumi.get(self, "device")

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> 'outputs.GetWirelessDevicesPacketLossByDeviceItemDownstreamResult':
        """
        Packets sent from an AP to a client.
        """
        return pulumi.get(self, "downstream")

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetWirelessDevicesPacketLossByDeviceItemNetworkResult':
        """
        Network.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter
    def upstream(self) -> 'outputs.GetWirelessDevicesPacketLossByDeviceItemUpstreamResult':
        """
        Packets sent from a client to an AP.
        """
        return pulumi.get(self, "upstream")


@pulumi.output_type
class GetWirelessDevicesPacketLossByDeviceItemDeviceResult(dict):
    def __init__(__self__, *,
                 mac: _builtins.str,
                 name: _builtins.str,
                 serial: _builtins.str):
        """
        :param _builtins.str mac: MAC address
        :param _builtins.str name: Name
        :param _builtins.str serial: Serial Number
        """
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "serial", serial)

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

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

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


@pulumi.output_type
class GetWirelessDevicesPacketLossByDeviceItemDownstreamResult(dict):
    def __init__(__self__, *,
                 loss_percentage: _builtins.float,
                 lost: _builtins.int,
                 total: _builtins.int):
        """
        :param _builtins.float loss_percentage: Percentage of lost packets.
        :param _builtins.int lost: Total packets sent by an AP that did not reach the client.
        :param _builtins.int total: Total packets received by a client.
        """
        pulumi.set(__self__, "loss_percentage", loss_percentage)
        pulumi.set(__self__, "lost", lost)
        pulumi.set(__self__, "total", total)

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

    @_builtins.property
    @pulumi.getter
    def lost(self) -> _builtins.int:
        """
        Total packets sent by an AP that did not reach the client.
        """
        return pulumi.get(self, "lost")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total packets received by a client.
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetWirelessDevicesPacketLossByDeviceItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: Network ID.
        :param _builtins.str name: Name of the network.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetWirelessDevicesPacketLossByDeviceItemUpstreamResult(dict):
    def __init__(__self__, *,
                 loss_percentage: _builtins.float,
                 lost: _builtins.int,
                 total: _builtins.int):
        """
        :param _builtins.float loss_percentage: Percentage of lost packets.
        :param _builtins.int lost: Total packets sent by a client and did not reach the AP.
        :param _builtins.int total: Total packets sent by a client to an AP.
        """
        pulumi.set(__self__, "loss_percentage", loss_percentage)
        pulumi.set(__self__, "lost", lost)
        pulumi.set(__self__, "total", total)

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

    @_builtins.property
    @pulumi.getter
    def lost(self) -> _builtins.int:
        """
        Total packets sent by a client and did not reach the AP.
        """
        return pulumi.get(self, "lost")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total packets sent by a client to an AP.
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetWirelessDevicesPacketLossByNetworkItemResult(dict):
    def __init__(__self__, *,
                 downstream: 'outputs.GetWirelessDevicesPacketLossByNetworkItemDownstreamResult',
                 network: 'outputs.GetWirelessDevicesPacketLossByNetworkItemNetworkResult',
                 upstream: 'outputs.GetWirelessDevicesPacketLossByNetworkItemUpstreamResult'):
        """
        :param 'GetWirelessDevicesPacketLossByNetworkItemDownstreamArgs' downstream: Packets sent from an AP to a client.
        :param 'GetWirelessDevicesPacketLossByNetworkItemNetworkArgs' network: Network.
        :param 'GetWirelessDevicesPacketLossByNetworkItemUpstreamArgs' upstream: Packets sent from a client to an AP.
        """
        pulumi.set(__self__, "downstream", downstream)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "upstream", upstream)

    @_builtins.property
    @pulumi.getter
    def downstream(self) -> 'outputs.GetWirelessDevicesPacketLossByNetworkItemDownstreamResult':
        """
        Packets sent from an AP to a client.
        """
        return pulumi.get(self, "downstream")

    @_builtins.property
    @pulumi.getter
    def network(self) -> 'outputs.GetWirelessDevicesPacketLossByNetworkItemNetworkResult':
        """
        Network.
        """
        return pulumi.get(self, "network")

    @_builtins.property
    @pulumi.getter
    def upstream(self) -> 'outputs.GetWirelessDevicesPacketLossByNetworkItemUpstreamResult':
        """
        Packets sent from a client to an AP.
        """
        return pulumi.get(self, "upstream")


@pulumi.output_type
class GetWirelessDevicesPacketLossByNetworkItemDownstreamResult(dict):
    def __init__(__self__, *,
                 loss_percentage: _builtins.float,
                 lost: _builtins.int,
                 total: _builtins.int):
        """
        :param _builtins.float loss_percentage: Percentage of lost packets.
        :param _builtins.int lost: Total packets sent by an AP that did not reach the client.
        :param _builtins.int total: Total packets received by a client.
        """
        pulumi.set(__self__, "loss_percentage", loss_percentage)
        pulumi.set(__self__, "lost", lost)
        pulumi.set(__self__, "total", total)

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

    @_builtins.property
    @pulumi.getter
    def lost(self) -> _builtins.int:
        """
        Total packets sent by an AP that did not reach the client.
        """
        return pulumi.get(self, "lost")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total packets received by a client.
        """
        return pulumi.get(self, "total")


@pulumi.output_type
class GetWirelessDevicesPacketLossByNetworkItemNetworkResult(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str id: Network ID.
        :param _builtins.str name: Name of the network.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetWirelessDevicesPacketLossByNetworkItemUpstreamResult(dict):
    def __init__(__self__, *,
                 loss_percentage: _builtins.float,
                 lost: _builtins.int,
                 total: _builtins.int):
        """
        :param _builtins.float loss_percentage: Percentage of lost packets.
        :param _builtins.int lost: Total packets sent by a client and did not reach the AP.
        :param _builtins.int total: Total packets sent by a client to an AP.
        """
        pulumi.set(__self__, "loss_percentage", loss_percentage)
        pulumi.set(__self__, "lost", lost)
        pulumi.set(__self__, "total", total)

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

    @_builtins.property
    @pulumi.getter
    def lost(self) -> _builtins.int:
        """
        Total packets sent by a client and did not reach the AP.
        """
        return pulumi.get(self, "lost")

    @_builtins.property
    @pulumi.getter
    def total(self) -> _builtins.int:
        """
        Total packets sent by a client to an AP.
        """
        return pulumi.get(self, "total")


