zscaler-sdk-python 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

zscaler/__init__.py

@@ -29,7 +29,7 @@ __license__ = "MIT"
 __contributors__ = [
     "William Guilherme",
 ]
-__version__ = "1.2.0"
+__version__ = "1.2.2"
 
 
 from zscaler.oneapi_client import Client as ZscalerClient  # noqa

zscaler/helpers.py

@@ -53,6 +53,58 @@ def to_snake_case(string):
         "extranetDNSList": "extranet_dns_list",
         "primaryDNSServer": "primary_dns_server",
         "secondaryDNSServer": "secondary_dns_server",
+        
+        # ZCC Edge Case Attributes
+        "enableUDPTransportSelection": "enable_udp_transport_selection",
+        "interceptZIATrafficAllAdapters": "intercept_zia_traffic_all_adapters",
+        "enablePortBasedZPAFilter": "enable_port_based_zpa_filter",
+        "addAppBypassToVPNGateway": "add_app_bypass_to_vpn_gateway",
+        "showVPNTunNotification": "show_vpn_tun_notification",
+        "enableSetProxyOnVPNAdapters": "enable_set_proxy_on_vpn_adapters",
+        "disableDNSRouteExclusion": "disable_dns_route_exclusion",
+        "enableReactUI": "enable_react_ui",
+        "ziaGlobalDbUrlForDR": "zia_global_db_url_for_dr",
+        "useDefaultAdapterForDNS": "use_default_adapter_for_dns",
+        "enablePublicAPI": "enable_public_api",
+        "launchReactUIbyDefault": "launch_react_u_iby_default",
+        "addZDXServiceEntitlement": "add_zdx_service_entitlement",
+        "computeDeviceGroupsForZIA": "compute_device_groups_for_zia",
+        "computeDeviceGroupsForZPA": "compute_device_groups_for_zpa",
+        "computeDeviceGroupsForZAD": "compute_device_groups_for_zad",
+        "computeDeviceGroupsForZAD": "compute_device_groups_for_zad",
+        "deleteDHCPOption121RoutesVisibility": "delete_dhcp_option121_routes_visibility",
+        "enableOneIDAdminMigrationChanges": "enable_one_id_admin_migration_changes",
+        "purgeKerberosPreferredDCCacheVisibility": "purge_kerberos_preferred_dc_cache_visibility",
+        "slowRolloutZCC": "slow_rollout_zcc",
+        "supportMultiplePWLPostures": "support_multiple_pwl_postures",
+        "truncateLargeUDPDNSResponseVisibility": "truncate_large_udpdns_response_visibility",
+        "enforceSplitDNSVisibility": "enforce_split_dns_visibility",
+        "zccSyntheticIPRangeVisibility": "zcc_synthetic_ip_range_visibility",
+        "enableSetProxyOnVPNAdaptersVisibility": "enable_set_proxy_on_vpn_adapters_visibility",
+        "customMTUForZpaVisibility": "custom_mtu_for_zpa_visibility",
+        "flowLoggerZCCBlockedTrafficVisibility": "flow_logger_zcc_blocked_traffic_visibility",
+        "postureCrowdStrikeZTAScoreVisibilityForLinux": "posture_crowd_strike_zta_score_visibility_for_linux",
+        "flowLoggerVPNTunnelTypeVisibility": "flow_logger_vpn_tunnel_type_visibility",
+        "flowLoggerVPNTypeVisibility": "flow_logger_vpn_type_visibility",
+        "flowLoggerZPATypeVisibility": "flow_logger_zpa_type_visibility",
+        "useDefaultAdapterForDNSVisibility": "use_default_adapter_for_dns_visibility",
+        "useCustomDNS": "use_custom_dns",
+        "notificationForZPAReauthVisibility": "notification_for_zpa_reauth_visibility",
+        "crowdStrikeZTAScoreVisibility": "crowd_strike_zta_score_visibility",
+        "hideDTLSSupportSettings": "hide_dtls_support_settings",
+        "dynamicZPAServiceEdgeAssignmenttVisibility": "dynamic_zpa_service_edge_assignmentt_visibility",
+        "domainInclusionExclusionForDNSRequestVisibility": "domain_inclusion_exclusion_for_dns_request_visibility",
+        "overrideATCmdByPolicyVisibility": "override_at_cmd_by_policy_visibility",
+        "windowsAPCaptivePortalDetectionVisibility": "windows_ap_captive_portal_detection_visibility",
+        "windowsAPEnableFailOpenVisibility": "windows_ap_enable_fail_open_visibility",
+        "enableOneIDPhase2Changes": "enable_one_id_phase2_changes",
+        "linuxRPMBuildVisibility": "linux_rpm_build_visibility",
+        "crowdStrikeZTAOsScoreVisibility": "crowd_strike_zta_os_score_visibility",
+        "crowdStrikeZTASensorConfigScoreVisibility": "crowd_strike_zta_sensor_config_score_visibility",
+        "enableZCCFailCloseSettingsForSEMode": "enable_zcc_fail_close_settings_for_se_mode",
+        "defaultProtocolForZPA": "default_protocol_for_zpa",
+        "tunnelTwoForiOSDevices": "tunnel_two_fori_os_devices",
+        "prioritizeIPv4OverIpv6": "prioritize_ipv4_over_ipv6",
     }
 
     if string in FIELD_EXCEPTIONS:
