@salesforce/afv-skills 1.22.0 → 1.24.0

package/skills/generating-mermaid-diagrams/scripts/query-org-metadata.py

@@ -1,293 +0,0 @@
-#!/usr/bin/env python3
-"""
-Query Salesforce org for ERD metadata enrichment.
-
-Retrieves:
-1. Record counts for LDV detection (>2M = LDV)
-2. OWD (Org-Wide Default) sharing settings
-3. Object type (Standard/Custom/External)
-
-Usage:
-    python3 query-org-metadata.py --objects Account,Contact,Invoice__c --target-org myorg
-    python3 query-org-metadata.py --objects Account,Contact --target-org myorg --output table
-    python3 query-org-metadata.py --objects Account --target-org myorg --output json
-
-Output:
-    JSON or table with object metadata for diagram generation
-"""
-
-import subprocess
-import json
-import sys
-import argparse
-from typing import Optional
-
-LDV_THRESHOLD = 2_000_000  # 2 million records
-
-
-def run_sf_command(cmd: list[str], timeout: int = 30) -> Optional[dict]:
-    """Run an sf CLI command and return parsed JSON result."""
-    try:
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=timeout
-        )
-        if result.returncode == 0:
-            return json.loads(result.stdout)
-    except subprocess.TimeoutExpired:
-        pass
-    except json.JSONDecodeError:
-        pass
-    except Exception:
-        pass
-    return None
-
-
-def query_record_count(sobject: str, target_org: str) -> int:
-    """Query record count using sf data query."""
-    # External objects don't support COUNT()
-    if sobject.endswith("__x"):
-        return -1
-
-    cmd = [
-        "sf", "data", "query",
-        "--query", f"SELECT COUNT() FROM {sobject}",
-        "--target-org", target_org,
-        "--json"
-    ]
-
-    data = run_sf_command(cmd)
-    if data:
-        return data.get("result", {}).get("totalSize", -1)
-    return -1
-
-
-def query_object_describe(sobject: str, target_org: str) -> dict:
-    """Get object metadata (label, custom flag) via sobject describe."""
-    cmd = [
-        "sf", "sobject", "describe",
-        "--sobject", sobject,
-        "--target-org", target_org,
-        "--json"
-    ]
-
-    data = run_sf_command(cmd)
-    if data:
-        result_data = data.get("result", {})
-        return {
-            "is_custom": result_data.get("custom", False),
-            "key_prefix": result_data.get("keyPrefix", ""),
-            "label": result_data.get("label", sobject),
-        }
-    return {}
-
-
-def query_owd_bulk(objects: list[str], target_org: str) -> dict[str, dict]:
-    """
-    Query OWD for multiple objects using Tooling API EntityDefinition.
-
-    This is the correct way to get OWD - sf sobject describe returns null
-    for sharingModel, but EntityDefinition via Tooling API works.
-    """
-    # Build IN clause for SOQL
-    quoted_objects = ", ".join([f"'{obj}'" for obj in objects])
-    query = f"SELECT QualifiedApiName, InternalSharingModel, ExternalSharingModel FROM EntityDefinition WHERE QualifiedApiName IN ({quoted_objects})"
-
-    cmd = [
-        "sf", "data", "query",
-        "--query", query,
-        "--target-org", target_org,
-        "--use-tooling-api",
-        "--json"
-    ]
-
-    data = run_sf_command(cmd, timeout=60)
-    result = {}
-
-    if data:
-        records = data.get("result", {}).get("records", [])
-        for record in records:
-            api_name = record.get("QualifiedApiName", "")
-            result[api_name] = {
-                "internal_owd": record.get("InternalSharingModel", "Unknown"),
-                "external_owd": record.get("ExternalSharingModel", "Unknown"),
-            }
-
-    return result
-
-
-def get_object_type(sobject: str, describe: dict) -> str:
-    """Determine object type: STD, CUST, or EXT."""
-    if sobject.endswith("__x"):
-        return "EXT"
-    elif sobject.endswith("__c") or describe.get("is_custom"):
-        return "CUST"
-    return "STD"
-
-
-def format_ldv(count: int) -> str:
-    """Format record count for LDV display."""
-    if count < 0:
-        return ""
-    if count >= LDV_THRESHOLD:
-        if count >= 1_000_000:
-            return f"LDV[~{count // 1_000_000}M]"
-        else:
-            return f"LDV[~{count // 1_000}K]"
-    return ""
-
-
-def format_owd(sharing_model: str) -> str:
-    """Format OWD for display."""
-    owd_map = {
-        "Private": "Private",
-        "Read": "Read",
-        "ReadWrite": "ReadWrite",
-        "ReadWriteTransfer": "Full",
-        "ControlledByParent": "Parent",
-        "FullAccess": "Full",
-        "Unknown": "Unknown"
-    }
-    return owd_map.get(sharing_model, sharing_model)
-
-
-def format_count(count: int) -> str:
-    """Format record count with commas."""
-    if count < 0:
-        return "N/A"
-    return f"{count:,}"
-
-
-def print_table_output(results: dict) -> None:
-    """Print results as formatted table."""
-    print()
-    print("=" * 78)
-    print(f"{'Object':<25} {'Type':<6} {'Records':<14} {'LDV':<12} {'OWD':<15}")
-    print("-" * 78)
-
-    for obj, data in results.items():
-        count_str = format_count(data['record_count'])
-        ldv = data['ldv_indicator'] or "-"
-        owd = f"OWD:{data['owd']}"
-        print(f"{obj:<25} {data['object_type']:<6} {count_str:<14} {ldv:<12} {owd:<15}")
-
-    print("=" * 78)
-    print()
-
-
-def print_mermaid_hints(results: dict) -> None:
-    """Print Mermaid flowchart style hints."""
-    print("Mermaid Style Hints:")
-    print("-" * 40)
-
-    for obj, data in results.items():
-        obj_type = data['object_type']
-        if obj_type == "STD":
-            color = "fill:#bae6fd,stroke:#0369a1"
-        elif obj_type == "CUST":
-            color = "fill:#fed7aa,stroke:#c2410c"
-        else:  # EXT
-            color = "fill:#a7f3d0,stroke:#047857"
-
-        # Build label parts
-        label_parts = []
-        if data['ldv_indicator']:
-            label_parts.append(data['ldv_indicator'])
-        label_parts.append(f"OWD:{data['owd']}")
-
-        label = f"{obj}<br/>{' | '.join(label_parts)}"
-        safe_id = obj.replace("__", "_")
-
-        print(f'    {safe_id}["{label}"]')
-        print(f"    style {safe_id} {color},color:#1f2937")
-    print()
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Query Salesforce org for ERD metadata (LDV, OWD, object type)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    %(prog)s --objects Account,Contact,Opportunity --target-org myorg
-    %(prog)s --objects Account,Invoice__c --target-org myorg --output table
-    %(prog)s --objects Account --target-org myorg --mermaid
-        """
-    )
-    parser.add_argument(
-        "--objects", "-o",
-        required=True,
-        help="Comma-separated object API names (e.g., Account,Contact,Invoice__c)"
-    )
-    parser.add_argument(
-        "--target-org", "-u",
-        required=True,
-        help="Salesforce org alias or username"
-    )
-    parser.add_argument(
-        "--output", "-f",
-        default="table",
-        choices=["json", "table"],
-        help="Output format (default: table)"
-    )
-    parser.add_argument(
-        "--mermaid", "-m",
-        action="store_true",
-        help="Include Mermaid style hints in output"
-    )
-
-    args = parser.parse_args()
-
-    objects = [o.strip() for o in args.objects.split(",")]
-    results = {}
-
-    # Show progress for table output
-    if args.output == "table":
-        print(f"\nQuerying {len(objects)} objects from org: {args.target_org}")
-        print("-" * 50)
-
-    # Bulk query OWD for all objects at once (much faster)
-    if args.output == "table":
-        print("  [0] Querying OWD via Tooling API...", end=" ", flush=True)
-    owd_data = query_owd_bulk(objects, args.target_org)
-    if args.output == "table":
-        print(f"OK ({len(owd_data)} found)")
-
-    for i, obj in enumerate(objects, 1):
-        if args.output == "table":
-            print(f"  [{i}/{len(objects)}] Querying {obj}...", end=" ", flush=True)
-
-        count = query_record_count(obj, args.target_org)
-        describe = query_object_describe(obj, args.target_org)
-        obj_type = get_object_type(obj, describe)
-
-        # Get OWD from bulk query result
-        obj_owd = owd_data.get(obj, {})
-        internal_owd = obj_owd.get("internal_owd", "Unknown")
-
-        results[obj] = {
-            "record_count": count,
-            "ldv_indicator": format_ldv(count),
-            "object_type": obj_type,
-            "owd": format_owd(internal_owd),
-            "external_owd": format_owd(obj_owd.get("external_owd", "Unknown")),
-            "label": describe.get("label", obj),
-        }
-
-        if args.output == "table":
-            status = "OK" if describe else "WARN"
-            print(status)
-
-    # Output results
-    if args.output == "json":
-        print(json.dumps(results, indent=2))
-    else:
-        print_table_output(results)
-        if args.mermaid:
-            print_mermaid_hints(results)
-
-
-if __name__ == "__main__":
-    main()

package/skills/generating-permission-set/SKILL.md

@@ -1,189 +0,0 @@
----
-name: generating-permission-set
-description: "Generates correct, deployable Salesforce permission set metadata (PermissionSet XML) with object, field, user, and app permissions. Use this skill when creating or editing permission set metadata, object permissions, field-level security (FLS), tab visibility, or deploying permission sets."
-compatibility: Salesforce Metadata API v60.0+
-metadata:
-  author: sf-skills
-  version: "1.0"
----
-
-## When to Use This Skill
-
-Use when generating or editing permission set metadata, or when granting object, field, user, and app permissions.
-
-## Step 1: Define Core Properties
-
-Start by defining the required permission set properties:
-
-```xml
-<PermissionSet xmlns="http://soap.sforce.com/2006/04/metadata">
-    <fullName>YourPermissionSetName</fullName>
-    <label>Display Name for Administrators</label>
-    <description>Clear description of purpose and intended audience</description>
-</PermissionSet>
-```
-
-**Naming conventions:**
-- Use descriptive API names (e.g., `Sales_Manager_Access`)
-
-## Step 2: Configure Object Permissions
-
-Add CRUD permissions for standard and custom objects:
-
-```xml
-<objectPermissions>
-    <allowCreate>true</allowCreate>
-    <allowRead>true</allowRead>
-    <allowEdit>true</allowEdit>
-    <allowDelete>false</allowDelete>
-    <modifyAllRecords>false</modifyAllRecords>
-    <viewAllRecords>false</viewAllRecords>
-    <viewAllFields>false</viewAllFields>
-    <object>Account</object>
-</objectPermissions>
-```
-
-## Step 3: Set Field-Level Security
-
-Define field permissions for sensitive or custom fields:
-
-```xml
-<fieldPermissions>
-    <editable>true</editable>
-    <readable>true</readable>
-    <field>Account.SSN__c</field>
-</fieldPermissions>
-```
-
-**Important:**
-- Required fields must NEVER appear in list of field permissions. Granting field-level security on required fields is not allowed by the platform and will cause deployment failure. 
-- Before adding any field, confirm from the object metadata that the field exists and is not required
-- A field is required when its metadata contains `<required>true</required>`:
-- Formula fields cannot be editable
-- Master-detail fields are required fields on the child (detail) object
-
-```xml
-<fields>
-    <fullName>FieldName__c</fullName>
-    <required>true</required>
-</fields>
-```
-- Use format `ObjectName.FieldName` for field references
-- Set both readable and editable to true when the user needs edit access; editable implies readable
-- If all fields should be visible, can alternatively enable the "viewAllFields" object permission
-
-## Step 4: Grant User Permissions
-
-Add system-level permissions for features and capabilities:
-
-```xml
-<userPermissions>
-    <enabled>true</enabled>
-    <name>ApiEnabled</name>
-</userPermissions>
-<userPermissions>
-    <enabled>true</enabled>
-    <name>RunReports</name>
-</userPermissions>
-```
-
-**Common permissions:**
-- `ApiEnabled`: API access
-- `ViewSetup`: View Setup menu
-- `ManageUsers`: User management
-- `RunReports`: Report execution
-
-**Security review required for:**
-- `ViewAllData`: Read all records
-- `ModifyAllData`: Edit all records
-- `ManageUsers`: User administration
-
-## Step 5: Configure App and Tab Visibility
-
-Make applications and tabs visible to users:
-
-```xml
-<applicationVisibilities>
-    <application>Sales_Console</application>
-    <visible>true</visible>
-</applicationVisibilities>
-<tabSettings>
-    <tab>CustomTab__c</tab>
-    <visibility>Visible</visibility>
-</tabSettings>
-```
-
-**Application visibility options:**
-- <visible> can be true or false
-
-**Tab visibility options:**
-- `Visible`: The tab is available on the All Tabs page and appears in the visible tabs for its associated app. Can be customized.
-- `Available`: The tab is available on the All Tabs page. Individual users can customize their display to make the tab visible in any app
-- `None`: Not visible
-
-**CRITICAL - Tab Naming:**
-- Custom object tabs: MUST include the __c suffix (e.g., MyCustomObject__c)
-- Standard object tabs: Use the object name with "standard-" prefix (e.g., standard-Account, standard-Contact)
-- The tab name matches the object's API name exactly
-
-## Step 6: Add Apex and Visualforce Access (Optional)
-
-Grant access to custom code:
-
-```xml
-<classAccesses>
-    <apexClass>CustomController</apexClass>
-    <enabled>true</enabled>
-</classAccesses>
-<pageAccesses>
-    <apexPage>CustomPage</apexPage>
-    <enabled>true</enabled>
-</pageAccesses>
-```
-
-## Step 7: Set License and Record Type Settings (Optional)
-
-Specify license requirements and record type visibility:
-
-```xml
-<license>Salesforce</license>
-<hasActivationRequired>false</hasActivationRequired>
-<recordTypeVisibilities>
-    <recordType>Account.Business</recordType>
-    <visible>true</visible>
-    <default>true</default>
-</recordTypeVisibilities>
-```
-## Step 8: Set Agent Access (Optional)
-                                              
-Enable access to Agentforce Employee Agents for users assigned to this permission set:
-
-<agentAccesses>
-    <agentName>Sales_Assistant_Agent</agentName>
-    <enabled>true</enabled>
-</agentAccesses>
-
-Field requirements:
-- agentName (Required): The developer name of the employee agent
-- enabled (Required): Set to true to grant access, false to deny
-
-Important:
-- Agent names must match existing Agentforce Employee Agent developer names
-
-## Validation Checklist
-
-Before deploying, verify:
-- [ ] fullName, label, description set
-- [ ] Permissions follow least privilege
-- [ ] No required fields in `<fieldPermissions>`
-- [ ] No duplicate permissions
-- [ ] No lengthy comments
-
-## What Causes Deployment Failure
-
-- **Field permissions on required fields:** Any required field in `<fieldPermissions>` fails deployment. Required fields cannot have FLS; omit them entirely. Always confirm from object/field metadata that a field exists and is not required—never assume.
-- **Incorrect API names:** Using the wrong name or missing suffixes (e.g. missing `__c` for custom objects, fields, tabs) cause failure.
-
-## Deployment
-
-Deploy using Salesforce CLI

package/skills/generating-ui-bundle-custom-app/SKILL.md

@@ -1,93 +0,0 @@
----
-name: generating-ui-bundle-custom-app
-description: "MUST activate when the project contains a uiBundles/*/src/ directory and the task involves creating or configuring a Custom Application for hosting a UI bundle in Lightning Experience. Use this skill when creating a CustomApplication metadata record to surface the UI bundle in the App Launcher. Activate when files matching applications/*.app-meta.xml exist and need modification, or when the user wants to expose their app via the Lightning App Launcher without a Digital Experience Site. Do NOT use generating-custom-application for this — UI bundle apps do not use tabs, action overrides, or flexipages."
-metadata:
-  version: "1.0"
----
-
-# Custom Application for React UI Bundles
-Create and configure a Salesforce Custom Application that hosts a React UI bundle in Lightning Experience. This skill generates the CustomApplication metadata so the app appears in the Lightning App Launcher and can be accessed by internal users.
-
-Custom Applications differ from Experience Sites: they don't need Networks, CustomSite, DigitalExperienceConfig, or DigitalExperienceBundle metadata. The Custom Application acts as a thin launcher entry that delegates rendering to the React UI bundle referenced by `uiBundle`.
-
-## Required Properties
-Resolve all properties before generating any metadata. Each has a fallback chain — work through each option in order until a value is found.
-
-| Property | Format | How to Resolve |
-|----------|--------|----------------|
-| **appName** | `lowercamelcase` (e.g., `myInternalApp`) | The UI bundle name from `uiBundles/<name>/` directory |
-| **appNamespace** | String | `namespace` in `sfdx-project.json` → `sf data query -q "SELECT NamespacePrefix FROM Organization" --target-org ${usernameOrAlias}` → default `c` |
-| **appLabel** | Human-readable string | User-provided, or derive from appName by converting camelCase to Title Case |
-
-The `appNamespace` and `appName` connect the Custom Application to the correct React UI bundle. In newer API versions this uses `<uiBundle>{appNamespace}__{appName}</uiBundle>`; in older versions it uses `<webApplication>{appName}</webApplication>`. Getting this wrong means the app launcher entry exists but shows a blank page. Step 2 of the workflow determines which field to use.
-
-## Generation Workflow
-### Step 1: Resolve All Required Properties
-Determine values for all properties before constructing anything. Use the resolution strategies in the table above.
-
-### Step 2: Query API Context (Version-Aware Field Discovery)
-Call `salesforce-api-context` MCP tools to discover which fields exist for the target org's API version. This ensures the generated metadata is compatible with the user's Salesforce version.
-
-**Required calls:**
-1. Call `get_metadata_type_fields` for `CustomApplication` — check whether the `uiBundle` field exists
-2. Call `get_metadata_type_fields` for `UIBundle` — check whether the `target` field exists
-
-**Field resolution based on API response:**
-
-| Field Check | If present | If absent (older API version) |
-|-------------|-----------|-------------------------------|
-| `CustomApplication.uiBundle` | Use `<uiBundle>{appNamespace}__{appName}</uiBundle>` | Use `<webApplication>{appName}</webApplication>` (no namespace) |
-| `UIBundle.target` | Use `<target>CustomApplication</target>` | Omit the `<target>` element entirely |
-
-If `salesforce-api-context` is unavailable after a real attempt, fall back to the newer field names (`uiBundle` + `target`).
-
-### Step 3: Create the Project Structure
-Create any files and directories that don't already exist:
-
-| Metadata Type | Path |
-|--------------|------|
-| CustomApplication | `<sourceDir>/applications/{appName}.app-meta.xml` |
-
-**Note:** `<sourceDir>` is determined from `sfdx-project.json`. Read `packageDirectories[]` and use the entry where `"default": true`; the full source directory is `<path>/main/default`. If no default is set, use the first entry. Commonly `force-app/main/default`, but this path is configurable.
-
-### Step 4: Populate All Metadata Fields
-Use the default template in the doc below. Values in `{braces}` are resolved property references — substitute them with the actual values from Step 1. Apply the field resolution from Step 2 to determine which XML elements to use.
-
-| Metadata Type | Template Reference |
-|--------------|-------------------|
-| CustomApplication | [configure-metadata-custom-application.md](docs/configure-metadata-custom-application.md) |
-
-### Execution Note for Step 4: Load and use the doc
-- Agents MUST read the full contents of the docs/*.md file referenced in Step 4 before attempting to populate metadata fields.
-- Read the file in full, replace placeholders (e.g. `{appName}`) with the resolved values, then use the expanded template to populate the metadata XML content.
-- If Step 2 determined the older field names apply, substitute `<uiBundle>` with `<webApplication>` in the generated output.
-
-### Step 5: Update UI Bundle Meta XML
-If Step 2 confirmed the `target` field exists on `UIBundle`, add `<target>CustomApplication</target>` to the `.uibundle-meta.xml` file (skip if the field doesn't exist in the org's API version):
-
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<UIBundle xmlns="http://soap.sforce.com/2006/04/metadata">
-    <masterLabel>{appName}</masterLabel>
-    <description>A Salesforce UI Bundle.</description>
-    <isActive>true</isActive>
-    <version>1</version>
-    <target>CustomApplication</target>
-</UIBundle>
-```
-
-### Step 6: Do Not Modify Non-Templated Properties
-Do not modify any default property values for `CustomApplication` metadata that are not expressed as variables wrapped in `{braces}`.
-
-## Verification Checklist
-Before deploying, confirm:
-
-- [ ] All required properties are resolved
-- [ ] API context was queried to determine available fields (Step 2)
-- [ ] `applications/{appName}.app-meta.xml` exists with correct content
-- [ ] The bundle reference field matches the org's API version (`<uiBundle>` or `<webApplication>`)
-- [ ] If `target` field is supported: `.uibundle-meta.xml` has `<target>CustomApplication</target>`
-- [ ] Deployment validates successfully:
-```bash
-sf project deploy validate --metadata CustomApplication UIBundle --target-org ${usernameOrAlias}
-```

package/skills/generating-ui-bundle-custom-app/docs/configure-metadata-custom-application.md

@@ -1,70 +0,0 @@
-# Configure Metadata: CustomApplication
-
-## Purpose
-This configuration file creates a **net-new, default** CustomApplication metadata record for a Lightning Experience app that hosts a React UI bundle. It is not intended to edit or modify an existing CustomApplication record. Use this template only when provisioning a brand-new Custom Application for a UI bundle.
-
-## File Location
-```
-<sourceDir>/applications/{appName}.app-meta.xml
-```
-
-**Note:** Determine `<sourceDir>` from `sfdx-project.json` → `packageDirectories[]` → find the entry with `"default": true` → use its `path` value + `/main/default`. Commonly `force-app/main/default`, but this is configurable.
-
-## Default Template (newer API versions — `uiBundle` field available)
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<CustomApplication xmlns="http://soap.sforce.com/2006/04/metadata">
-    <brand>
-        <headerColor>#0070D2</headerColor>
-        <shouldOverrideOrgTheme>false</shouldOverrideOrgTheme>
-    </brand>
-    <formFactors>Small</formFactors>
-    <formFactors>Large</formFactors>
-    <isNavAutoTempTabsDisabled>false</isNavAutoTempTabsDisabled>
-    <isNavPersonalizationDisabled>false</isNavPersonalizationDisabled>
-    <isNavTabPersistenceDisabled>false</isNavTabPersistenceDisabled>
-    <isOmniPinnedViewEnabled>false</isOmniPinnedViewEnabled>
-    <label>{appLabel}</label>
-    <navType>Standard</navType>
-    <uiBundle>{appNamespace}__{appName}</uiBundle>
-    <uiType>Lightning</uiType>
-</CustomApplication>
-```
-
-## Fallback Template (older API versions — `uiBundle` field NOT available)
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<CustomApplication xmlns="http://soap.sforce.com/2006/04/metadata">
-    <brand>
-        <headerColor>#0070D2</headerColor>
-        <shouldOverrideOrgTheme>false</shouldOverrideOrgTheme>
-    </brand>
-    <formFactors>Small</formFactors>
-    <formFactors>Large</formFactors>
-    <isNavAutoTempTabsDisabled>false</isNavAutoTempTabsDisabled>
-    <isNavPersonalizationDisabled>false</isNavPersonalizationDisabled>
-    <isNavTabPersistenceDisabled>false</isNavTabPersistenceDisabled>
-    <isOmniPinnedViewEnabled>false</isOmniPinnedViewEnabled>
-    <label>{appLabel}</label>
-    <navType>Standard</navType>
-    <webApplication>{appName}</webApplication>
-    <uiType>Lightning</uiType>
-</CustomApplication>
-```
-
-## Field Reference
-
-| Field | Required | Version | Description |
-|-------|----------|---------|-------------|
-| `brand.headerColor` | Yes | All | Hex color for the app header bar in Lightning Experience. Default: `#0070D2` (Salesforce blue). |
-| `brand.shouldOverrideOrgTheme` | Yes | All | Whether this app's branding overrides the org theme. Default: `false`. |
-| `formFactors` | Yes | All | Supported form factors. Include both `Small` (mobile) and `Large` (desktop) for full coverage. |
-| `isNavAutoTempTabsDisabled` | Yes | All | Disable auto-creation of temporary tabs. Default: `false`. |
-| `isNavPersonalizationDisabled` | Yes | All | Disable user personalization of navigation. Default: `false`. |
-| `isNavTabPersistenceDisabled` | Yes | All | Disable persistence of nav tabs across sessions. Default: `false`. |
-| `isOmniPinnedViewEnabled` | Yes | All | Enable Omni-channel pinned view. Default: `false`. |
-| `label` | Yes | All | Human-readable label shown in the App Launcher and app switcher. |
-| `navType` | Yes | All | Navigation type. Use `Standard` for standard Lightning navigation. |
-| `uiBundle` | Conditional | Newer | Namespace-qualified developer name of the UI bundle (`{appNamespace}__{appName}`). Use when `get_metadata_type_fields` confirms this field exists on `CustomApplication`. |
-| `webApplication` | Conditional | Older | Developer name of the UI bundle (`{appName}`, no namespace). Use when `uiBundle` field is not available. |
-| `uiType` | Yes | All | UI framework type. Must be `Lightning` for UI bundle apps. |