wxcli 1.2.0__py3-none-any.whl

wxcli/commands/video_mesh.py

@@ -0,0 +1,1090 @@
+import json
+import typer
+from wxcli.auth import get_api
+from wxcli.errors import WebexError, handle_rest_error
+from wxcli.output import print_table, print_json
+from wxcli.config import get_org_id
+
+
+app = typer.Typer(help="Manage Webex Calling video-mesh.")
+
+
+@app.command("list")
+def cmd_list(
+    from_param: str = typer.Option(..., "--from", help="The starting date and time of the requested data in any [ISO"),
+    to: str = typer.Option(..., "--to", help="The ending date and time of the requested data in any [ISO 8"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Clusters Availability."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/clusters/availability"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("show")
+def show(
+    cluster_id: str = typer.Argument(help="clusterId"),
+    from_param: str = typer.Option(..., "--from", help="The starting date and time of the requested data in any [ISO"),
+    to: str = typer.Option(..., "--to", help="The ending date and time of the requested data in any [ISO 8"),
+    output: str = typer.Option("json", "--output", "-o", help="Output format: table|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Cluster Availability."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/clusters/availability/{cluster_id}"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    else:
+        if isinstance(result, dict):
+            print_table([result], columns=[("Key", ""), ("Value", "")], limit=0)
+        elif isinstance(result, list):
+            print_table(result, columns=[("ID", "id"), ("Name", "name")], limit=0)
+        else:
+            print_json(result)
+
+
+
+@app.command("list-availability")
+def list_availability(
+    from_param: str = typer.Option(..., "--from", help="The starting date and time of the requested data in any [ISO"),
+    to: str = typer.Option(..., "--to", help="The ending date and time of the requested data in any [ISO 8"),
+    cluster_id: str = typer.Option(..., "--cluster-id", help="The unique Video Mesh cluster ID."),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Node Availability."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/nodes/availability"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if cluster_id is not None:
+        params["clusterId"] = cluster_id
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("show-availability")
+def show_availability(
+    node_id: str = typer.Argument(help="nodeId"),
+    from_param: str = typer.Option(..., "--from", help="The starting date and time of the requested data in any [ISO"),
+    to: str = typer.Option(..., "--to", help="The ending date and time of the requested data in any [ISO 8"),
+    output: str = typer.Option("json", "--output", "-o", help="Output format: table|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Node Availability."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/nodes/availability/{node_id}"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    else:
+        if isinstance(result, dict):
+            print_table([result], columns=[("Key", ""), ("Value", "")], limit=0)
+        elif isinstance(result, list):
+            print_table(result, columns=[("ID", "id"), ("Name", "name")], limit=0)
+        else:
+            print_json(result)
+
+
+
+@app.command("list-media-health-monitor-test")
+def list_media_health_monitor_test(
+    trigger_type: str = typer.Option(..., "--trigger-type", help="Choices: OnDemand, Periodic, All"),
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Media Health Monitoring Tool Test results V2."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testResults/mediaHealthMonitorTest"
+    params = {}
+    if trigger_type is not None:
+        params["triggerType"] = trigger_type
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-clusters-media-health-monitor-test")
+def list_clusters_media_health_monitor_test(
+    cluster_id: str = typer.Option(..., "--cluster-id", help="Unique ID of the Video Mesh cluster."),
+    trigger_type: str = typer.Option(..., "--trigger-type", help="Choices: OnDemand, Periodic, All"),
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Media Health Monitoring Tool Test results for clusters V2."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testResults/mediaHealthMonitorTest/clusters"
+    params = {}
+    if cluster_id is not None:
+        params["clusterId"] = cluster_id
+    if trigger_type is not None:
+        params["triggerType"] = trigger_type
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-nodes-media-health-monitor-test")
+def list_nodes_media_health_monitor_test(
+    node_id: str = typer.Option(..., "--node-id", help="Unique ID of the Video Mesh node."),
+    trigger_type: str = typer.Option(..., "--trigger-type", help="Choices: OnDemand, Periodic, All"),
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Media Health Monitoring Tool Test results for node V2."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testResults/mediaHealthMonitorTest/nodes"
+    params = {}
+    if node_id is not None:
+        params["nodeId"] = node_id
+    if trigger_type is not None:
+        params["triggerType"] = trigger_type
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-cloud-overflow")
+def list_cloud_overflow(
+    from_param: str = typer.Option(..., "--from", help="The starting date and time of the requested data in any [ISO"),
+    to: str = typer.Option(..., "--to", help="The ending date and time of the requested data in any [ISO 8"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Overflow to Cloud details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/cloudOverflow"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-call-redirects-video-mesh")
+def list_call_redirects_video_mesh(
+    from_param: str = typer.Option(..., "--from", help="The starting date and time of the requested data in any [ISO"),
+    to: str = typer.Option(..., "--to", help="The ending date and time of the requested data in any [ISO 8"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Cluster Redirect details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/callRedirects"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-call-redirects-clusters")
+def list_call_redirects_clusters(
+    from_param: str = typer.Option(..., "--from", help="The starting date and time of the requested data in any [ISO"),
+    to: str = typer.Option(..., "--to", help="The ending date and time of the requested data in any [ISO 8"),
+    cluster_id: str = typer.Option(..., "--cluster-id", help="The unique Video Mesh Cluster ID."),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Cluster Redirect details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/clusters/callRedirects"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if cluster_id is not None:
+        params["clusterId"] = cluster_id
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-utilization-video-mesh")
+def list_utilization_video_mesh(
+    from_param: str = typer.Option(..., "--from", help="The starting date and time of the requested data in any [ISO"),
+    to: str = typer.Option(..., "--to", help="The ending date and time of the requested data in any [ISO 8"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Clusters Utilization."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/utilization"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-utilization-clusters")
+def list_utilization_clusters(
+    from_param: str = typer.Option(..., "--from", help="The starting date and time of the requested data in any [ISO"),
+    to: str = typer.Option(..., "--to", help="The ending date and time of the requested data in any [ISO 8"),
+    cluster_id: str = typer.Option(..., "--cluster-id", help="The unique Video Mesh Cluster ID."),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Cluster Utilization details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/clusters/utilization"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if cluster_id is not None:
+        params["clusterId"] = cluster_id
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-reachability-test")
+def list_reachability_test(
+    trigger_type: str = typer.Option(..., "--trigger-type", help="Choices: OnDemand, Periodic, All"),
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Reachability Test results V2."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testResults/reachabilityTest"
+    params = {}
+    if trigger_type is not None:
+        params["triggerType"] = trigger_type
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-clusters-reachability-test")
+def list_clusters_reachability_test(
+    cluster_id: str = typer.Option(..., "--cluster-id", help="Unique ID of the Video Mesh cluster."),
+    trigger_type: str = typer.Option(..., "--trigger-type", help="Choices: OnDemand, Periodic, All"),
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Reachability Test results for cluster V2."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testResults/reachabilityTest/clusters"
+    params = {}
+    if cluster_id is not None:
+        params["clusterId"] = cluster_id
+    if trigger_type is not None:
+        params["triggerType"] = trigger_type
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-nodes-reachability-test")
+def list_nodes_reachability_test(
+    node_id: str = typer.Option(..., "--node-id", help="Unique ID of the Video Mesh node."),
+    trigger_type: str = typer.Option(..., "--trigger-type", help="Choices: OnDemand, Periodic, All"),
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Reachability Test results for node V2."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testResults/reachabilityTest/nodes"
+    params = {}
+    if node_id is not None:
+        params["nodeId"] = node_id
+    if trigger_type is not None:
+        params["triggerType"] = trigger_type
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-clusters-video-mesh")
+def list_clusters_video_mesh(
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Cluster Details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/clusters"
+    params = {}
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("show-clusters")
+def show_clusters(
+    cluster_id: str = typer.Argument(help="clusterId"),
+    output: str = typer.Option("json", "--output", "-o", help="Output format: table|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Cluster Details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/clusters/{cluster_id}"
+    try:
+        result = api.session.rest_get(url)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    else:
+        if isinstance(result, dict):
+            print_table([result], columns=[("Key", ""), ("Value", "")], limit=0)
+        elif isinstance(result, list):
+            print_table(result, columns=[("ID", "id"), ("Name", "name")], limit=0)
+        else:
+            print_json(result)
+
+
+
+@app.command("create")
+def create(
+    cluster_id: str = typer.Argument(help="clusterId"),
+    type_param: str = typer.Option(None, "--type", help="Choices: ReachabilityTest, NetworkTest, MediaHealthMonitorTest"),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    output: str = typer.Option("id", "--output", "-o", help="Output format: id|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Trigger on-demand test for cluster\n\nExample --json-body:\n  '{"type":"ReachabilityTest","nodes":["..."]}'."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/triggerTest/clusters/{cluster_id}"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if type_param is not None:
+            body["type"] = type_param
+    try:
+        result = api.session.rest_post(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    elif isinstance(result, dict) and "id" in result:
+        typer.echo(f"Created: {result['id']}")
+    elif not result or result == {}:
+        typer.echo("Created.")
+    else:
+        print_json(result)
+
+
+
+@app.command("create-nodes")
+def create_nodes(
+    node_id: str = typer.Argument(help="nodeId"),
+    type_param: str = typer.Option(None, "--type", help="Choices: ReachabilityTest, NetworkTest, MediaHealthMonitorTest"),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    output: str = typer.Option("id", "--output", "-o", help="Output format: id|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Trigger on-demand test for node."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/triggerTest/nodes/{node_id}"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if type_param is not None:
+            body["type"] = type_param
+    try:
+        result = api.session.rest_post(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    elif isinstance(result, dict) and "id" in result:
+        typer.echo(f"Created: {result['id']}")
+    elif not result or result == {}:
+        typer.echo("Created.")
+    else:
+        print_json(result)
+
+
+
+@app.command("list-test-status")
+def list_test_status(
+    command_id: str = typer.Option(..., "--command-id", help="The unique command ID generated from Trigger on-demand test"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Triggered test status."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testStatus"
+    params = {}
+    if command_id is not None:
+        params["commandId"] = command_id
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("nodes", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-test-results")
+def list_test_results(
+    command_id: str = typer.Option(..., "--command-id", help="The unique command ID generated from Trigger on-demand test"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Triggered test results."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testResults"
+    params = {}
+    if command_id is not None:
+        params["commandId"] = command_id
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("results", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-network-test")
+def list_network_test(
+    trigger_type: str = typer.Option(..., "--trigger-type", help="Choices: OnDemand, Periodic, All"),
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Network Test results."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testResults/networkTest"
+    params = {}
+    if trigger_type is not None:
+        params["triggerType"] = trigger_type
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-clusters-network-test")
+def list_clusters_network_test(
+    cluster_id: str = typer.Option(..., "--cluster-id", help="Unique ID of the Video Mesh cluster."),
+    trigger_type: str = typer.Option(..., "--trigger-type", help="Choices: OnDemand, Periodic, All"),
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Network Test results for cluster."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testResults/networkTest/clusters"
+    params = {}
+    if cluster_id is not None:
+        params["clusterId"] = cluster_id
+    if trigger_type is not None:
+        params["triggerType"] = trigger_type
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-nodes-network-test")
+def list_nodes_network_test(
+    node_id: str = typer.Option(..., "--node-id", help="Unique ID of the Video Mesh node."),
+    trigger_type: str = typer.Option(..., "--trigger-type", help="Choices: OnDemand, Periodic, All"),
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Network Test results for node."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/testResults/networkTest/nodes"
+    params = {}
+    if node_id is not None:
+        params["nodeId"] = node_id
+    if trigger_type is not None:
+        params["triggerType"] = trigger_type
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-client-type-distribution")
+def list_client_type_distribution(
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    device_type: str = typer.Option(..., "--device-type", help="Device type(s).  - Possible values:  `webexDevices` `webexAp"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Cluster Client Type Distribution details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/clientTypeDistribution"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if device_type is not None:
+        params["deviceType"] = device_type
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-clusters-client-type-distribution")
+def list_clusters_client_type_distribution(
+    cluster_id: str = typer.Option(..., "--cluster-id", help="Unique ID of the Video Mesh cluster."),
+    from_param: str = typer.Option(..., "--from", help="The start date and time of the requested data in any [ISO 86"),
+    to: str = typer.Option(..., "--to", help="The end date and time of the requested data in any [ISO 8601"),
+    device_type: str = typer.Option(..., "--device-type", help="Device type(s).  - Possible values:     `webexDevices` `webe"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Cluster Client Type Distribution details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/clientTypeDistribution/clusters"
+    params = {}
+    if cluster_id is not None:
+        params["clusterId"] = cluster_id
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if device_type is not None:
+        params["deviceType"] = device_type
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("list-event-thresholds")
+def list_event_thresholds(
+    event_name: str = typer.Option(None, "--event-name", help="Choices: clusterCallsRedirected, orgCallsOverflowed"),
+    cluster_id: str = typer.Option(None, "--cluster-id", help="Unique ID of the Video Mesh Cluster."),
+    event_scope: str = typer.Option(None, "--event-scope", help="Choices: CLUSTER, ORG"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Event Threshold Configuration."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/eventThresholds"
+    params = {}
+    if event_name is not None:
+        params["eventName"] = event_name
+    if cluster_id is not None:
+        params["clusterId"] = cluster_id
+    if event_scope is not None:
+        params["eventScope"] = event_scope
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("eventThresholds", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name')], limit=limit)
+
+
+
+@app.command("update")
+def update(
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Update Event Threshold Configuration\n\nExample --json-body:\n  '{"eventThresholds":[{"eventThresholdId":"...","thresholdConfig":"..."}]}'."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/eventThresholds"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+    try:
+        result = api.session.rest_patch(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    typer.echo(f"Updated.")
+
+
+
+@app.command("show-event-thresholds")
+def show_event_thresholds(
+    event_threshold_id: str = typer.Argument(help="eventThresholdId"),
+    output: str = typer.Option("json", "--output", "-o", help="Output format: table|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Event Threshold Configuration."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/eventThresholds/{event_threshold_id}"
+    try:
+        result = api.session.rest_get(url)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    else:
+        if isinstance(result, dict):
+            print_table([result], columns=[("Key", ""), ("Value", "")], limit=0)
+        elif isinstance(result, list):
+            print_table(result, columns=[("ID", "id"), ("Name", "name")], limit=0)
+        else:
+            print_json(result)
+
+
+
+@app.command("create-reset")
+def create_reset(
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    output: str = typer.Option("id", "--output", "-o", help="Output format: id|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Reset Event Threshold Configuration\n\nExample --json-body:\n  '{"eventThresholdIds":["..."]}'."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/videoMesh/eventThresholds/reset"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+    try:
+        result = api.session.rest_post(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    elif isinstance(result, dict) and "id" in result:
+        typer.echo(f"Created: {result['id']}")
+    elif not result or result == {}:
+        typer.echo("Created.")
+    else:
+        print_json(result)
+
+