@@ -114,6 +166,58 @@ def to_lower_camel_case(string):
         "extranet_dns_list": "extranetDNSList",
         "primary_dns_server": "primaryDNSServer",
         "secondary_dns_server": "secondaryDNSServer",
+        
+        # ZCC Edge Case Attributes
+        "enable_udp_transport_selection": "enableUDPTransportSelection",
+        "intercept_zia_traffic_all_adapters": "interceptZIATrafficAllAdapters",
+        "enable_port_based_zpa_filter": "enablePortBasedZPAFilter",
+        "add_app_bypass_to_vpn_gateway": "addAppBypassToVPNGateway",
+        "show_vpn_tun_notification": "showVPNTunNotification",
+        "enable_set_proxy_on_vpn_adapters": "enableSetProxyOnVPNAdapters",
+        "disable_dns_route_exclusion": "disableDNSRouteExclusion",
+        "enable_react_ui": "enableReactUI",
+        "zia_global_db_url_for_dr": "ziaGlobalDbUrlForDR",
+        "use_default_adapter_for_dns": "useDefaultAdapterForDNS",
+        "enable_public_api": "enablePublicAPI",
+        "launch_react_u_iby_default": "launchReactUIbyDefault",
+        "add_zdx_service_entitlement": "addZDXServiceEntitlement",
+        "compute_device_groups_for_zia": "computeDeviceGroupsForZIA",
+        "compute_device_groups_for_zpa": "computeDeviceGroupsForZPA",
+        "compute_device_groups_for_zad": "computeDeviceGroupsForZAD",
+        "delete_dhcp_option121_routes_visibility": "deleteDHCPOption121RoutesVisibility",
+        "enable_one_id_admin_migration_changes": "enableOneIDAdminMigrationChanges",
+        "purge_kerberos_preferred_dc_cache_visibility": "purgeKerberosPreferredDCCacheVisibility",
+        "slow_rollout_zcc": "slowRolloutZCC",
+        "support_multiple_pwl_postures": "supportMultiplePWLPostures",
+        "truncate_large_udpdns_response_visibility": "truncateLargeUDPDNSResponseVisibility",
+        "enforce_split_dns_visibility": "enforceSplitDNSVisibility",
+        "zcc_synthetic_ip_range_visibility": "zccSyntheticIPRangeVisibility",
+        "enable_set_proxy_on_vpn_adapters_visibility": "enableSetProxyOnVPNAdaptersVisibility",
+        "custom_mtu_for_zpa_visibility": "customMTUForZpaVisibility",
+        "flow_logger_zcc_blocked_traffic_visibility": "flowLoggerZCCBlockedTrafficVisibility",
+        "posture_crowd_strike_zta_score_visibility_for_linux": "postureCrowdStrikeZTAScoreVisibilityForLinux",
+        "flow_logger_vpn_tunnel_type_visibility": "flowLoggerVPNTunnelTypeVisibility",
+        "flow_logger_vpn_type_visibility": "flowLoggerVPNTypeVisibility",
+        "flow_logger_zpa_type_visibility": "flowLoggerZPATypeVisibility",
+        "use_default_adapter_for_dns_visibility": "useDefaultAdapterForDNSVisibility",
+        "use_custom_dns": "useCustomDNS",
+        "notification_for_zpa_reauth_visibility": "notificationForZPAReauthVisibility",
+        "crowd_strike_zta_score_visibility": "crowdStrikeZTAScoreVisibility",
+        "hide_dtls_support_settings": "hideDTLSSupportSettings",
+        "dynamic_zpa_service_edge_assignmentt_visibility": "dynamicZPAServiceEdgeAssignmenttVisibility",
+        "domain_inclusion_exclusion_for_dns_request_visibility": "domainInclusionExclusionForDNSRequestVisibility",
+        "override_at_cmd_by_policy_visibility": "overrideATCmdByPolicyVisibility",
+        "windows_ap_captive_portal_detection_visibility": "windowsAPCaptivePortalDetectionVisibility",
+        "windows_ap_enable_fail_open_visibility": "windowsAPEnableFailOpenVisibility",
+        "enable_one_id_phase2_changes": "enableOneIDPhase2Changes",
+        "linux_rpm_build_visibility": "linuxRPMBuildVisibility",
+        "crowd_strike_zta_os_score_visibility": "crowdStrikeZTAOsScoreVisibility",
+        "crowd_strike_zta_sensor_config_score_visibility": "crowdStrikeZTASensorConfigScoreVisibility",
+        "enable_zcc_fail_close_settings_for_se_mode": "enableZCCFailCloseSettingsForSEMode",
+        "default_protocol_for_zpa": "defaultProtocolForZPA",
+        "tunnelTwoForiOSDevices": "tunnel_two_fori_os_devices",
+        "prioritize_ipv4_over_ipv6": "prioritizeIPv4OverIpv6",
+        
     }
 
     if string in FIELD_EXCEPTIONS:

