@uipath/api-workflow-tool 1.202.0-preview.161 → 1.203.0-preview.160

package/dist/{index-4j2bwfb2.js → index-w15ym591.js}

@@ -13,7 +13,7 @@ import {
   ZipService,
   toolsFactoryRepository,
   translate
-} from "./packager-tool-4vt21dnn.js";
+} from "./packager-tool-6se0wnbx.js";
 import"./packager-tool-1de529jm.js";
 // ../packager/project-packager/src/i18n/locales/de.json
 var de_default = {
@@ -46,18 +46,25 @@ var de_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -131,18 +138,25 @@ var en = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -215,18 +229,25 @@ var es_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -299,18 +320,25 @@ var es_MX_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -383,18 +411,25 @@ var fr_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -467,18 +502,25 @@ var ja_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -551,18 +593,25 @@ var ko_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -635,18 +684,25 @@ var pt_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -719,18 +775,25 @@ var pt_BR_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -803,18 +866,25 @@ var ro_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -887,18 +957,25 @@ var ru_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -971,18 +1048,25 @@ var tr_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -1055,18 +1139,25 @@ var zh_CN_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -1139,18 +1230,25 @@ var zh_TW_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -1223,18 +1321,25 @@ var zu_default = {
       info: {
         alreadyProvided: "Governance policy file already provided, skipping download.",
         saved: "Governance policy saved to {path}",
-        downloading: "Downloading governance policy from {url}",
-        noPolicyFound: "No governance policy found for this configuration.",
-        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        resolving: "Asking AutomationOps for the {product} policy, license type {licenseType}.",
+        ungoverned: "AutomationOps publishes no policy for this tenant. Analyzing with the rules shipped with the WorkflowCompiler.",
+        suppliedFileHonoured: "AutomationOps publishes no policy for this tenant, so the supplied governance file is used: {path}",
+        suppliedFileUnchecked: "Using the supplied governance file, but the tenant's own policy could not be checked: {path}",
+        noTenantToAsk: "No signed-in tenant to ask about governance. Using the supplied governance file: {path}",
         licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
         licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
         licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
       },
       errors: {
-        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
-        failedToGetPolicy: "Failed to download governance policy: {content}",
-        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
-        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        connectionIncomplete: "Connection info is incomplete, so the tenant could not be asked about governance.",
+        unknownOutcome: "Could not tell whether this tenant is governed ({reason}): {detail} Asked {url}.",
+        retryAfter: "The policy service asked for {seconds} seconds before another try.",
+        tenantPolicyWins: "The AutomationOps policy published for {product} applies to this tenant, so the governance file at {path} cannot replace it.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      },
+      instructions: {
+        tenantPolicyWins: "Drop --governance-file-path so the tenant's policy is used, or ask an administrator to change the policy published in AutomationOps."
       }
     },
     signing: {
@@ -1294,6 +1399,1575 @@ I18nManager.registerTranslations("zh-CN", zh_CN_default);
 I18nManager.registerTranslations("zh-TW", zh_TW_default);
 I18nManager.registerTranslations("zu", zu_default);
 
+// ../gov/aops-policy-sdk/dist/policy-resolver.js
+var BASE_PATH = "http://localhost".replace(/\/+$/, "");
+
+class Configuration {
+  configuration;
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+}
+var DefaultConfig = new Configuration;
+
+class BaseAPI {
+  configuration;
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$", "i");
+  middleware;
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === undefined ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = undefined;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : undefined
+          }) || response;
+        }
+      }
+      if (response === undefined) {
+        if (e instanceof Error) {
+          throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+
+class ResponseError extends Error {
+  response;
+  name = "ResponseError";
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+}
+
+class FetchError extends Error {
+  cause;
+  name = "FetchError";
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+
+class RequiredError extends Error {
+  field;
+  name = "RequiredError";
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+  }
+}
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+function canConsumeForm(consumes) {
+  for (const consume of consumes) {
+    if (consume.contentType === "multipart/form-data") {
+      return true;
+    }
+  }
+  return false;
+}
+
+class JSONApiResponse {
+  raw;
+  transformer;
+  constructor(raw, transformer = (jsonValue) => jsonValue) {
+    this.raw = raw;
+    this.transformer = transformer;
+  }
+  async value() {
+    return this.transformer(await this.raw.json());
+  }
+}
+
+class VoidApiResponse {
+  raw;
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return;
+  }
+}
+class TextApiResponse {
+  raw;
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return await this.raw.text();
+  }
+}
+function ProductDtoFromJSON(json) {
+  return ProductDtoFromJSONTyped(json, false);
+}
+function ProductDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    name: json["name"] == null ? undefined : json["name"],
+    label: json["label"] == null ? undefined : json["label"],
+    isRestricted: json["isRestricted"] == null ? undefined : json["isRestricted"],
+    isCloud: json["isCloud"] == null ? undefined : json["isCloud"],
+    isRemote: json["isRemote"] == null ? undefined : json["isRemote"]
+  };
+}
+function ProductDtoToJSON(json) {
+  return ProductDtoToJSONTyped(json, false);
+}
+function ProductDtoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    name: value["name"],
+    label: value["label"],
+    isRestricted: value["isRestricted"],
+    isCloud: value["isCloud"],
+    isRemote: value["isRemote"]
+  };
+}
+function GlobalPolicyDtoFromJSON(json) {
+  return GlobalPolicyDtoFromJSONTyped(json, false);
+}
+function GlobalPolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    licenseType: json["licenseType"] == null ? undefined : json["licenseType"],
+    identifier: json["identifier"] == null ? undefined : json["identifier"],
+    policyNumber: json["policyNumber"] == null ? undefined : json["policyNumber"],
+    product: json["product"] == null ? undefined : ProductDtoFromJSON(json["product"]),
+    data: json["data"] == null ? undefined : json["data"]
+  };
+}
+function GlobalPolicyDtoToJSON(json) {
+  return GlobalPolicyDtoToJSONTyped(json, false);
+}
+function GlobalPolicyDtoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    licenseType: value["licenseType"],
+    identifier: value["identifier"],
+    policyNumber: value["policyNumber"],
+    product: ProductDtoToJSON(value["product"]),
+    data: value["data"]
+  };
+}
+function CreateGlobalPolicyWithFormDataRequestToJSON(json) {
+  return CreateGlobalPolicyWithFormDataRequestToJSONTyped(json, false);
+}
+function CreateGlobalPolicyWithFormDataRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    globalPolicy: GlobalPolicyDtoToJSON(value["globalPolicy"])
+  };
+}
+function CreatePolicyRequestToJSON(json) {
+  return CreatePolicyRequestToJSONTyped(json, false);
+}
+function CreatePolicyRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    name: value["name"],
+    description: value["description"],
+    priority: value["priority"],
+    availability: value["availability"],
+    productName: value["productName"],
+    data: value["data"]
+  };
+}
+function FormDataDtoFromJSON(json) {
+  return FormDataDtoFromJSONTyped(json, false);
+}
+function FormDataDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    policyIdentifier: json["policyIdentifier"] == null ? undefined : json["policyIdentifier"],
+    data: json["data"] == null ? undefined : json["data"]
+  };
+}
+function FormDataDtoToJSON(json) {
+  return FormDataDtoToJSONTyped(json, false);
+}
+function FormDataDtoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    policyIdentifier: value["policyIdentifier"],
+    data: value["data"]
+  };
+}
+function PolicyDtoFromJSON(json) {
+  return PolicyDtoFromJSONTyped(json, false);
+}
+function PolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    name: json["name"] == null ? undefined : json["name"],
+    identifier: json["identifier"] == null ? undefined : json["identifier"],
+    description: json["description"] == null ? undefined : json["description"],
+    priority: json["priority"] == null ? undefined : json["priority"],
+    availability: json["availability"] == null ? undefined : json["availability"],
+    product: json["product"] == null ? undefined : ProductDtoFromJSON(json["product"]),
+    data: json["data"] == null ? undefined : FormDataDtoFromJSON(json["data"])
+  };
+}
+function PolicyDtoToJSON(json) {
+  return PolicyDtoToJSONTyped(json, false);
+}
+function PolicyDtoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    name: value["name"],
+    identifier: value["identifier"],
+    description: value["description"],
+    priority: value["priority"],
+    availability: value["availability"],
+    product: ProductDtoToJSON(value["product"]),
+    data: FormDataDtoToJSON(value["data"])
+  };
+}
+function CreatePolicyWithFormDataRequestToJSON(json) {
+  return CreatePolicyWithFormDataRequestToJSONTyped(json, false);
+}
+function CreatePolicyWithFormDataRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    policy: PolicyDtoToJSON(value["policy"]),
+    policyFormData: FormDataDtoToJSON(value["policyFormData"])
+  };
+}
+function DeployedPolicyDtoToJSON(json) {
+  return DeployedPolicyDtoToJSONTyped(json, false);
+}
+function DeployedPolicyDtoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    licenseType: value["licenseType"],
+    productName: value["productName"],
+    tenantIdentifier: value["tenantIdentifier"],
+    userIdentifier: value["userIdentifier"]
+  };
+}
+function DeployedPolicyWithoutUserDtoToJSON(json) {
+  return DeployedPolicyWithoutUserDtoToJSONTyped(json, false);
+}
+function DeployedPolicyWithoutUserDtoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    licenseType: value["licenseType"],
+    productName: value["productName"],
+    tenantIdentifier: value["tenantIdentifier"]
+  };
+}
+function DeploymentLevelFromJSON(json) {
+  return DeploymentLevelFromJSONTyped(json, false);
+}
+function DeploymentLevelFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function TenantPolicyDtoFromJSON(json) {
+  return TenantPolicyDtoFromJSONTyped(json, false);
+}
+function TenantPolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    tenantIdentifier: json["tenantIdentifier"] == null ? undefined : json["tenantIdentifier"],
+    policyIdentifier: json["policyIdentifier"] == null ? undefined : json["policyIdentifier"],
+    productIdentifier: json["productIdentifier"] == null ? undefined : json["productIdentifier"],
+    licenseTypeIdentifier: json["licenseTypeIdentifier"] == null ? undefined : json["licenseTypeIdentifier"],
+    tenantName: json["tenantName"] == null ? undefined : json["tenantName"]
+  };
+}
+function GroupPolicyDtoFromJSON(json) {
+  return GroupPolicyDtoFromJSONTyped(json, false);
+}
+function GroupPolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    policyIdentifier: json["policyIdentifier"] == null ? undefined : json["policyIdentifier"],
+    productIdentifier: json["productIdentifier"] == null ? undefined : json["productIdentifier"],
+    groupId: json["groupId"] == null ? undefined : json["groupId"],
+    groupName: json["groupName"] == null ? undefined : json["groupName"]
+  };
+}
+function UserPolicyDtoFromJSON(json) {
+  return UserPolicyDtoFromJSONTyped(json, false);
+}
+function UserPolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    policyIdentifier: json["policyIdentifier"] == null ? undefined : json["policyIdentifier"],
+    productIdentifier: json["productIdentifier"] == null ? undefined : json["productIdentifier"],
+    userId: json["userId"] == null ? undefined : json["userId"],
+    userName: json["userName"] == null ? undefined : json["userName"]
+  };
+}
+function FederatedPolicyDtoFromJSON(json) {
+  return FederatedPolicyDtoFromJSONTyped(json, false);
+}
+function FederatedPolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    name: json["name"] == null ? undefined : json["name"],
+    identifier: json["identifier"] == null ? undefined : json["identifier"],
+    product: json["product"] == null ? undefined : ProductDtoFromJSON(json["product"]),
+    description: json["description"] == null ? undefined : json["description"],
+    priority: json["priority"] == null ? undefined : json["priority"],
+    availability: json["availability"] == null ? undefined : json["availability"],
+    tenantPolicies: json["tenantPolicies"] == null ? undefined : json["tenantPolicies"].map(TenantPolicyDtoFromJSON),
+    userPolicies: json["userPolicies"] == null ? undefined : json["userPolicies"].map(UserPolicyDtoFromJSON),
+    groupPolicies: json["groupPolicies"] == null ? undefined : json["groupPolicies"].map(GroupPolicyDtoFromJSON)
+  };
+}
+function FederatedPolicyDtoPagedResultFromJSON(json) {
+  return FederatedPolicyDtoPagedResultFromJSONTyped(json, false);
+}
+function FederatedPolicyDtoPagedResultFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    totalCount: json["totalCount"] == null ? undefined : json["totalCount"],
+    result: json["result"] == null ? undefined : json["result"].map(FederatedPolicyDtoFromJSON)
+  };
+}
+function ImportPolicyRequestFromJSON(json) {
+  return ImportPolicyRequestFromJSONTyped(json, false);
+}
+function ImportPolicyRequestFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    productName: json["product-name"] == null ? undefined : json["product-name"],
+    policyName: json["policy-name"] == null ? undefined : json["policy-name"],
+    version: json["version"] == null ? undefined : json["version"],
+    data: json["data"] == null ? undefined : json["data"]
+  };
+}
+function PolicyDtoPagedResultFromJSON(json) {
+  return PolicyDtoPagedResultFromJSONTyped(json, false);
+}
+function PolicyDtoPagedResultFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    totalCount: json["totalCount"] == null ? undefined : json["totalCount"],
+    result: json["result"] == null ? undefined : json["result"].map(PolicyDtoFromJSON)
+  };
+}
+function PolicyExportResponseFromJSON(json) {
+  return PolicyExportResponseFromJSONTyped(json, false);
+}
+function PolicyExportResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    identifier: json["identifier"] == null ? undefined : json["identifier"],
+    name: json["name"] == null ? undefined : json["name"],
+    availability: json["availability"] == null ? undefined : json["availability"],
+    data: json["data"] == null ? undefined : json["data"],
+    priority: json["priority"] == null ? undefined : json["priority"],
+    deploymentLevel: json["deploymentLevel"] == null ? undefined : DeploymentLevelFromJSON(json["deploymentLevel"])
+  };
+}
+function PolicyInfoDtoFromJSON(json) {
+  return PolicyInfoDtoFromJSONTyped(json, false);
+}
+function PolicyInfoDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    name: json["name"] == null ? undefined : json["name"],
+    identifier: json["identifier"] == null ? undefined : json["identifier"],
+    product: json["product"] == null ? undefined : json["product"]
+  };
+}
+function PolicyUsageDataFromJSON(json) {
+  return PolicyUsageDataFromJSONTyped(json, false);
+}
+function PolicyUsageDataFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    tenants: json["tenants"] == null ? undefined : json["tenants"],
+    users: json["users"] == null ? undefined : json["users"],
+    groups: json["groups"] == null ? undefined : json["groups"]
+  };
+}
+function UpdatePolicyRequestToJSON(json) {
+  return UpdatePolicyRequestToJSONTyped(json, false);
+}
+function UpdatePolicyRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    name: value["name"],
+    identifier: value["identifier"],
+    description: value["description"],
+    priority: value["priority"],
+    availability: value["availability"],
+    productName: value["productName"],
+    data: value["data"]
+  };
+}
+
+class PolicyApi extends BaseAPI {
+  async policyCreateDefaultPolicyForAllProductsRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/default`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyDtoFromJSON(jsonValue));
+  }
+  async policyCreateDefaultPolicyForAllProducts(initOverrides) {
+    const response = await this.policyCreateDefaultPolicyForAllProductsRaw(initOverrides);
+    return await response.value();
+  }
+  async policyCreateFormDataRaw(requestParameters, initOverrides) {
+    if (requestParameters["policyIdentifier"] == null) {
+      throw new RequiredError("policyIdentifier", 'Required parameter "policyIdentifier" was null or undefined when calling policyCreateFormData().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/form-data/{policyIdentifier}`;
+    urlPath = urlPath.replace(`{${"policyIdentifier"}}`, encodeURIComponent(String(requestParameters["policyIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "PUT",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters["body"]
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  async policyCreateFormData(requestParameters, initOverrides) {
+    const response = await this.policyCreateFormDataRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyCreateGlobalPolicyRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/global`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: CreateGlobalPolicyWithFormDataRequestToJSON(requestParameters["createGlobalPolicyWithFormDataRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GlobalPolicyDtoFromJSON(jsonValue));
+  }
+  async policyCreateGlobalPolicy(requestParameters = {}, initOverrides) {
+    const response = await this.policyCreateGlobalPolicyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyCreatePolicyRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["telemetryFlowId"] != null) {
+      queryParameters["telemetryFlowId"] = requestParameters["telemetryFlowId"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: CreatePolicyWithFormDataRequestToJSON(requestParameters["createPolicyWithFormDataRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyDtoFromJSON(jsonValue));
+  }
+  async policyCreatePolicy(requestParameters = {}, initOverrides) {
+    const response = await this.policyCreatePolicyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyCreatePolicyV2Raw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["telemetryFlowId"] != null) {
+      queryParameters["telemetryFlowId"] = requestParameters["telemetryFlowId"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/v2/create`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: CreatePolicyRequestToJSON(requestParameters["createPolicyRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyDtoFromJSON(jsonValue));
+  }
+  async policyCreatePolicyV2(requestParameters = {}, initOverrides) {
+    const response = await this.policyCreatePolicyV2Raw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyDeletePolicyRaw(requestParameters, initOverrides) {
+    if (requestParameters["policyIdentifier"] == null) {
+      throw new RequiredError("policyIdentifier", 'Required parameter "policyIdentifier" was null or undefined when calling policyDeletePolicy().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/{policyIdentifier}`;
+    urlPath = urlPath.replace(`{${"policyIdentifier"}}`, encodeURIComponent(String(requestParameters["policyIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyDtoFromJSON(jsonValue));
+  }
+  async policyDeletePolicy(requestParameters, initOverrides) {
+    const response = await this.policyDeletePolicyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyDeletePolicyByProductNameAndPolicyNameRaw(requestParameters, initOverrides) {
+    if (requestParameters["productName"] == null) {
+      throw new RequiredError("productName", 'Required parameter "productName" was null or undefined when calling policyDeletePolicyByProductNameAndPolicyName().');
+    }
+    if (requestParameters["policyName"] == null) {
+      throw new RequiredError("policyName", 'Required parameter "policyName" was null or undefined when calling policyDeletePolicyByProductNameAndPolicyName().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/product/{productName}/policy/{policyName}`;
+    urlPath = urlPath.replace(`{${"productName"}}`, encodeURIComponent(String(requestParameters["productName"])));
+    urlPath = urlPath.replace(`{${"policyName"}}`, encodeURIComponent(String(requestParameters["policyName"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyDtoFromJSON(jsonValue));
+  }
+  async policyDeletePolicyByProductNameAndPolicyName(requestParameters, initOverrides) {
+    const response = await this.policyDeletePolicyByProductNameAndPolicyNameRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyDownloadPolicyByIdentifierRaw(requestParameters, initOverrides) {
+    if (requestParameters["policyIdentifier"] == null) {
+      throw new RequiredError("policyIdentifier", 'Required parameter "policyIdentifier" was null or undefined when calling policyDownloadPolicyByIdentifier().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/{policyIdentifier}/download`;
+    urlPath = urlPath.replace(`{${"policyIdentifier"}}`, encodeURIComponent(String(requestParameters["policyIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyUsageDataFromJSON(jsonValue));
+  }
+  async policyDownloadPolicyByIdentifier(requestParameters, initOverrides) {
+    const response = await this.policyDownloadPolicyByIdentifierRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetAllPoliciesRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy`;
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(PolicyDtoFromJSON));
+  }
+  async policyGetAllPolicies(initOverrides) {
+    const response = await this.policyGetAllPoliciesRaw(initOverrides);
+    return await response.value();
+  }
+  async policyGetAllPoliciesByProductIdRaw(requestParameters, initOverrides) {
+    if (requestParameters["productIdentifier"] == null) {
+      throw new RequiredError("productIdentifier", 'Required parameter "productIdentifier" was null or undefined when calling policyGetAllPoliciesByProductId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/{productIdentifier}`;
+    urlPath = urlPath.replace(`{${"productIdentifier"}}`, encodeURIComponent(String(requestParameters["productIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(PolicyDtoFromJSON));
+  }
+  async policyGetAllPoliciesByProductId(requestParameters, initOverrides) {
+    const response = await this.policyGetAllPoliciesByProductIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetAllPoliciesByQueryOptionsRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["productLabel"] != null) {
+      queryParameters["productLabel"] = requestParameters["productLabel"];
+    }
+    if (requestParameters["productName"] != null) {
+      queryParameters["productName"] = requestParameters["productName"];
+    }
+    if (requestParameters["productNames"] != null) {
+      queryParameters["productNames"] = requestParameters["productNames"];
+    }
+    if (requestParameters["sortBy"] != null) {
+      queryParameters["sortBy"] = requestParameters["sortBy"];
+    }
+    if (requestParameters["sortOrder"] != null) {
+      queryParameters["sortOrder"] = requestParameters["sortOrder"];
+    }
+    if (requestParameters["pageIndex"] != null) {
+      queryParameters["pageIndex"] = requestParameters["pageIndex"];
+    }
+    if (requestParameters["pageSize"] != null) {
+      queryParameters["pageSize"] = requestParameters["pageSize"];
+    }
+    if (requestParameters["searchTerm"] != null) {
+      queryParameters["searchTerm"] = requestParameters["searchTerm"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/paged`;
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyDtoPagedResultFromJSON(jsonValue));
+  }
+  async policyGetAllPoliciesByQueryOptions(requestParameters = {}, initOverrides) {
+    const response = await this.policyGetAllPoliciesByQueryOptionsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetAllRulesForProductRaw(requestParameters, initOverrides) {
+    if (requestParameters["licenseType"] == null) {
+      throw new RequiredError("licenseType", 'Required parameter "licenseType" was null or undefined when calling policyGetAllRulesForProduct().');
+    }
+    if (requestParameters["productName"] == null) {
+      throw new RequiredError("productName", 'Required parameter "productName" was null or undefined when calling policyGetAllRulesForProduct().');
+    }
+    if (requestParameters["tenantIdentifier"] == null) {
+      throw new RequiredError("tenantIdentifier", 'Required parameter "tenantIdentifier" was null or undefined when calling policyGetAllRulesForProduct().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/all/license/{licenseType}/product/{productName}/tenant/{tenantIdentifier}`;
+    urlPath = urlPath.replace(`{${"licenseType"}}`, encodeURIComponent(String(requestParameters["licenseType"])));
+    urlPath = urlPath.replace(`{${"productName"}}`, encodeURIComponent(String(requestParameters["productName"])));
+    urlPath = urlPath.replace(`{${"tenantIdentifier"}}`, encodeURIComponent(String(requestParameters["tenantIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(PolicyExportResponseFromJSON));
+  }
+  async policyGetAllRulesForProduct(requestParameters, initOverrides) {
+    const response = await this.policyGetAllRulesForProductRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetDeployedPolicyRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (requestParameters["xUiPathClientVersion"] != null) {
+      headerParameters["x-UiPath-ClientVersion"] = String(requestParameters["xUiPathClientVersion"]);
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/deployed-policy`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: DeployedPolicyDtoToJSON(requestParameters["deployedPolicyDto"])
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async policyGetDeployedPolicy(requestParameters = {}, initOverrides) {
+    await this.policyGetDeployedPolicyRaw(requestParameters, initOverrides);
+  }
+  async policyGetDeployedTenantPoliciesRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (requestParameters["xUiPathClientVersion"] != null) {
+      headerParameters["x-UiPath-ClientVersion"] = String(requestParameters["xUiPathClientVersion"]);
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/deployed-policy/tenant`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: DeployedPolicyWithoutUserDtoToJSON(requestParameters["deployedPolicyWithoutUserDto"])
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async policyGetDeployedTenantPolicies(requestParameters = {}, initOverrides) {
+    await this.policyGetDeployedTenantPoliciesRaw(requestParameters, initOverrides);
+  }
+  async policyGetFederatedPoliciesByQueryOptionsRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["productLabel"] != null) {
+      queryParameters["productLabel"] = requestParameters["productLabel"];
+    }
+    if (requestParameters["productName"] != null) {
+      queryParameters["productName"] = requestParameters["productName"];
+    }
+    if (requestParameters["productNames"] != null) {
+      queryParameters["productNames"] = requestParameters["productNames"];
+    }
+    if (requestParameters["sortBy"] != null) {
+      queryParameters["sortBy"] = requestParameters["sortBy"];
+    }
+    if (requestParameters["sortOrder"] != null) {
+      queryParameters["sortOrder"] = requestParameters["sortOrder"];
+    }
+    if (requestParameters["pageIndex"] != null) {
+      queryParameters["pageIndex"] = requestParameters["pageIndex"];
+    }
+    if (requestParameters["pageSize"] != null) {
+      queryParameters["pageSize"] = requestParameters["pageSize"];
+    }
+    if (requestParameters["searchTerm"] != null) {
+      queryParameters["searchTerm"] = requestParameters["searchTerm"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/federated/paged`;
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => FederatedPolicyDtoPagedResultFromJSON(jsonValue));
+  }
+  async policyGetFederatedPoliciesByQueryOptions(requestParameters = {}, initOverrides) {
+    const response = await this.policyGetFederatedPoliciesByQueryOptionsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetFormDataByPolicyIdRaw(requestParameters, initOverrides) {
+    if (requestParameters["policyIdentifier"] == null) {
+      throw new RequiredError("policyIdentifier", 'Required parameter "policyIdentifier" was null or undefined when calling policyGetFormDataByPolicyId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/form-data/{policyIdentifier}`;
+    urlPath = urlPath.replace(`{${"policyIdentifier"}}`, encodeURIComponent(String(requestParameters["policyIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  async policyGetFormDataByPolicyId(requestParameters, initOverrides) {
+    const response = await this.policyGetFormDataByPolicyIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetGlobalPolicyByLicenseTypeAndProductNameRaw(requestParameters, initOverrides) {
+    if (requestParameters["licenseType"] == null) {
+      throw new RequiredError("licenseType", 'Required parameter "licenseType" was null or undefined when calling policyGetGlobalPolicyByLicenseTypeAndProductName().');
+    }
+    if (requestParameters["productIdentifier"] == null) {
+      throw new RequiredError("productIdentifier", 'Required parameter "productIdentifier" was null or undefined when calling policyGetGlobalPolicyByLicenseTypeAndProductName().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/global/license/{licenseType}/product/{productIdentifier}`;
+    urlPath = urlPath.replace(`{${"licenseType"}}`, encodeURIComponent(String(requestParameters["licenseType"])));
+    urlPath = urlPath.replace(`{${"productIdentifier"}}`, encodeURIComponent(String(requestParameters["productIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GlobalPolicyDtoFromJSON(jsonValue));
+  }
+  async policyGetGlobalPolicyByLicenseTypeAndProductName(requestParameters, initOverrides) {
+    const response = await this.policyGetGlobalPolicyByLicenseTypeAndProductNameRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetGroupPoliciesForAllProductsRaw(requestParameters, initOverrides) {
+    if (requestParameters["identifier"] == null) {
+      throw new RequiredError("identifier", 'Required parameter "identifier" was null or undefined when calling policyGetGroupPoliciesForAllProducts().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/group/{identifier}`;
+    urlPath = urlPath.replace(`{${"identifier"}}`, encodeURIComponent(String(requestParameters["identifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(GroupPolicyDtoFromJSON));
+  }
+  async policyGetGroupPoliciesForAllProducts(requestParameters, initOverrides) {
+    const response = await this.policyGetGroupPoliciesForAllProductsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetPoliciesByProductIdentifiersRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["ids"] != null) {
+      queryParameters["ids"] = requestParameters["ids"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/filter/products`;
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(PolicyInfoDtoFromJSON));
+  }
+  async policyGetPoliciesByProductIdentifiers(requestParameters = {}, initOverrides) {
+    const response = await this.policyGetPoliciesByProductIdentifiersRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetPolicyByIdRaw(requestParameters, initOverrides) {
+    if (requestParameters["policyIdentifier"] == null) {
+      throw new RequiredError("policyIdentifier", 'Required parameter "policyIdentifier" was null or undefined when calling policyGetPolicyById().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/id/{policyIdentifier}`;
+    urlPath = urlPath.replace(`{${"policyIdentifier"}}`, encodeURIComponent(String(requestParameters["policyIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyDtoFromJSON(jsonValue));
+  }
+  async policyGetPolicyById(requestParameters, initOverrides) {
+    const response = await this.policyGetPolicyByIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetPolicyByNameAndProductIdentifierRaw(requestParameters, initOverrides) {
+    if (requestParameters["policyName"] == null) {
+      throw new RequiredError("policyName", 'Required parameter "policyName" was null or undefined when calling policyGetPolicyByNameAndProductIdentifier().');
+    }
+    if (requestParameters["productIdentifier"] == null) {
+      throw new RequiredError("productIdentifier", 'Required parameter "productIdentifier" was null or undefined when calling policyGetPolicyByNameAndProductIdentifier().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/{policyName}/product/{productIdentifier}`;
+    urlPath = urlPath.replace(`{${"policyName"}}`, encodeURIComponent(String(requestParameters["policyName"])));
+    urlPath = urlPath.replace(`{${"productIdentifier"}}`, encodeURIComponent(String(requestParameters["productIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyUsageDataFromJSON(jsonValue));
+  }
+  async policyGetPolicyByNameAndProductIdentifier(requestParameters, initOverrides) {
+    const response = await this.policyGetPolicyByNameAndProductIdentifierRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetPolicyDataByIdentifierRaw(requestParameters, initOverrides) {
+    if (requestParameters["policyIdentifier"] == null) {
+      throw new RequiredError("policyIdentifier", 'Required parameter "policyIdentifier" was null or undefined when calling policyGetPolicyDataByIdentifier().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/data/{policyIdentifier}`;
+    urlPath = urlPath.replace(`{${"policyIdentifier"}}`, encodeURIComponent(String(requestParameters["policyIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ImportPolicyRequestFromJSON(jsonValue));
+  }
+  async policyGetPolicyDataByIdentifier(requestParameters, initOverrides) {
+    const response = await this.policyGetPolicyDataByIdentifierRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetPolicyUsageDataRaw(requestParameters, initOverrides) {
+    if (requestParameters["policyIdentifier"] == null) {
+      throw new RequiredError("policyIdentifier", 'Required parameter "policyIdentifier" was null or undefined when calling policyGetPolicyUsageData().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/usage/{policyIdentifier}`;
+    urlPath = urlPath.replace(`{${"policyIdentifier"}}`, encodeURIComponent(String(requestParameters["policyIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyUsageDataFromJSON(jsonValue));
+  }
+  async policyGetPolicyUsageData(requestParameters, initOverrides) {
+    const response = await this.policyGetPolicyUsageDataRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyGetRulesForProductRaw(requestParameters, initOverrides) {
+    if (requestParameters["licenseType"] == null) {
+      throw new RequiredError("licenseType", 'Required parameter "licenseType" was null or undefined when calling policyGetRulesForProduct().');
+    }
+    if (requestParameters["productName"] == null) {
+      throw new RequiredError("productName", 'Required parameter "productName" was null or undefined when calling policyGetRulesForProduct().');
+    }
+    if (requestParameters["tenantIdentifier"] == null) {
+      throw new RequiredError("tenantIdentifier", 'Required parameter "tenantIdentifier" was null or undefined when calling policyGetRulesForProduct().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/license/{licenseType}/product/{productName}/tenant/{tenantIdentifier}`;
+    urlPath = urlPath.replace(`{${"licenseType"}}`, encodeURIComponent(String(requestParameters["licenseType"])));
+    urlPath = urlPath.replace(`{${"productName"}}`, encodeURIComponent(String(requestParameters["productName"])));
+    urlPath = urlPath.replace(`{${"tenantIdentifier"}}`, encodeURIComponent(String(requestParameters["tenantIdentifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async policyGetRulesForProduct(requestParameters, initOverrides) {
+    await this.policyGetRulesForProductRaw(requestParameters, initOverrides);
+  }
+  async policyGetUserInheritanceGroupPoliciesForAllProductsRaw(requestParameters, initOverrides) {
+    if (requestParameters["identifier"] == null) {
+      throw new RequiredError("identifier", 'Required parameter "identifier" was null or undefined when calling policyGetUserInheritanceGroupPoliciesForAllProducts().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/user/group/{identifier}`;
+    urlPath = urlPath.replace(`{${"identifier"}}`, encodeURIComponent(String(requestParameters["identifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async policyGetUserInheritanceGroupPoliciesForAllProducts(requestParameters, initOverrides) {
+    await this.policyGetUserInheritanceGroupPoliciesForAllProductsRaw(requestParameters, initOverrides);
+  }
+  async policyGetUserPoliciesForAllProductsRaw(requestParameters, initOverrides) {
+    if (requestParameters["identifier"] == null) {
+      throw new RequiredError("identifier", 'Required parameter "identifier" was null or undefined when calling policyGetUserPoliciesForAllProducts().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/user/{identifier}`;
+    urlPath = urlPath.replace(`{${"identifier"}}`, encodeURIComponent(String(requestParameters["identifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async policyGetUserPoliciesForAllProducts(requestParameters, initOverrides) {
+    await this.policyGetUserPoliciesForAllProductsRaw(requestParameters, initOverrides);
+  }
+  async policyGetUserPoliciesForAllProductsAndAllGroupsRaw(requestParameters, initOverrides) {
+    if (requestParameters["identifier"] == null) {
+      throw new RequiredError("identifier", 'Required parameter "identifier" was null or undefined when calling policyGetUserPoliciesForAllProductsAndAllGroups().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/user/{identifier}/all`;
+    urlPath = urlPath.replace(`{${"identifier"}}`, encodeURIComponent(String(requestParameters["identifier"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async policyGetUserPoliciesForAllProductsAndAllGroups(requestParameters, initOverrides) {
+    await this.policyGetUserPoliciesForAllProductsAndAllGroupsRaw(requestParameters, initOverrides);
+  }
+  async policyUpdateGlobalPolicyRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/global`;
+    const response = await this.request({
+      path: urlPath,
+      method: "PUT",
+      headers: headerParameters,
+      query: queryParameters,
+      body: CreateGlobalPolicyWithFormDataRequestToJSON(requestParameters["createGlobalPolicyWithFormDataRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GlobalPolicyDtoFromJSON(jsonValue));
+  }
+  async policyUpdateGlobalPolicy(requestParameters = {}, initOverrides) {
+    const response = await this.policyUpdateGlobalPolicyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyUpdatePolicyRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy`;
+    const response = await this.request({
+      path: urlPath,
+      method: "PUT",
+      headers: headerParameters,
+      query: queryParameters,
+      body: CreatePolicyWithFormDataRequestToJSON(requestParameters["createPolicyWithFormDataRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyDtoFromJSON(jsonValue));
+  }
+  async policyUpdatePolicy(requestParameters = {}, initOverrides) {
+    const response = await this.policyUpdatePolicyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyUpdatePolicyV2Raw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Policy/v2/update`;
+    const response = await this.request({
+      path: urlPath,
+      method: "PUT",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UpdatePolicyRequestToJSON(requestParameters["updatePolicyRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyDtoFromJSON(jsonValue));
+  }
+  async policyUpdatePolicyV2(requestParameters = {}, initOverrides) {
+    const response = await this.policyUpdatePolicyV2Raw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async policyUploadCheckPolicyRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    const consumes = [
+      { contentType: "multipart/form-data" }
+    ];
+    const canConsumeForm2 = canConsumeForm(consumes);
+    let formParams;
+    let useForm = false;
+    useForm = canConsumeForm2;
+    if (useForm) {
+      formParams = new FormData;
+    } else {
+      formParams = new URLSearchParams;
+    }
+    if (requestParameters["file"] != null) {
+      formParams.append("file", requestParameters["file"]);
+    }
+    let urlPath = `/api/Policy/upload/check`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: formParams
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PolicyDtoFromJSON(jsonValue));
+  }
+  async policyUploadCheckPolicy(requestParameters = {}, initOverrides) {
+    const response = await this.policyUploadCheckPolicyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+}
+var DEFAULT_TIMEOUT_MS = 1e4;
+var CLIENT_VERSION_HEADER = "ClientVersion";
+var JSON_MIME = /^application\/(json|[^;\s]+\+json)\s*(;.*)?$/i;
+async function resolvePolicyAsync(options) {
+  const subject = options.subject;
+  requireValue("subject", subject);
+  requireText("subject.organizationId", subject.organizationId);
+  requireText("subject.tenantId", subject.tenantId);
+  requireText("subject.product", subject.product);
+  requireText("subject.licenseType", subject.licenseType);
+  requireText("baseUrl", options.baseUrl);
+  requireText("clientVersion", options.clientVersion);
+  const fetchApi = options.fetch ?? globalThis.fetch;
+  if (typeof fetchApi !== "function") {
+    throw new RequiredError("fetch", "No fetch implementation available. Pass options.fetch.");
+  }
+  const now = options.now ?? (() => new Date);
+  const basePath = `${options.baseUrl.replace(/\/+$/, "")}/${encodeURIComponent(subject.organizationId)}/roboticsops_`;
+  let requestUrl = basePath;
+  const api = new PolicyApi(new Configuration({
+    basePath,
+    fetchApi,
+    apiKey: async () => `Bearer ${await readToken(options.accessToken)}`,
+    headers: {
+      AccountId: subject.organizationId,
+      [CLIENT_VERSION_HEADER]: options.clientVersion
+    },
+    middleware: [
+      {
+        pre: async (context) => {
+          requestUrl = context.url;
+        }
+      }
+    ]
+  }));
+  if (options.signal?.aborted) {
+    return unknown(subject, buildAudit(requestUrl, now), "cancelled", "The request was cancelled before it was sent.");
+  }
+  const controller = new AbortController;
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const relayAbort = () => controller.abort();
+  options.signal?.addEventListener("abort", relayAbort, { once: true });
+  let seenResponse;
+  try {
+    const response = await api.policyGetRulesForProductRaw({
+      licenseType: subject.licenseType,
+      productName: subject.product,
+      tenantIdentifier: subject.tenantId
+    }, { signal: controller.signal });
+    seenResponse = response.raw;
+    return await classifySuccess(response.raw, subject, requestUrl, now);
+  } catch (error) {
+    return classifyFailure(error, subject, requestUrl, now, timedOut, options.signal, seenResponse);
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", relayAbort);
+  }
+}
+async function classifySuccess(response, subject, url, now) {
+  const audit = buildAudit(url, now, response);
+  if (response.status === 204) {
+    return { outcome: "ungoverned", subject, audit };
+  }
+  if (response.status !== 200) {
+    return unknown(subject, audit, "serverError", `The policy service answered ${response.status}; only 200 carries a policy and only 204 means none is published.`);
+  }
+  const contentType = response.headers.get("content-type");
+  if (!JSON_MIME.test(contentType ?? "")) {
+    return unknown(subject, audit, "notJson", `Expected a JSON policy document, got content-type ${contentType ?? "(none)"}.`);
+  }
+  const body = await response.text();
+  if (!isJsonObject(body)) {
+    return unknown(subject, audit, "notJson", body.trim() === "" ? "The response body was empty." : "The response body is not a JSON object.");
+  }
+  return { outcome: "governed", subject, audit, document: body };
+}
+function classifyFailure(error, subject, url, now, timedOut, signal, seenResponse) {
+  if (error instanceof ResponseError) {
+    return unknown(subject, buildAudit(url, now, error.response), reasonForStatus(error.response.status), `The policy service answered ${error.response.status}.`);
+  }
+  const audit = buildAudit(url, now, seenResponse);
+  if (timedOut) {
+    return unknown(subject, audit, "timedOut", "The policy service did not answer within the timeout.");
+  }
+  if (signal?.aborted || isAbortError(error)) {
+    return unknown(subject, audit, "cancelled", "The request was cancelled.");
+  }
+  return unknown(subject, audit, "transport", `The request to the policy service failed: ${describe(unwrap(error))}`);
+}
+function unwrap(error) {
+  return error instanceof FetchError ? error.cause : error;
+}
+function reasonForStatus(status) {
+  if (status === 401 || status === 403) {
+    return "unauthorized";
+  }
+  if (status === 404) {
+    return "notFound";
+  }
+  return "serverError";
+}
+function buildAudit(url, now, response) {
+  const audit = { url, resolvedAt: now().toISOString() };
+  if (response) {
+    audit.httpStatus = response.status;
+    const retryAfter = parseRetryAfter(response.headers.get("retry-after"), now);
+    if (retryAfter !== undefined) {
+      audit.retryAfterSeconds = retryAfter;
+    }
+  }
+  return audit;
+}
+function parseRetryAfter(header, now) {
+  if (header === null || header.trim() === "") {
+    return;
+  }
+  const seconds = Number(header.trim());
+  if (Number.isInteger(seconds) && seconds >= 0) {
+    return seconds;
+  }
+  const at = Date.parse(header);
+  if (Number.isNaN(at)) {
+    return;
+  }
+  return Math.max(0, Math.round((at - now().getTime()) / 1000));
+}
+function isJsonObject(body) {
+  if (body.trim() === "") {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return false;
+  }
+  return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+}
+function unknown(subject, audit, reason, detail) {
+  return { outcome: "unknown", subject, audit, reason, detail };
+}
+async function readToken(accessToken) {
+  return typeof accessToken === "function" ? await accessToken() : accessToken;
+}
+function isAbortError(error) {
+  const candidate = error instanceof Error && "cause" in error && error.cause instanceof Error ? error.cause : error;
+  return candidate instanceof Error && candidate.name === "AbortError";
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function requireValue(field, value) {
+  if (value === undefined || value === null) {
+    throw new RequiredError(field, `Required option "${field}" is missing.`);
+  }
+}
+function requireText(field, value) {
+  requireValue(field, value);
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new RequiredError(field, `Required option "${field}" must be a non-empty string.`);
+  }
+}
 // ../common/dist/index.js
 import { createRequire } from "node:module";
 import fs from "node:fs";
@@ -7997,7 +9671,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
       this.runningCommand = proc;
     }
-    _dispatchSubcommand(commandName, operands, unknown) {
+    _dispatchSubcommand(commandName, operands, unknown2) {
       const subCommand = this._findCommand(commandName);
       if (!subCommand)
         this.help({ error: true });
@@ -8006,9 +9680,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
       promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, "preSubcommand");
       promiseChain = this._chainOrCall(promiseChain, () => {
         if (subCommand._executableHandler) {
-          this._executeSubCommand(subCommand, operands.concat(unknown));
+          this._executeSubCommand(subCommand, operands.concat(unknown2));
         } else {
-          return subCommand._parseCommand(operands, unknown);
+          return subCommand._parseCommand(operands, unknown2);
         }
       });
       return promiseChain;
@@ -8105,22 +9779,22 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       return result;
     }
-    _parseCommand(operands, unknown) {
-      const parsed = this.parseOptions(unknown);
+    _parseCommand(operands, unknown2) {
+      const parsed = this.parseOptions(unknown2);
       this._parseOptionsEnv();
       this._parseOptionsImplied();
       operands = operands.concat(parsed.operands);
-      unknown = parsed.unknown;
-      this.args = operands.concat(unknown);
+      unknown2 = parsed.unknown;
+      this.args = operands.concat(unknown2);
       if (operands && this._findCommand(operands[0])) {
-        return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
+        return this._dispatchSubcommand(operands[0], operands.slice(1), unknown2);
       }
       if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
         return this._dispatchHelpCommand(operands[1]);
       }
       if (this._defaultCommandName) {
-        this._outputHelpIfRequested(unknown);
-        return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
+        this._outputHelpIfRequested(unknown2);
+        return this._dispatchSubcommand(this._defaultCommandName, operands, unknown2);
       }
       if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
         this.help({ error: true });
@@ -8142,7 +9816,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
         if (this.parent) {
           promiseChain = this._chainOrCall(promiseChain, () => {
-            this.parent.emit(commandEvent, operands, unknown);
+            this.parent.emit(commandEvent, operands, unknown2);
           });
         }
         promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
@@ -8151,13 +9825,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (this.parent?.listenerCount(commandEvent)) {
         checkForUnknownOptions();
         this._processArguments();
-        this.parent.emit(commandEvent, operands, unknown);
+        this.parent.emit(commandEvent, operands, unknown2);
       } else if (operands.length) {
         if (this._findCommand("*")) {
-          return this._dispatchSubcommand("*", operands, unknown);
+          return this._dispatchSubcommand("*", operands, unknown2);
         }
         if (this.listenerCount("command:*")) {
-          this.emit("command:*", operands, unknown);
+          this.emit("command:*", operands, unknown2);
         } else if (this.commands.length) {
           this.unknownCommand();
         } else {
@@ -8212,7 +9886,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     parseOptions(args) {
       const operands = [];
-      const unknown = [];
+      const unknown2 = [];
       let dest = operands;
       function maybeOption(arg) {
         return arg.length > 1 && arg[0] === "-";
@@ -8229,7 +9903,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const arg = activeGroup ?? args[i++];
         activeGroup = null;
         if (arg === "--") {
-          if (dest === unknown)
+          if (dest === unknown2)
             dest.push(arg);
           dest.push(...args.slice(i));
           break;
@@ -8281,18 +9955,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
         }
         if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
-          dest = unknown;
+          dest = unknown2;
         }
-        if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
+        if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown2.length === 0) {
           if (this._findCommand(arg)) {
             operands.push(arg);
-            unknown.push(...args.slice(i));
+            unknown2.push(...args.slice(i));
             break;
           } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
             operands.push(arg, ...args.slice(i));
             break;
           } else if (this._defaultCommandName) {
-            unknown.push(arg, ...args.slice(i));
+            unknown2.push(arg, ...args.slice(i));
             break;
           }
         }
@@ -8302,7 +9976,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         dest.push(arg);
       }
-      return { operands, unknown };
+      return { operands, unknown: unknown2 };
     }
     opts() {
       if (this._storeOptionsAsProperties) {
@@ -9227,7 +10901,7 @@ var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{1
 var EMAIL_PATTERN = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
 var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
 var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
-var PADDED_BASE64_PATTERN = /[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
+var PADDED_BASE64_PATTERN = /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
 var BASE64_WITH_PLUS_PATTERN = /[A-Za-z0-9+/]{40,}/g;
 var USER_HOME_PATTERN = /(?<![A-Za-z0-9._-])([/\\])(Users|home|Profiles)([/\\])([^/\\]+)/gi;
 var UNC_PATH_PATTERN = /(^|[\s"'<>|=,;([{])(\\\\[^\s"'<>|]+)/g;
@@ -9274,7 +10948,7 @@ var QUOTED_LITERAL_PATTERN = new RegExp([
   `(?<![A-Za-z0-9])"(?:[^\\
 ]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?"(?![A-Za-z0-9])`
 ].join("|"), "g");
-var JSON_BODY_PATTERN = /[{[][^{}[\]]*[:,][^{}[\]]*[\]}]/g;
+var JSON_BODY_PATTERN = /[{[][^{}[\]:,]*[:,][^{}[\]]*[\]}]/g;
 var COLLAPSED_BODY = "{…}";
 var COLLAPSED_BODY_MARKER = "\x01body\x01";
 var MAX_BODY_NESTING = 8;
@@ -9289,10 +10963,13 @@ function collapseJsonBodies(text) {
   }
   return out.split(COLLAPSED_BODY_MARKER).join(COLLAPSED_BODY);
 }
-var TRAILING_PROSE_PUNCT = /[.,;:!?)\]}>'"]+$/;
+var TRAILING_PROSE_PUNCT = `.,;:!?)]}>'"`;
 function peelTrailingPunctuation(match) {
-  const trailing = match.match(TRAILING_PROSE_PUNCT)?.[0] ?? "";
-  return trailing ? [match.slice(0, -trailing.length), trailing] : [match, ""];
+  let end = match.length;
+  while (end > 0 && TRAILING_PROSE_PUNCT.includes(match[end - 1])) {
+    end -= 1;
+  }
+  return [match.slice(0, end), match.slice(end)];
 }
 function redactUrl(raw) {
   try {
@@ -9500,6 +11177,12 @@ var TLS_ERROR_CODES = new Set([
 var TLS_INSTRUCTIONS = "The server's TLS certificate could not be verified. Most often a " + "corporate proxy/firewall re-signs HTTPS with a root CA that Node does " + "not trust — set NODE_EXTRA_CA_CERTS to that CA's PEM file (and HTTPS_PROXY " + "if you connect through a proxy). If the certificate is instead expired or " + "its hostname does not match, fix the endpoint URL or the system clock. " + "Then retry.";
 var NETWORK_INSTRUCTIONS = "Could not reach the UiPath service. Check your network connection and " + "VPN, confirm any HTTP_PROXY/HTTPS_PROXY/NO_PROXY settings are correct, " + "then retry.";
 var LOCAL_PERMISSION_ERROR_CODES = new Set(["EACCES", "EPERM", "EROFS"]);
+function carriedInstructions(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const e = error;
+  return typeof e.instructions === "string" ? e.instructions : undefined;
+}
 function setExitCode(code) {
   process.exitCode = code;
 }
@@ -9981,7 +11664,8 @@ function readRegistryValue(keyPath, valueName) {
   }
   const [error, output] = catchError(() => execFileSync2("reg", ["query", keyPath, "/v", valueName], {
     encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true
   }));
   if (error) {
     return "";
@@ -10634,28 +12318,32 @@ function isPlainRecord(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function extractPagedRows(value) {
+function splitPagedEnvelope(value) {
   if (Array.isArray(value) || !isPlainRecord(value))
     return null;
-  const entries = Object.values(value);
+  const entries = Object.entries(value);
   if (entries.length === 0)
     return null;
-  let rows = null;
-  let hasScalarSibling = false;
-  for (const entry of entries) {
+  let found = null;
+  const meta = Object.create(null);
+  for (const [key, entry] of entries) {
     if (Array.isArray(entry)) {
-      if (rows !== null)
+      if (found !== null)
         return null;
-      rows = entry;
+      found = { key, rows: entry };
     } else if (entry !== null && typeof entry === "object") {
       return null;
     } else {
-      hasScalarSibling = true;
+      meta[key] = entry;
     }
   }
-  if (rows === null || !hasScalarSibling)
+  if (found === null || Object.keys(meta).length === 0)
     return null;
-  return rows;
+  return { ...found, meta };
+}
+function extractPagedRows(value) {
+  const paged = splitPagedEnvelope(value);
+  return paged === null ? null : paged.rows;
 }
 function toLowerCamelCaseKey(key) {
   if (!key)
@@ -10759,6 +12447,9 @@ function printOutput(data, format = "json", logFn, asciiSafe = false, tableRowSt
       }
       break;
     }
+    case "markdown":
+      logFn(renderMarkdown(data));
+      break;
     default: {
       const hasData = "Data" in data && data.Data != null;
       const pagedRows = hasData ? extractPagedRows(data.Data) : null;
@@ -10783,6 +12474,10 @@ function logOutput(data, format = "json", tableRowStyle) {
   printOutput(data, format, (msg) => sink.writeOut(`${msg}
 `), needsAsciiSafeJson(sink), styleFn);
 }
+var PLUMBING_KEYS = new Set(["code", "log"]);
+function isPlumbingKey(key) {
+  return PLUMBING_KEYS.has(key.toLowerCase());
+}
 function cellToString(val) {
   return val != null && typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
 }
@@ -10798,7 +12493,7 @@ function wrapText(text, width) {
 function printTable(data, logFn, externalLogValue, tableRowStyle) {
   if (data.length === 0)
     return;
-  const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data[0]).filter((key) => !isPlumbingKey(key));
   const maxWidths = keys.map((key) => Math.max(key.length, ...data.map((item) => cellToString(item[key]).length)));
   const header = keys.map((key, i) => key.padEnd(maxWidths[i])).join(" | ");
   logFn(header);
@@ -10820,7 +12515,7 @@ function isNonEmptyPlainObject(value) {
 }
 var NESTED_INDENT = "  ";
 function printVerticalTable(data, logFn = console.log, externalLogValue) {
-  const keys = Object.keys(data).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data).filter((key) => !isPlumbingKey(key));
   if (keys.length === 0)
     return;
   const isBlockValue = (value) => isPlainObjectArray(value) || isNonEmptyPlainObject(value);
@@ -10851,7 +12546,7 @@ function printVerticalTable(data, logFn = console.log, externalLogValue) {
 function printResizableTable(data, logFn = console.log, externalLogValue, availableWidth, tableRowStyle) {
   if (data.length === 0)
     return;
-  const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data[0]).filter((key) => !isPlumbingKey(key));
   if (keys.length === 0)
     return;
   if (!process.stdout.isTTY) {
@@ -10925,6 +12620,220 @@ function printResizableTable(data, logFn = console.log, externalLogValue, availa
     logFn(`Log: ${externalLogValue}`);
   }
 }
+var MARKDOWN_MAX_CELL = 200;
+var MARKDOWN_MAX_DEPTH = 3;
+function markdownHeading(depth) {
+  return "#".repeat(Math.min(3 + depth, 6));
+}
+var BACKTICK_RUN = /`+/g;
+function fencedBlock(text) {
+  const first = text.trimStart()[0];
+  const language = first === "<" ? "xml" : first === "{" || first === "[" ? "json" : "";
+  const longestRun = Math.max(0, ...Array.from(text.matchAll(BACKTICK_RUN), (match) => match[0].length));
+  const fence = "`".repeat(Math.max(3, longestRun + 1));
+  return `${fence}${language}
+${text}
+${fence}`;
+}
+function collapseNewlineRuns(text) {
+  return text.split(/(\s+)/).map((part, index) => index % 2 === 1 && part.includes(`
+`) ? " " : part).join("");
+}
+function markdownCell(value) {
+  const text = value instanceof Date ? value.toISOString() : cellToString(value);
+  return collapseNewlineRuns(text).replace(/\|/g, "\\|");
+}
+function markdownLabel(key) {
+  return collapseNewlineRuns(key).replace(/[\\`*|]/g, "\\$&");
+}
+function withoutPlumbing(record) {
+  const kept = Object.create(null);
+  for (const [key, value] of Object.entries(record)) {
+    if (!isPlumbingKey(key))
+      kept[key] = value;
+  }
+  return kept;
+}
+function rowsWithoutPlumbing(rows) {
+  return rows.map((row) => isPlainRecord(row) ? withoutPlumbing(row) : row);
+}
+function markdownTable(rows) {
+  const columns = [];
+  const seen = new Set;
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        columns.push(key);
+      }
+    }
+  }
+  if (columns.length === 0)
+    return null;
+  const cells = rows.map((row) => columns.map((key) => markdownCell(row[key])));
+  if (cells.some((row) => row.some((c) => c.length > MARKDOWN_MAX_CELL))) {
+    return null;
+  }
+  return [
+    `| ${columns.map(markdownLabel).join(" | ")} |`,
+    `| ${columns.map(() => "---").join(" | ")} |`,
+    ...cells.map((row) => `| ${row.join(" | ")} |`)
+  ].join(`
+`);
+}
+function extractMessageSequence(rows) {
+  const messages = [];
+  for (const row of rows) {
+    const message = extractSingleMessage(row);
+    if (message === null)
+      return null;
+    messages.push(message);
+  }
+  return messages.join(`
+
+`);
+}
+function markdownRows(rows, depth) {
+  if (rows.length === 0)
+    return "(none)";
+  if (!isPlainObjectArray(rows)) {
+    return rows.map((item) => `- ${markdownCell(item)}`).join(`
+`);
+  }
+  const prose = extractMessageSequence(rows);
+  if (prose !== null)
+    return prose;
+  const table = markdownTable(rows);
+  if (table !== null)
+    return table;
+  if (depth >= MARKDOWN_MAX_DEPTH) {
+    return fencedBlock(JSON.stringify(rows, null, 2));
+  }
+  return rows.map((row, index) => [
+    `${markdownHeading(depth)} ${index + 1}`,
+    markdownObject(row, depth + 1)
+  ].join(`
+
+`)).join(`
+
+`);
+}
+function markdownObject(obj, depth) {
+  const scalars = [];
+  const blocks = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined)
+      continue;
+    const label = markdownLabel(key);
+    if (Array.isArray(value)) {
+      blocks.push(`${markdownHeading(depth)} ${label}
+
+${markdownRows(value, depth + 1)}`);
+    } else if (isNonEmptyPlainObject(value)) {
+      const nested = depth < MARKDOWN_MAX_DEPTH ? markdownObject(value, depth + 1) : fencedBlock(JSON.stringify(value, null, 2));
+      if (nested !== "") {
+        blocks.push(`${markdownHeading(depth)} ${label}
+
+${nested}`);
+      }
+    } else if (typeof value === "string" && value.includes(`
+`)) {
+      blocks.push(`**${label}:**
+
+${fencedBlock(value)}`);
+    } else {
+      scalars.push(`**${label}:** ${markdownCell(value)}`);
+    }
+  }
+  const sections = scalars.length > 0 ? [scalars.join(`
+`)] : [];
+  sections.push(...blocks);
+  return sections.join(`
+
+`);
+}
+function extractSingleMessage(payload) {
+  if (!isPlainRecord(payload))
+    return null;
+  const keys = Object.keys(payload);
+  if (keys.length !== 1 || keys[0].toLowerCase() !== "message")
+    return null;
+  const value = payload[keys[0]];
+  return typeof value === "string" ? value : null;
+}
+function markdownPayload(payload) {
+  const message = extractSingleMessage(payload);
+  if (message !== null)
+    return message;
+  if (Array.isArray(payload)) {
+    return markdownRows(rowsWithoutPlumbing(payload), 0);
+  }
+  const visible = withoutPlumbing(payload);
+  const paged = splitPagedEnvelope(visible);
+  if (paged !== null) {
+    const meta = markdownObject(paged.meta, 0);
+    const rows = `${markdownHeading(0)} ${markdownLabel(paged.key)}
+
+${markdownRows(rowsWithoutPlumbing(paged.rows), 1)}`;
+    return meta === "" ? rows : `${meta}
+
+${rows}`;
+  }
+  return markdownObject(visible, 0);
+}
+function isPaginationWorthShowing(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const page = value;
+  return page.HasMore === true || typeof page.Offset === "number" && page.Offset > 0;
+}
+function markdownEnvelopeNotes(data) {
+  const envelope = data;
+  const notes = [];
+  const warning = envelope.Warning;
+  if (typeof warning === "string" && warning !== "") {
+    notes.push(`> **Warning:** ${warning}`);
+  }
+  const instructions = envelope.Instructions;
+  if (typeof instructions === "string" && instructions !== "") {
+    notes.push(`> ${instructions}`);
+  }
+  const pagination = envelope.Pagination;
+  if (isPaginationWorthShowing(pagination)) {
+    const body = markdownObject(pagination, 1);
+    if (body !== "") {
+      notes.push(`${markdownHeading(0)} Pagination
+
+${body}`);
+    }
+  }
+  const log = envelope.Log;
+  if (typeof log === "string" && log !== "") {
+    notes.push(`**Log:** ${log}`);
+  }
+  return notes;
+}
+function renderMarkdown(data) {
+  if (data.Result !== RESULTS.Success) {
+    const failure = data;
+    const sections = [`**Failed:** ${failure.Message}`];
+    if (failure.Data != null) {
+      sections.push(markdownPayload(failure.Data));
+    }
+    if (failure.Instructions) {
+      sections.push(`> ${failure.Instructions}`);
+    }
+    return sections.filter((section) => section !== "").join(`
+
+`);
+  }
+  if (!("Data" in data) || data.Data == null) {
+    return markdownObject(withoutPlumbing(data), 0);
+  }
+  return [markdownPayload(data.Data), ...markdownEnvelopeNotes(data)].filter((section) => section !== "").join(`
+
+`);
+}
 function toYaml(data) {
   const codec = getYamlCodec();
   if (!codec) {
@@ -12246,8 +14155,9 @@ function addSdkUserAgentHeader(headers, userAgent) {
 // ../packager/project-packager/package.json
 var package_default = {
   name: "@uipath/project-packager",
+  author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.0-preview.161",
+  version: "1.203.0-preview.160",
   description: "UiPath Project Packager - core library for packing individual UiPath projects",
   type: "module",
   main: "./dist/index.js",
@@ -12292,6 +14202,7 @@ var package_default = {
     lint: "biome check ."
   },
   dependencies: {
+    "@uipath/aops-policy-sdk": "workspace:*",
     "@uipath/filesystem": "workspace:*",
     "@uipath/solutionpackager-tool-core": "workspace:*",
     "@uipath/common": "workspace:*"
@@ -12301,7 +14212,7 @@ var package_default = {
   },
   devDependencies: {
     "@types/node": "^25.5.2",
-    "@uipath/resource-builder-tool": "1.0.0-s202-16635",
+    "@uipath/resource-builder-tool": "2025.11.0-alpha4535-3530",
     "@uipath/tool-agent": "^2.0.0",
     "@uipath/packager-tool-apiworkflow": "workspace:*",
     "@uipath/packager-tool-connector": "workspace:*",
@@ -12650,6 +14561,14 @@ class ProjectPublisher {
   }
 }
 // ../packager/project-packager/src/services/governance-policy-service.ts
+class GovernancePolicyError extends Error {
+  instructions;
+  name = "GovernancePolicyError";
+  constructor(message, instructions) {
+    super(message);
+    this.instructions = instructions;
+  }
+}
 var LICENSE_TYPES = {
   NoLicense: "NoLicense",
   Development: "Development",
@@ -12659,7 +14578,7 @@ var LICENSE_TYPES = {
   StudioPro: "StudioPro",
   AutomationKit: "AutomationKit"
 };
-var DEFAULT_PROFILE_KEY = "StudioWeb";
+var STUDIOWEB_PRODUCT = "StudioWeb";
 var ACQUIRE_LICENSE_PATH = "/orchestrator_/api/StudioWeb/AcquireLicense";
 var GOVERNANCE_SUBFOLDER = "governance";
 var GOVERNANCE_FILE_NAME = "governance-policy.json";
@@ -12676,87 +14595,122 @@ class GovernancePolicyService {
     this.temporaryStorage = temporaryStorage;
     this.fetchFn = fetchFn;
   }
-  async resolveGovernancePolicyAsync(validateOptions, connectionInfo, cancellationToken) {
-    if (validateOptions.governanceFileType !== "AutomationOps" /* AutomationOps */) {
+  async resolveGovernancePolicyAsync(validateOptions, connectionInfo, cancellationToken, usage = "pack") {
+    if (validateOptions.governanceFileType === "Default" /* Default */) {
       return;
     }
-    if (validateOptions.governanceFilePath) {
+    const suppliedFilePath = validateOptions.governanceFilePath;
+    if (suppliedFilePath && validateOptions.governanceFileType === "AutomationOps" /* AutomationOps */) {
       this.logger.info(t("info.alreadyProvided"));
       return;
     }
-    let cloudUrl = connectionInfo?.cloudUrl;
-    const organizationId = connectionInfo?.organizationId;
-    const tenantId = connectionInfo?.tenantId;
-    const accessToken = connectionInfo?.accessToken;
-    if (!cloudUrl || !organizationId || !tenantId || !accessToken) {
-      this.logger.warn(t("errors.connectionIncomplete"));
-      validateOptions.governanceFileType = "Default" /* Default */;
+    if (suppliedFilePath && usage === "analyze") {
+      this.logger.info(t("info.alreadyProvided"));
+      validateOptions.governanceFileType = "Studio" /* Studio */;
       return;
     }
-    const profileKey = validateOptions.profileKey ?? DEFAULT_PROFILE_KEY;
-    let cloudOrigin;
-    try {
-      cloudOrigin = new URL(cloudUrl).origin;
-      cloudUrl = cloudUrl.replace(/\/+$/, "");
-    } catch {
-      this.logger.warn(t("errors.connectionIncomplete"));
-      validateOptions.governanceFileType = "Default" /* Default */;
+    const origin = this.resolveCloudOrigin(connectionInfo?.cloudUrl);
+    const product = validateOptions.profileKey;
+    if (!origin || !product || !connectionInfo?.organizationId || !connectionInfo.tenantId || !connectionInfo.accessToken) {
+      if (suppliedFilePath) {
+        this.logger.info(t("info.noTenantToAsk", { path: suppliedFilePath }));
+        validateOptions.governanceFileType = "Studio" /* Studio */;
+        return;
+      }
+      this.warnAndUseShippedRules(validateOptions, t("errors.connectionIncomplete"));
       return;
     }
-    const licenseType = await this.resolveLicenseTypeAsync(profileKey, cloudUrl, accessToken, cancellationToken);
-    const policy = await this.downloadPolicyAsync(cloudOrigin, organizationId, tenantId, accessToken, licenseType, profileKey, cancellationToken);
-    if (!policy) {
-      validateOptions.governanceFileType = "Default" /* Default */;
-      return;
+    const licenseType = await this.resolveLicenseTypeAsync(product, connectionInfo.cloudUrl?.replace(/\/+$/, "") ?? "", connectionInfo.accessToken, cancellationToken);
+    const subject = {
+      organizationId: connectionInfo.organizationId,
+      tenantId: connectionInfo.tenantId,
+      product,
+      licenseType
+    };
+    this.logger.info(t("info.resolving", { product, licenseType }));
+    const resolution = await resolvePolicyAsync({
+      subject,
+      baseUrl: origin,
+      accessToken: connectionInfo.accessToken,
+      clientVersion: package_default.version,
+      fetch: this.fetchFn,
+      signal: cancellationToken
+    });
+    await this.applyResolutionAsync(resolution, validateOptions, suppliedFilePath);
+  }
+  async applyResolutionAsync(resolution, validateOptions, suppliedFilePath) {
+    switch (resolution.outcome) {
+      case "governed":
+        if (suppliedFilePath) {
+          throw new GovernancePolicyError(t("errors.tenantPolicyWins", {
+            product: resolution.subject.product,
+            path: suppliedFilePath
+          }), t("instructions.tenantPolicyWins"));
+        }
+        await this.savePolicyAsync(validateOptions, resolution.document);
+        return;
+      case "ungoverned":
+        if (suppliedFilePath) {
+          this.logger.info(t("info.suppliedFileHonoured", {
+            path: suppliedFilePath
+          }));
+          validateOptions.governanceFileType = "Studio" /* Studio */;
+          return;
+        }
+        this.logger.info(t("info.ungoverned"));
+        validateOptions.governanceFileType = "Default" /* Default */;
+        return;
+      case "unknown": {
+        this.logger.warn(this.describeUnknown(resolution));
+        if (suppliedFilePath) {
+          this.logger.info(t("info.suppliedFileUnchecked", {
+            path: suppliedFilePath
+          }));
+          validateOptions.governanceFileType = "Studio" /* Studio */;
+          return;
+        }
+        validateOptions.governanceFileType = "Default" /* Default */;
+        return;
+      }
     }
+  }
+  async savePolicyAsync(validateOptions, document) {
     try {
       const dir = await this.temporaryStorage.getTempSubfolderPathAsync(GOVERNANCE_SUBFOLDER);
       const filePath = Path.join(dir, GOVERNANCE_FILE_NAME);
-      await this.fileSystem.writeFile(filePath, policy);
+      await this.fileSystem.writeFile(filePath, document);
       this.logger.info(t("info.saved", { path: filePath }));
       validateOptions.governanceFilePath = filePath;
+      validateOptions.governanceFileType = "AutomationOps" /* AutomationOps */;
     } catch (error) {
-      this.logger.warn(t("errors.failedToSave", {
-        error: errorMessage(error)
-      }));
-      validateOptions.governanceFileType = "Default" /* Default */;
+      this.warnAndUseShippedRules(validateOptions, t("errors.failedToSave", { error: errorMessage(error) }));
     }
   }
-  async downloadPolicyAsync(cloudOrigin, organizationId, tenantId, accessToken, licenseType, profileKey, cancellationToken) {
-    const policyUrl = `${cloudOrigin}/${organizationId}/roboticsops_` + `/api/Policy/license/${licenseType}/product/${profileKey}/tenant/${tenantId}`;
-    this.logger.info(t("info.downloading", { url: policyUrl }));
+  warnAndUseShippedRules(validateOptions, reason) {
+    this.logger.warn(t("errors.fallingBackToDefault", { reason }));
+    validateOptions.governanceFileType = "Default" /* Default */;
+  }
+  describeUnknown(resolution) {
+    const reason = t("errors.unknownOutcome", {
+      reason: resolution.reason,
+      detail: resolution.detail,
+      url: resolution.audit.url
+    });
+    const retryAfter = resolution.audit.retryAfterSeconds;
+    return retryAfter === undefined ? reason : `${reason} ${t("errors.retryAfter", { seconds: retryAfter })}`;
+  }
+  resolveCloudOrigin(cloudUrl) {
+    if (!cloudUrl) {
+      return null;
+    }
     try {
-      const response = await this.fetchFn(policyUrl, {
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          AccountId: organizationId
-        },
-        signal: cancellationToken
-      });
-      if (response.status === 204 || response.status === 404) {
-        this.logger.info(t("info.noPolicyFound"));
-        return null;
-      }
-      if (!response.ok) {
-        const body = await response.text();
-        this.logger.warn(t("errors.failedToGetPolicy", { content: body }));
-        return null;
-      }
-      const content = await response.text();
-      if (!content?.trimStart().startsWith("{")) {
-        this.logger.info(t("info.responseNotJson"));
-        return null;
-      }
-      return content;
-    } catch (error) {
-      this.logger.warn(t("errors.failedToDownload", {
-        error: errorMessage(error)
-      }));
+      return new URL(cloudUrl).origin;
+    } catch {
       return null;
     }
   }
   async resolveLicenseTypeAsync(profileKey, cloudUrl, accessToken, cancellationToken) {
-    const isStudioWeb = profileKey === DEFAULT_PROFILE_KEY;
+    const isStudioWeb = profileKey === STUDIOWEB_PRODUCT;
     const fallback = isStudioWeb ? LICENSE_TYPES.NoLicense : LICENSE_TYPES.Development;
     try {
       const response = await this.fetchFn(`${cloudUrl}${ACQUIRE_LICENSE_PATH}`, {
@@ -12812,6 +14766,11 @@ async function resolveProducedNupkgsAsync(fileSystem, packagePath) {
   return [];
 }
 // ../packager/project-packager/src/services/pack-service.ts
+var PACKAGE_ID_TOO_LONG = "PACKAGE_ID_TOO_LONG";
+function isPackageIdTooLongError(error) {
+  return error instanceof Error && error.code === PACKAGE_ID_TOO_LONG;
+}
+
 class PackService {
   disallowedCharsRegex = /[^\p{L}\p{N}_.-]/gu;
   spacesDotRegex = /[\s.]+/g;
@@ -12823,7 +14782,11 @@ class PackService {
     packageId = packageId.replace(this.dotDashRegex, "-");
     packageId = packageId.replace(this.disallowedCharsRegex, "_");
     if (packageId.length > this.MaxPackageIdLength) {
-      throw new Error(`Package id ${packageId} exceeds the characters limit of ${this.MaxPackageIdLength}`);
+      const error = new Error(`Package id ${packageId} exceeds the characters limit of ${this.MaxPackageIdLength}`);
+      error.code = PACKAGE_ID_TOO_LONG;
+      error.packageId = packageId;
+      error.maxLength = this.MaxPackageIdLength;
+      throw error;
     }
     return packageId;
   }
@@ -13261,7 +15224,7 @@ class ProjectPackager {
     }, cancellationToken);
   }
   async validateProjectAsync(options, cancellationToken) {
-    await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+    await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken, "analyze");
     const validationResult = await this.validateOptionsValidator.validateAsync(options, cancellationToken);
     if (!validationResult.isSuccess) {
       return validationResult;
@@ -13285,7 +15248,10 @@ class ProjectPackager {
     }, cancellationToken);
   }
   async buildProjectAsync(options, cancellationToken) {
-    await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+    const [governanceError] = await catchError(this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken));
+    if (governanceError) {
+      return ToolResult.error(ToolErrorCodes.InternalError, `Project build failed: ${governanceError.message}`, carriedInstructions(governanceError));
+    }
     const validationResult = await this.buildOptionsValidator.validateAsync(options, cancellationToken);
     if (!validationResult.isSuccess) {
       return validationResult;
@@ -13352,7 +15318,7 @@ class ProjectPackager {
       } catch (error) {
         const errorMessage2 = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage2}`);
-        return ToolResult.error(ToolErrorCodes.InternalError, `Project pack failed: ${errorMessage2}`);
+        return ToolResult.error(ToolErrorCodes.InternalError, `Project pack failed: ${errorMessage2}`, carriedInstructions(error));
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -13474,7 +15440,9 @@ class ProjectPackager {
 export {
   BrowserContextStorage,
   ConsoleTelemetryProvider,
+  GovernancePolicyError,
   GovernancePolicyService,
+  PACKAGE_ID_TOO_LONG,
   PackService,
   PackagerParameters,
   PackagerParametersValidator,
@@ -13496,9 +15464,11 @@ export {
   TelemetryService,
   ToolLogger,
   ToolsFactory,
+  isPackageIdTooLongError,
+  resolvePolicyAsync,
   resolveProducedNupkgsAsync,
   setGlobalLogHandler,
   signNupkgsAsync
 };
 
-//# debugId=D7E9D71FAAA7198F64756E2164756E21
+//# debugId=0B08B05B544EE1BB64756E2164756E21