zscaler/logger.py

@@ -8,117 +8,60 @@ from http.client import HTTPConnection
 LOG_FORMAT = "%(asctime)s - %(name)s - %(module)s - %(levelname)s - %(message)s"
 
 
-# def setup_logging(logger_name="zscaler-sdk-python", enabled=None, verbose=None):
-#     """
-#     Set up logging with specified level and logger name.
-#     Log level is controlled via ZSCALER_SDK_VERBOSE environment variable.
-#     Logging can be enabled/disabled via ZSCALER_SDK_LOG environment variable.
-
-#     Parameters:
-#     - logger_name (str, optional): Logger name. Defaults to "zscaler-sdk-python".
-#     - enabled (bool, optional): Enable logging. Defaults to None, which uses the environment variable.
-#     - verbose (bool, optional): Set verbose logging. Defaults to None, which uses the environment variable.
-#     """
-#     if enabled is None:
-#         enabled = os.getenv("ZSCALER_SDK_LOG", "false").lower() == "true"
-
-#     # if not enabled:
-#     #     # If logging is not enabled, set up a null handler
-#     #     logging.disable(logging.INFO)
-#     #     return
-
-#     if not enabled:
-#         # Do not globally disable logging
-#         # Just keep the SDK logger silent
-#         sdk_logger = logging.getLogger(logger_name)
-#         sdk_logger.addHandler(logging.NullHandler())
-#         return
-
-#     if verbose is None:
-#         verbose = os.getenv("ZSCALER_SDK_VERBOSE", "false").lower() == "true"
-
-#     log_level = logging.DEBUG if verbose else logging.INFO
-#     HTTPConnection.debuglevel = 0
-#     # Create a logger with the specified name
-#     logger = logging.getLogger(logger_name)
-#     default_logger = logging.getLogger()
-
-#     # If the logger already has handlers, remove them to avoid duplicate logging
-#     for handler in logger.handlers[:]:
-#         logger.removeHandler(handler)
-
-#     for handler in default_logger.handlers[:]:
-#         default_logger.removeHandler(handler)
-
-#     # Set log level
-#     logger.setLevel(log_level)
-#     default_logger.setLevel(log_level)
-#     logging.basicConfig(level=log_level)
-#     # Create a stream handler with the specified level and formatter
-#     stream_handler = logging.StreamHandler()
-#     stream_handler.setLevel(log_level)
-#     log_formatter = logging.Formatter(LOG_FORMAT)
-#     stream_handler.setFormatter(log_formatter)
-
-#     # Add the handler to the logger
-#     logger.addHandler(stream_handler)
-
-
-#     # Option: Add FileHandler if you want logs to be written to a file.
-#     if os.getenv("LOG_TO_FILE", "false").lower() == "true":
-#         file_handler = logging.FileHandler(os.getenv("LOG_FILE_PATH", "sdk.log"))
-#         file_handler.setLevel(log_level)
-#         file_handler.setFormatter(log_formatter)
-#         logger.addHandler(file_handler)
 def setup_logging(logger_name="zscaler-sdk-python", enabled=None, verbose=None):
     """
-    Set up logging for the Zscaler SDK.
-
-    Logging behavior can be controlled via environment variables or config:
-
-    Environment Variables:
-        ZSCALER_SDK_LOG (true/false): Enable or disable SDK logging.
-        ZSCALER_SDK_VERBOSE (true/false): Enable verbose (DEBUG) logging.
-        LOG_TO_FILE (true/false): Enable file-based logging.
-        LOG_FILE_PATH: File path for logs (default: sdk.log)
+    Set up logging with specified level and logger name.
+    Log level is controlled via ZSCALER_SDK_VERBOSE environment variable.
+    Logging can be enabled/disabled via ZSCALER_SDK_LOG environment variable.
 
     Parameters:
-        logger_name (str): Name of the logger. Defaults to "zscaler-sdk-python".
-        enabled (bool): Enable logging. If None, reads from env.
-        verbose (bool): Enable DEBUG-level logging. If None, reads from env.
+    - logger_name (str, optional): Logger name. Defaults to "zscaler-sdk-python".
+    - enabled (bool, optional): Enable logging. Defaults to None, which uses the environment variable.
+    - verbose (bool, optional): Set verbose logging. Defaults to None, which uses the environment variable.
     """
     if enabled is None:
         enabled = os.getenv("ZSCALER_SDK_LOG", "false").lower() == "true"
 
     if not enabled:
-        # Do NOT disable global logging.
-        # Just suppress SDK logs quietly with a NullHandler.
-        logging.getLogger(logger_name).addHandler(logging.NullHandler())
+        # If logging is not enabled, set up a null handler
+        logging.disable(logging.INFO)
         return
 
     if verbose is None:
         verbose = os.getenv("ZSCALER_SDK_VERBOSE", "false").lower() == "true"
 
     log_level = logging.DEBUG if verbose else logging.INFO
-    HTTPConnection.debuglevel = 0  # Optional: Enable HTTP debug logging
-
-    # SDK logger (isolated)
+    HTTPConnection.debuglevel = 0
+    # Create a logger with the specified name
     logger = logging.getLogger(logger_name)
+    default_logger = logging.getLogger()
+
+    # If the logger already has handlers, remove them to avoid duplicate logging
+    for handler in logger.handlers[:]:
+        logger.removeHandler(handler)
+
+    for handler in default_logger.handlers[:]:
+        default_logger.removeHandler(handler)
+
+    # Set log level
     logger.setLevel(log_level)
+    default_logger.setLevel(log_level)
+    logging.basicConfig(level=log_level)
+    # Create a stream handler with the specified level and formatter
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(log_level)
+    log_formatter = logging.Formatter(LOG_FORMAT)
+    stream_handler.setFormatter(log_formatter)
 
-    # Clean up any duplicate handlers
-    if not logger.handlers:
-        stream_handler = logging.StreamHandler()
-        stream_handler.setLevel(log_level)
-        stream_handler.setFormatter(logging.Formatter(LOG_FORMAT))
-        logger.addHandler(stream_handler)
+    # Add the handler to the logger
+    logger.addHandler(stream_handler)
 
-        # Optional file logging
-        if os.getenv("LOG_TO_FILE", "false").lower() == "true":
-            file_handler = logging.FileHandler(os.getenv("LOG_FILE_PATH", "sdk.log"))
-            file_handler.setLevel(log_level)
-            file_handler.setFormatter(logging.Formatter(LOG_FORMAT))
-            logger.addHandler(file_handler)
+    # Option: Add FileHandler if you want logs to be written to a file.
+    if os.getenv("LOG_TO_FILE", "false").lower() == "true":
+        file_handler = logging.FileHandler(os.getenv("LOG_FILE_PATH", "sdk.log"))
+        file_handler.setLevel(log_level)
+        file_handler.setFormatter(log_formatter)
+        logger.addHandler(file_handler)
 
 
 def dump_request(logger, url: str, method: str, json, params, headers, request_uuid: str, body=True):
@@ -178,4 +121,4 @@ def dump_response(
     if response_body and response_body != "" and response_body != "null":
         log_lines.append(f"\n{response_body}")
     log_lines.append("-" * 68)
-    logger.info("\n".join(log_lines))
+    logger.info("\n".join(log_lines))

zscaler/oneapi_object.py

@@ -13,27 +13,13 @@ class ZscalerObject:
     def __repr__(self):
         return str(vars(self))
 
-    # def as_dict(self):
-    #     """
-    #     Returns dictionary object of ZscalerObject with keys in snake_case for user-facing output.
-    #     """
-    #     result = {}
-    #     for key, val in self.request_format().items():
-    #         if val is None:
-    #             continue
-    #         if isinstance(val, list):
-    #             formatted_list = []
-    #             for item in val:
-    #                 if isinstance(item, ZscalerObject):
-    #                     formatted_list.append(item.as_dict())  # Recursive call for nested objects
-    #                 else:
-    #                     formatted_list.append(item)
-    #             result[to_snake_case(key)] = formatted_list  # Convert key to snake_case
-    #         elif not isinstance(val, ZscalerObject):
-    #             result[to_snake_case(key)] = val  # Convert key to snake_case for simple types
-    #         else:
-    #             result[to_snake_case(key)] = val.as_dict()  # Convert nested objects
-    #     return result
+    def __getitem__(self, key):
+        if hasattr(self, key):
+            return getattr(self, key)
+        raise KeyError(f"{key} not found in {self.__class__.__name__}")
+
+    def __contains__(self, key):
+        return hasattr(self, key)
 
     def as_dict(self):
         result = {}

zscaler/oneapi_response.py

@@ -26,8 +26,6 @@ class ZscalerAPIResponse:
         res_details=None,
         response_body="",
         data_type=None,
-        # max_items=None,
-        # max_pages=None,
         all_entries=False,
         sort_order=None,
         sort_by=None,
@@ -80,19 +78,7 @@ class ZscalerAPIResponse:
 
         if res_details:
             content_type = res_details.headers.get("Content-Type", "").lower()
-            #     if "application/json" in content_type:
-            #         self._build_json_response(response_body)
-            #     else:
-            #         # Attempt JSON parse, else store as text
-            #         try:
-            #             self._build_json_response(response_body)
-            #         except json.JSONDecodeError:
-            #             self._body = response_body
-            # else:
-            #     try:
-            #         self._build_json_response(response_body)
-            #     except json.JSONDecodeError:
-            #         self._body = response_body
+
             if "application/json" in content_type:
                 try:
                     self._build_json_response(response_body)
@@ -180,13 +166,21 @@ class ZscalerAPIResponse:
 
         self._items_fetched += len(self._list)
         self._pages_fetched += 1
-
+    
     def get_results(self):
         """
         Returns the current page of results.
         The initial call to the API returns only one page.
         """
         logger.debug("Fetching current page results")
+
+        if self._service_type.upper() == "ZCC" and self._type:
+            try:
+                return [self._type(item) for item in self._list if isinstance(item, dict)]
+            except Exception as wrap_error:
+                logger.warning(f"Failed to wrap results with {self._type}: {wrap_error}")
+                return self._list
+
         return self._list
 
     def has_next(self):
@@ -199,35 +193,28 @@ class ZscalerAPIResponse:
         return self._has_next()
 
     def next(self):
-        """
-        Fetch the next page of results if available.
+        if not self.has_next():
+            raise StopIteration("No more pages available.")
 
-        Returns:
-            tuple: (list of items, error)
+        results, error = self._fetch_next_page()
+        if error:
+            return None, self, error
+        if not results:
+            return None, self, None
+
+        if self._type:
+            try:
+                results = [self._type(item) for item in results if isinstance(item, dict)]
+            except Exception as wrap_error:
+                logger.warning(f"Failed to wrap pagination results with {self._type}: {wrap_error}")
+
+        return results, self, None
 
-        If there's an error fetching the next page, returns (None, error).
-        If no more pages exist, returns (None, None).
-        """
-        if not self.has_next():
-            logger.debug("No further pages to retrieve.")
-            return (None, None)
-
-        next_page_results = self._fetch_next_page()
-        if next_page_results is None:
-            # An error occurred, already logged
-            return (None, ValueError("Error fetching next page."))
-        if not next_page_results:
-            # Empty result means no more data
-            return (None, None)
-        return (next_page_results, None)
 
     def _fetch_next_page(self):
-        """
-        Internal method that fetches and returns the next page of results.
-        """
         if not self._has_next():
             logger.debug("No more pages to fetch")
-            return []
+            return [], None
 
         if self._service_type == "ZDX":
             self._params["offset"] = self._next_offset
@@ -248,20 +235,12 @@ class ZscalerAPIResponse:
 
         if error:
             logger.error(f"Error fetching the next page: {error}")
-            return None
+            return None, error
 
-        # Rebuild the response body for the next page
         self._build_json_response(response_body)
-        return self._list
+        return self._list, None
 
     def _has_next(self):
-        # Check max_items or max_pages constraints
-        # if self._max_items is not None and self._items_fetched >= self._max_items:
-        #     logger.debug("Reached max items limit: %d", self._max_items)
-        #     return False
-        # if self._max_pages is not None and self._pages_fetched >= self._max_pages:
-        #     logger.debug("Reached max pages limit: %d", self._max_pages)
-        #     return False
 
         if self._service_type == "ZPA":
             # More pages if current page < total_pages

zscaler/request_executor.py

@@ -14,8 +14,9 @@ from zscaler.zdx.legacy import LegacyZDXClientHelper
 from zscaler.zpa.legacy import LegacyZPAClientHelper
 from zscaler.zia.legacy import LegacyZIAClientHelper
 from zscaler.zwa.legacy import LegacyZWAClientHelper
+# from zscaler.logger import setup_logging  # ✅ Import here
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('zscaler-sdk-python')
 
 
 class RequestExecutor:
@@ -75,6 +76,13 @@ class RequestExecutor:
         self._config = config
         self._cache = cache
 
+        # ✅ Setup logging based on config flags
+        # log_config = self._config["client"].get("logging", {})
+        # setup_logging(
+        #     enabled=log_config.get("enabled", False),
+        #     verbose=log_config.get("verbose", False),
+        # )
+
         # Retrieve cloud, service, and customer ID (optional)
         self.cloud = self._config["client"].get("cloud", "production").lower()
         self.sandbox_cloud = self._config["client"].get("sandboxCloud", "").lower()
@@ -462,7 +470,7 @@ class RequestExecutor:
         req_timeout = self._request_timeout
 
         if req_timeout > 0 and (current_req_start_time - request_start_time) > req_timeout:
-            logger.error("Request Timeout exceeded.")
+            logger.warning("Request Timeout exceeded.")
             return None, None, None, Exception("Request Timeout exceeded.")
 
         response, error = self._http_client.send_request(request)

zscaler/utils.py

@@ -26,7 +26,7 @@ import time
 from typing import Dict, Optional
 from urllib.parse import urlencode
 from datetime import datetime as dt
-
+from functools import wraps
 import pytz
 from box import Box, BoxList
 from dateutil import parser
@@ -783,6 +783,52 @@ def format_url(base_string):
     """
     return "".join([line.strip() for line in base_string.splitlines()])
 
+def zcc_param_mapper(func):
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        query_params = kwargs.get("query_params", {}) or {}
+        mapped_params = {}
+
+        # Normalize and map os_types
+        if "os_types" in query_params:
+            os_raw = query_params["os_types"]
+            if isinstance(os_raw, str):
+                os_raw = [os_raw]  # ✅ support single string value
+
+            mapped = [
+                str(zcc_param_map["os"].get(os_type.lower()))
+                for os_type in os_raw
+                if zcc_param_map["os"].get(os_type.lower())
+            ]
+            if not mapped:
+                raise ValueError("Invalid `os_types` provided.")
+            mapped_params["osTypes"] = ",".join(mapped)
+
+        # Normalize and map registration_types
+        if "registration_types" in query_params:
+            reg_raw = query_params["registration_types"]
+            if isinstance(reg_raw, str):
+                reg_raw = [reg_raw]
+
+            mapped = [
+                str(zcc_param_map["reg_type"].get(rt.lower()))
+                for rt in reg_raw
+                if zcc_param_map["reg_type"].get(rt.lower())
+            ]
+            if not mapped:
+                raise ValueError("Invalid `registration_types` provided.")
+            mapped_params["registrationTypes"] = ",".join(mapped)
+
+        # Drop user-friendly keys
+        query_params.pop("os_types", None)
+        query_params.pop("registration_types", None)
+
+        # Merge in mapped numeric params
+        query_params.update(mapped_params)
+        kwargs["query_params"] = query_params
+
+        return func(self, *args, **kwargs)
+    return wrapper
 
 # Maps ZCC numeric os_type and registration_type arguments to a human-readable string
 zcc_param_map = {

zscaler/zcc/admin_user.py

@@ -17,7 +17,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 from zscaler.api_client import APIClient
 from zscaler.request_executor import RequestExecutor
 from zscaler.utils import format_url
-from zscaler.zcc.models.admin_user import AdminUser
+from zscaler.zcc.models.admin_user import AdminUser, AdminUserSyncInfo
 from zscaler.zcc.models.admin_roles import AdminRoles
 
 
@@ -92,9 +92,11 @@ class AdminUserAPI(APIClient):
         Examples:
             Prints all admins in the Client Connector Portal to the console:
 
-            >>> for admin in zcc.admin_user.list_admin_users():
-            ...    print(admin)
-
+            >>> sync_info, _, error = client.zcc.admin_user.get_admin_user_sync_info()
+            >>> if error:
+            ...     print(f"Error: {error}")
+            ...     return
+            ... print(sync_info.as_dict())
         """
         http_method = "get".upper()
         api_url = format_url(
@@ -108,20 +110,19 @@ class AdminUserAPI(APIClient):
         headers = {}
 
         request, error = self._request_executor.create_request(http_method, api_url, body, headers)
-
         if error:
-            return None
+            return None, None, error
 
         response, error = self._request_executor.execute(request)
         if error:
-            return None
+            return None, response, error
 
         try:
-            result = self.form_response_body(response.get_body())
+            result = AdminUserSyncInfo(self.form_response_body(response.get_body()))
         except Exception as error:
-            return None
+            return None, response, error
 
-        return result
+        return result, response, None
 
     def list_admin_roles(self, query_params=None) -> tuple:
         """
@@ -152,7 +153,6 @@ class AdminUserAPI(APIClient):
 
         query_params = query_params or {}
 
-        # Prepare request body and headers
         body = {}
         headers = {}
 
@@ -198,7 +198,6 @@ class AdminUserAPI(APIClient):
         """
         )
 
-        # Prepare request body and headers
         body = {}
         headers = {}
 
@@ -244,7 +243,6 @@ class AdminUserAPI(APIClient):
         """
         )
 
-        # Prepare request body and headers
         body = {}
         headers = {}