@uipath/flow-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/node-6p3nx3y1.js

@@ -0,0 +1,4823 @@
+import {
+  I18nManager,
+  LogMessage,
+  NugetPackager,
+  Path,
+  ProjectTool,
+  TemporaryStorageService,
+  ToolResult,
+  ZipService,
+  normalizeIgnoredRules,
+  toolsFactoryRepository,
+  translate
+} from "./packager-tool-stq8800d.js";
+import"./packager-tool-nkrmjr3a.js";
+import {
+  ConsoleTelemetryProvider,
+  DebugTelemetryProvider,
+  NodeContextStorage,
+  PackagerDimensions,
+  TelemetryService,
+  addSdkUserAgentHeader,
+  carriedInstructions,
+  catchError
+} from "./packager-tool-r7xy9sew.js";
+import {
+  NodeFileSystem
+} from "./packager-tool-3h2ktz6q.js";
+import"./packager-tool-1yh8g550.js";
+// ../packager/project-packager/src/i18n/locales/de.json
+var de_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+
+// ../packager/project-packager/src/i18n/locales/en.ts
+var en = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/es.json
+var es_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/es-MX.json
+var es_MX_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/fr.json
+var fr_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/ja.json
+var ja_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/ko.json
+var ko_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/pt.json
+var pt_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/pt-BR.json
+var pt_BR_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/ro.json
+var ro_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/ru.json
+var ru_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/tr.json
+var tr_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/zh-CN.json
+var zh_CN_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/zh-TW.json
+var zh_TW_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// ../packager/project-packager/src/i18n/locales/zu.json
+var zu_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile}, {projectJsonFile}, or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        destinationInsideProject: "Destination path '{destinationPath}' is inside the project directory '{projectPath}'.",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}",
+        destinationInsideProjectInstruction: "Choose a destination outside the project directory. A package written inside the project would be swallowed into the next pack's content."
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        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 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} governs this tenant, so the governance file at {path} is not used.",
+        ignoredRulesNotApplied: "The AutomationOps policy published for {product} governs this tenant, so --ignored-rules is not applied and every rule the policy enforces stays enforced. Ignored: {rules}",
+        defaultOverridden: "The AutomationOps policy published for {product} governs this tenant, so it is used instead of the rules shipped with the WorkflowCompiler.",
+        failedToSave: "Failed to save governance policy: {error}",
+        fallingBackToDefault: "{reason} Analyzing with the rules shipped with the WorkflowCompiler."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+
+// ../packager/project-packager/src/i18n/index.ts
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de_default);
+I18nManager.registerTranslations("es", es_default);
+I18nManager.registerTranslations("es-MX", es_MX_default);
+I18nManager.registerTranslations("fr", fr_default);
+I18nManager.registerTranslations("ja", ja_default);
+I18nManager.registerTranslations("ko", ko_default);
+I18nManager.registerTranslations("pt", pt_default);
+I18nManager.registerTranslations("pt-BR", pt_BR_default);
+I18nManager.registerTranslations("ro", ro_default);
+I18nManager.registerTranslations("ru", ru_default);
+I18nManager.registerTranslations("tr", tr_default);
+I18nManager.registerTranslations("zh-CN", zh_CN_default);
+I18nManager.registerTranslations("zh-TW", zh_TW_default);
+I18nManager.registerTranslations("zu", zu_default);
+// ../packager/project-packager/src/services/tool-logger.ts
+var globalLogHandler = (logMessage) => {
+  const formattedMessage = logMessage.toFormattedString();
+  switch (logMessage.logLevel) {
+    case "Debug" /* Debug */:
+      console.debug(formattedMessage);
+      break;
+    case "Information" /* Info */:
+      console.info(formattedMessage);
+      break;
+    case "Warning" /* Warn */:
+      console.warn(formattedMessage);
+      break;
+    case "Error" /* Error */:
+      console.error(formattedMessage);
+      break;
+  }
+};
+function setGlobalLogHandler(handler) {
+  globalLogHandler = handler;
+}
+
+class ToolLogger {
+  source;
+  sourceTarget;
+  constructor(source, sourceTarget) {
+    this.source = source;
+    this.sourceTarget = sourceTarget;
+  }
+  debug(message, options) {
+    const logMessage = new LogMessage(message, "Debug" /* Debug */, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  info(message, options) {
+    const logMessage = new LogMessage(message, "Information" /* Info */, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  warn(message, options) {
+    const logMessage = new LogMessage(message, "Warning" /* Warn */, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  error(message, options) {
+    const logMessage = new LogMessage(message, "Error" /* Error */, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  progress(message, options) {
+    const logMessage = new LogMessage(message, "Information" /* Info */, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  log(message, logLevel, options) {
+    const logMessage = new LogMessage(message, logLevel, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  logMessage(message) {
+    globalLogHandler(message);
+  }
+}
+
+// ../packager/project-packager/src/base-node-packager-factory.ts
+class BaseNodePackagerFactory {
+  dotnetDiscovery;
+  getOrCreateFileSystem(config) {
+    return config?.fileSystem ?? new NodeFileSystem;
+  }
+  getOrCreateTelemetryService(config) {
+    if (config?.telemetryService) {
+      return config.telemetryService;
+    }
+    const provider = new DebugTelemetryProvider;
+    const contextStorage = new NodeContextStorage;
+    return new TelemetryService(provider, contextStorage);
+  }
+  checkDotnetAvailability(logger) {
+    if (!this.dotnetDiscovery) {
+      return;
+    }
+    const version = this.dotnetDiscovery.getDotnetVersion();
+    if (version) {
+      logger.info(translate.t("solutionpackager.dotnet.info.available", {
+        version
+      }));
+    } else {
+      logger.warn(translate.t("solutionpackager.dotnet.warnings.notAvailable"));
+    }
+  }
+  configureLogHandler(config) {
+    if (config?.logHandler) {
+      setGlobalLogHandler(config.logHandler);
+    }
+  }
+  configureLanguage(config) {
+    const language = config?.language ?? "en";
+    translate.setLocale(language);
+  }
+}
+// ../packager/project-packager/src/models/packager-parameters.ts
+var RulesConfigFileType;
+((RulesConfigFileType2) => {
+  RulesConfigFileType2["Default"] = "Default";
+  RulesConfigFileType2["AutomationOps"] = "AutomationOps";
+  RulesConfigFileType2["Studio"] = "Studio";
+})(RulesConfigFileType ||= {});
+
+class PackagerParameters {
+  inputPath;
+  downloadUrl;
+  projectId;
+  logLevel = "Warning" /* Warn */;
+  outputPath;
+  targetFramework;
+  excludeConfiguredSources = false;
+  nuGetSourcesConfigPath;
+  feedFolder;
+  detailedLogPath;
+  connection;
+  workflowCompilerVersion;
+}
+// ../packager/project-packager/src/models/project-restore-options.ts
+class ProjectRestoreOptions extends PackagerParameters {
+}
+
+// ../packager/project-packager/src/models/project-validate-options.ts
+class ProjectValidateOptions extends ProjectRestoreOptions {
+  validateOptions = {
+    skipAnalyze: false,
+    skipValidate: false,
+    governanceFileType: "Default" /* Default */
+  };
+}
+
+// ../packager/project-packager/src/models/project-build-options.ts
+class ProjectBuildOptions extends ProjectValidateOptions {
+  outputType;
+}
+// ../packager/project-packager/src/models/project-cleanup-options.ts
+class ProjectCleanupOptions extends PackagerParameters {
+  dryRun = false;
+  skipImports = false;
+  lockKey;
+}
+// ../packager/project-packager/src/models/project-pack-options.ts
+class ProjectPackOptions extends ProjectBuildOptions {
+  destinationPath;
+  package;
+  signingInfo;
+  packOptions;
+}
+// ../packager/project-packager/src/services/dotnet-discovery-service.ts
+import { execSync } from "node:child_process";
+
+class DotnetDiscoveryService {
+  cachedVersion;
+  isDotnetAvailable() {
+    return this.getDotnetVersion() !== undefined;
+  }
+  getDotnetVersion() {
+    if (this.cachedVersion !== undefined) {
+      return this.cachedVersion;
+    }
+    try {
+      const output = execSync("dotnet --version", {
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf-8"
+      });
+      this.cachedVersion = output.trim();
+      return this.cachedVersion;
+    } catch {
+      return;
+    }
+  }
+}
+
+// ../packager/project-packager/src/services/package-sign-service.ts
+import { spawn } from "node:child_process";
+class NodePackageSignService {
+  dotnetDiscovery;
+  logger;
+  constructor(dotnetDiscovery, logger) {
+    this.dotnetDiscovery = dotnetDiscovery;
+    this.logger = logger;
+  }
+  async signPackageAsync(packagePath, certificatePath, certificatePassword, timestampServer) {
+    return this.signPackagesAsync([packagePath], certificatePath, certificatePassword, timestampServer);
+  }
+  async signPackagesAsync(packagePaths, certificatePath, certificatePassword, timestampServer) {
+    if (packagePaths.length === 0) {
+      return ToolResult.success();
+    }
+    if (!this.dotnetDiscovery.isDotnetAvailable()) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.signing.errors.dotnetNotAvailable"));
+    }
+    const args = [
+      "nuget",
+      "sign",
+      ...packagePaths,
+      "--certificate-path",
+      certificatePath,
+      "--overwrite"
+    ];
+    if (certificatePassword) {
+      args.push("--certificate-password", certificatePassword);
+    }
+    if (timestampServer) {
+      args.push("--timestamper", timestampServer);
+    }
+    return new Promise((resolve) => {
+      const childProcess = spawn("dotnet", args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+        windowsHide: true
+      });
+      let stderr = "";
+      childProcess.stdout?.on("data", (data) => {
+        this.logger.info(data.toString().trim());
+      });
+      childProcess.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      childProcess.on("error", (error) => {
+        this.logger.error(`Failed to start dotnet process: ${error.message}`);
+        resolve(ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Failed to start dotnet process: ${error.message}`));
+      });
+      childProcess.on("exit", (code) => {
+        if (code === 0) {
+          this.logger.info(`Successfully signed packages: ${packagePaths.join(", ")}`);
+          resolve(ToolResult.success());
+        } else {
+          const errorMessage = stderr.trim() || `dotnet nuget sign exited with code ${code}`;
+          this.logger.error(`Package signing failed: ${errorMessage}`);
+          resolve(ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Package signing failed: ${errorMessage}`));
+        }
+      });
+    });
+  }
+}
+// ../packager/project-packager/src/telemetry-names.ts
+var TelemetryNames;
+((TelemetryNames2) => {
+  TelemetryNames2["ProjectToolPack"] = "ProjectPackager.Tool.Pack";
+  TelemetryNames2["ProjectToolRestore"] = "ProjectPackager.Tool.Restore";
+  TelemetryNames2["ProjectToolValidate"] = "ProjectPackager.Tool.Validate";
+  TelemetryNames2["ProjectToolBuild"] = "ProjectPackager.Tool.Build";
+  TelemetryNames2["ProjectToolCleanup"] = "ProjectPackager.Tool.Cleanup";
+  TelemetryNames2["ProjectPackagerPack"] = "ProjectPackager.Pack";
+  TelemetryNames2["ProjectPackagerRestore"] = "ProjectPackager.Restore";
+  TelemetryNames2["ProjectPackagerValidate"] = "ProjectPackager.Validate";
+  TelemetryNames2["ProjectPackagerBuild"] = "ProjectPackager.Build";
+  TelemetryNames2["ProjectPackagerCleanup"] = "ProjectPackager.Cleanup";
+  TelemetryNames2["ProjectPackagerProjectLoaded"] = "ProjectPackager.ProjectLoaded";
+})(TelemetryNames ||= {});
+
+// ../gov/aops-policy-sdk/generated/src/runtime.ts
+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();
+  }
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/ProductDto.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/GlobalPolicyDto.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/CreateGlobalPolicyWithFormDataRequest.ts
+function CreateGlobalPolicyWithFormDataRequestToJSON(json) {
+  return CreateGlobalPolicyWithFormDataRequestToJSONTyped(json, false);
+}
+function CreateGlobalPolicyWithFormDataRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    globalPolicy: GlobalPolicyDtoToJSON(value["globalPolicy"])
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/CreatePolicyRequest.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/FormDataDto.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/PolicyDto.ts
+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"])
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/CreatePolicyWithFormDataRequest.ts
+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"])
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/DeployedPolicyDto.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/DeployedPolicyWithoutUserDto.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/DeploymentLevel.ts
+function DeploymentLevelFromJSON(json) {
+  return DeploymentLevelFromJSONTyped(json, false);
+}
+function DeploymentLevelFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/TenantPolicyDto.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/GroupPolicyDto.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/UserPolicyDto.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/FederatedPolicyDto.ts
+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)
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/FederatedPolicyDtoPagedResult.ts
+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)
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/ImportPolicyRequest.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/PolicyDtoPagedResult.ts
+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)
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/PolicyExportResponse.ts
+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"])
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/PolicyInfoDto.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/PolicyUsageData.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/models/UpdatePolicyRequest.ts
+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"]
+  };
+}
+
+// ../gov/aops-policy-sdk/generated/src/apis/PolicyApi.ts
+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();
+  }
+}
+
+// ../gov/aops-policy-sdk/src/policy-resolver.ts
+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.`);
+  }
+}
+// ../packager/project-packager/package.json
+var package_default = {
+  name: "@uipath/project-packager",
+  author: "UiPath",
+  license: "SEE LICENSE IN LICENSE.txt",
+  version: "1.204.0-preview.211",
+  description: "UiPath Project Packager - core library for packing individual UiPath projects",
+  type: "module",
+  main: "./dist/index.js",
+  exports: {
+    ".": {
+      types: "./dist/src/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./node": {
+      types: "./dist/src/node.d.ts",
+      default: "./dist/node.js"
+    },
+    "./browser": {
+      types: "./dist/src/browser.d.ts",
+      default: "./dist/browser.js"
+    }
+  },
+  types: "./dist/src/index.d.ts",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/packager/project-packager"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external '@uipath/filesystem/*' --external @uipath/filesystem --sourcemap=linked && bun build ./src/browser.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external '@uipath/filesystem/*' --external @uipath/filesystem --sourcemap=linked && bun build ./src/node.ts --outdir dist --format esm --target node --external @uipath/solutionpackager-tool-core --external '@uipath/filesystem/*' --external @uipath/filesystem --sourcemap=linked && tsc -p tsconfig.build.json --emitDeclarationOnly --noCheck --outDir dist",
+    typecheck: "tsc --noEmit",
+    clean: "rimraf dist",
+    test: "vitest run",
+    e2e: "vitest run --config vitest.e2e.config.ts",
+    "test:coverage": "vitest run --coverage",
+    prepack: "bun run build",
+    "publish:dry": "bun publish --dry-run",
+    "publish:gh": "bun publish",
+    "version:patch": "bun version patch --no-git-tag-version",
+    "version:minor": "bun version minor --no-git-tag-version",
+    "version:major": "bun version major --no-git-tag-version",
+    lint: "biome check ."
+  },
+  dependencies: {
+    "@uipath/aops-policy-sdk": "workspace:*",
+    "@uipath/filesystem": "workspace:*",
+    "@uipath/solutionpackager-tool-core": "workspace:*",
+    "@uipath/common": "workspace:*"
+  },
+  peerDependencies: {
+    fflate: "^0.8.2"
+  },
+  devDependencies: {
+    "@types/node": "^25.5.2",
+    "@uipath/resource-builder-tool": "2025.11.0-alpha6004-4107",
+    "@uipath/tool-agent": "^2.0.0",
+    "@uipath/packager-tool-apiworkflow": "workspace:*",
+    "@uipath/packager-tool-connector": "workspace:*",
+    "@uipath/packager-tool-flow": "workspace:*",
+    "@uipath/packager-tool-functions": "workspace:*",
+    "@uipath/packager-tool-webapp": "workspace:*",
+    "@uipath/packager-tool-workflowcompiler": "workspace:*",
+    "@vitest/coverage-v8": "^4.1.11",
+    jsdom: "^30.0.1",
+    typescript: "^7.0.2",
+    "vite-tsconfig-paths": "^6.1.1",
+    vitest: "^4.1.11"
+  }
+};
+
+// ../packager/project-packager/src/services/governance-policy-service.ts
+var LICENSE_TYPES = {
+  NoLicense: "NoLicense",
+  Development: "Development",
+  Attended: "Attended",
+  Unattended: "Unattended",
+  StudioX: "StudioX",
+  StudioPro: "StudioPro",
+  AutomationKit: "AutomationKit"
+};
+var STUDIOWEB_PRODUCT = "StudioWeb";
+var ACQUIRE_LICENSE_PATH = "/orchestrator_/api/StudioWeb/AcquireLicense";
+var GOVERNANCE_SUBFOLDER = "governance";
+var GOVERNANCE_FILE_NAME = "governance-policy.json";
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+var t = (key, params) => translate.t(`solutionpackager.governance.${key}`, params);
+function localRulesType(requestedType, suppliedFilePath) {
+  if (requestedType === "Default" /* Default */ || !suppliedFilePath) {
+    return "Default" /* Default */;
+  }
+  return requestedType === "AutomationOps" /* AutomationOps */ ? "AutomationOps" /* AutomationOps */ : "Studio" /* Studio */;
+}
+
+class GovernancePolicyService {
+  fileSystem;
+  temporaryStorage;
+  fetchFn;
+  logger = new ToolLogger("GovernancePolicyService", "ResolvePolicy");
+  constructor(fileSystem, temporaryStorage, fetchFn = fetch.bind(globalThis)) {
+    this.fileSystem = fileSystem;
+    this.temporaryStorage = temporaryStorage;
+    this.fetchFn = fetchFn;
+  }
+  async resolveGovernancePolicyAsync(validateOptions, connectionInfo, cancellationToken, _usage = "pack") {
+    const requestedType = validateOptions.governanceFileType;
+    const suppliedFilePath = validateOptions.governanceFilePath;
+    const origin = this.resolveCloudOrigin(connectionInfo?.cloudUrl);
+    const product = validateOptions.profileKey;
+    if (!origin || !product || !connectionInfo?.organizationId || !connectionInfo.tenantId || !connectionInfo.accessToken) {
+      if (requestedType === "Default" /* Default */) {
+        return;
+      }
+      if (suppliedFilePath) {
+        this.logger.info(t("info.noTenantToAsk", { path: suppliedFilePath }));
+        validateOptions.governanceFileType = localRulesType(requestedType, suppliedFilePath);
+        return;
+      }
+      this.warnAndUseShippedRules(validateOptions, t("errors.connectionIncomplete"));
+      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, requestedType, suppliedFilePath);
+  }
+  async applyResolutionAsync(resolution, validateOptions, requestedType, suppliedFilePath) {
+    switch (resolution.outcome) {
+      case "governed": {
+        const tenantProduct = resolution.subject.product;
+        if (suppliedFilePath) {
+          this.logger.warn(t("errors.tenantPolicyWins", {
+            product: tenantProduct,
+            path: suppliedFilePath
+          }));
+        } else if (requestedType === "Default" /* Default */) {
+          this.logger.warn(t("errors.defaultOverridden", {
+            product: tenantProduct
+          }));
+        }
+        this.dropIgnoredRules(validateOptions, tenantProduct);
+        await this.savePolicyAsync(validateOptions, resolution.document);
+        return;
+      }
+      case "ungoverned": {
+        const localType = localRulesType(requestedType, suppliedFilePath);
+        if (suppliedFilePath && localType !== "Default" /* Default */) {
+          this.logger.info(t("info.suppliedFileHonoured", {
+            path: suppliedFilePath
+          }));
+        } else {
+          this.logger.info(t("info.ungoverned"));
+        }
+        validateOptions.governanceFileType = localType;
+        return;
+      }
+      case "unknown": {
+        this.logger.warn(this.describeUnknown(resolution));
+        const localType = localRulesType(requestedType, suppliedFilePath);
+        if (suppliedFilePath && localType !== "Default" /* Default */) {
+          this.logger.info(t("info.suppliedFileUnchecked", {
+            path: suppliedFilePath
+          }));
+        }
+        validateOptions.governanceFileType = localType;
+        return;
+      }
+    }
+  }
+  dropIgnoredRules(validateOptions, product) {
+    const rules = normalizeIgnoredRules(validateOptions.ignoredRules);
+    validateOptions.ignoredRules = undefined;
+    if (rules.length === 0) {
+      return;
+    }
+    this.logger.warn(t("errors.ignoredRulesNotApplied", {
+      product,
+      rules: rules.join(", ")
+    }));
+  }
+  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, document);
+      this.logger.info(t("info.saved", { path: filePath }));
+      validateOptions.governanceFilePath = filePath;
+      validateOptions.governanceFileType = "AutomationOps" /* AutomationOps */;
+    } catch (error) {
+      this.warnAndUseShippedRules(validateOptions, t("errors.failedToSave", { error: errorMessage(error) }));
+    }
+  }
+  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 {
+      return new URL(cloudUrl).origin;
+    } catch {
+      return null;
+    }
+  }
+  async resolveLicenseTypeAsync(profileKey, cloudUrl, accessToken, cancellationToken) {
+    const isStudioWeb = profileKey === STUDIOWEB_PRODUCT;
+    const fallback = isStudioWeb ? LICENSE_TYPES.NoLicense : LICENSE_TYPES.Development;
+    try {
+      const response = await this.fetchFn(`${cloudUrl}${ACQUIRE_LICENSE_PATH}`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${accessToken}` },
+        signal: cancellationToken
+      });
+      if (!response.ok) {
+        this.logger.info(t("info.licenseStatus", {
+          status: response.status,
+          fallback
+        }));
+        return fallback;
+      }
+      const { isLicensed, robotType } = await response.json();
+      this.logger.info(t("info.licenseResponse", {
+        isLicensed: String(isLicensed),
+        robotType: String(robotType)
+      }));
+      if (!isLicensed || !robotType) {
+        return fallback;
+      }
+      if (isStudioWeb) {
+        return robotType === LICENSE_TYPES.AutomationKit ? LICENSE_TYPES.AutomationKit : LICENSE_TYPES.NoLicense;
+      }
+      return robotType;
+    } catch (error) {
+      this.logger.info(t("info.licenseFailed", {
+        error: errorMessage(error),
+        fallback
+      }));
+      return fallback;
+    }
+  }
+}
+
+// ../packager/project-packager/src/services/nupkg-resolver.ts
+async function resolveProducedNupkgsAsync(fileSystem, packagePath) {
+  if (packagePath.toLowerCase().endsWith(".nupkg")) {
+    return [packagePath];
+  }
+  const stat = await fileSystem.stat(packagePath);
+  if (!stat?.isDirectory()) {
+    return [];
+  }
+  const candidateDirs = [packagePath, fileSystem.path.dirname(packagePath)];
+  for (const dir of candidateDirs) {
+    const entries = await fileSystem.readdir(dir);
+    const nupkgs = entries.filter((entry) => entry.toLowerCase().endsWith(".nupkg")).map((entry) => fileSystem.path.join(dir, entry));
+    if (nupkgs.length > 0) {
+      return nupkgs;
+    }
+  }
+  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;
+  dotDashRegex = /\.{0,10}[-:]\.{0,10}/g;
+  MaxPackageIdLength = 100;
+  sanitizePackageId(packageId) {
+    packageId = packageId.trim();
+    packageId = packageId.replace(this.spacesDotRegex, ".");
+    packageId = packageId.replace(this.dotDashRegex, "-");
+    packageId = packageId.replace(this.disallowedCharsRegex, "_");
+    if (packageId.length > 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;
+  }
+}
+
+// ../packager/project-packager/src/services/package-signer.ts
+async function signNupkgsAsync(signService, nupkgPaths, signingInfo) {
+  if (!signingInfo?.certificatePath) {
+    return ToolResult.success();
+  }
+  if (!signService) {
+    return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "Package signing is required but signing service is not available. Package signing requires dotnet CLI to be installed in Node.js environment.");
+  }
+  const certificatePath = signingInfo.certificatePath;
+  const toSign = [...new Set(nupkgPaths)];
+  if (toSign.length === 0) {
+    return ToolResult.success();
+  }
+  if (signService.signPackagesAsync) {
+    return signService.signPackagesAsync(toSign, certificatePath, signingInfo.certificatePassword, signingInfo.timestampServer);
+  }
+  for (const packagePath of toSign) {
+    const signResult = await signService.signPackageAsync(packagePath, certificatePath, signingInfo.certificatePassword, signingInfo.timestampServer);
+    if (!signResult.isSuccess) {
+      return signResult;
+    }
+  }
+  return ToolResult.success();
+}
+
+// ../packager/project-packager/src/services/packager-parameters-validator.ts
+class PackagerParametersValidator {
+  logger;
+  fileSystem;
+  constructor(logger, fileSystem) {
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+  }
+  async validateAsync(_options, _cancellationToken) {
+    return ToolResult.success();
+  }
+  validateDestinationPath(destinationPath) {
+    if (!destinationPath) {
+      const error = translate.t("solutionpackager.validator.errors.destinationNotDefined");
+      this.logger.error(error);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, error);
+    }
+    return ToolResult.success();
+  }
+  async validateDestinationOutsideProjectAsync(destinationPath, inputPath) {
+    const projectDirectory = await this.resolveProjectDirectoryAsync(inputPath);
+    if (!projectDirectory) {
+      return ToolResult.success();
+    }
+    const destination = this.fileSystem.path.resolve(destinationPath);
+    if (!this.isSameOrInside(projectDirectory, destination)) {
+      return ToolResult.success();
+    }
+    const message = translate.t("solutionpackager.validator.errors.destinationInsideProject", {
+      destinationPath: destination,
+      projectPath: projectDirectory
+    });
+    const instructions = translate.t("solutionpackager.validator.errors.destinationInsideProjectInstruction");
+    this.logger.error(message);
+    return ToolResult.error("INTERNAL_ERROR" /* InternalError */, message, instructions);
+  }
+  async resolveProjectDirectoryAsync(inputPath) {
+    if (!inputPath) {
+      return;
+    }
+    const resolved = this.fileSystem.path.resolve(inputPath);
+    const stat = await this.fileSystem.stat(resolved);
+    if (!stat) {
+      return;
+    }
+    return stat.isDirectory() ? resolved : this.fileSystem.path.dirname(resolved);
+  }
+  isSameOrInside(parent, child) {
+    const relative = this.fileSystem.path.relative(parent, child);
+    if (relative === "") {
+      return true;
+    }
+    if (this.fileSystem.path.isAbsolute(relative)) {
+      return false;
+    }
+    return relative !== ".." && !relative.startsWith("../") && !relative.startsWith("..\\");
+  }
+  async validateGovernanceOptions(validateOptions) {
+    if (validateOptions.governanceFileType === "Default" /* Default */) {
+      if (validateOptions.governanceFilePath) {
+        this.logger.warn(`Governance file path '${validateOptions.governanceFilePath}' will be ignored when governance file type is Default`);
+      }
+      return ToolResult.success();
+    }
+    if (!validateOptions.governanceFilePath) {
+      const error = translate.t("solutionpackager.validator.errors.governanceRequired");
+      this.logger.error(error);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, error);
+    }
+    try {
+      const stat = await this.fileSystem.stat(validateOptions.governanceFilePath);
+      if (!stat) {
+        const error = translate.t("solutionpackager.validator.errors.governanceFileInfo", {
+          path: validateOptions.governanceFilePath
+        });
+        this.logger.error(error);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, error);
+      }
+      if (stat.isDirectory()) {
+        const error = translate.t("solutionpackager.validator.errors.governanceInvalidFile", {
+          path: validateOptions.governanceFilePath
+        });
+        this.logger.error(error);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, error);
+      }
+    } catch (error) {
+      const errorMessage2 = error instanceof Error ? error.message : String(error);
+      const errorLog = `Governance file not found or inaccessible: ${validateOptions.governanceFilePath}. Error: ${errorMessage2}`;
+      this.logger.error(errorLog);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, errorLog);
+    }
+    this.logger.info(`Using Studio governance file: ${validateOptions.governanceFilePath}`);
+    return ToolResult.success();
+  }
+}
+
+// ../packager/project-packager/src/services/project-build-options-validator.ts
+class ProjectBuildOptionsValidator extends PackagerParametersValidator {
+  async validateAsync(options, _cancellationToken) {
+    return await this.validateGovernanceOptions(options.validateOptions);
+  }
+}
+
+// ../packager/project-packager/src/services/project-loader.ts
+class ProjectLoader {
+  fileSystem;
+  static WebAppManifestFileName = "webAppManifest.json";
+  static ProjectJsonFileName = "project.json";
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async loadProject(projectPath) {
+    if (!projectPath) {
+      throw new Error(translate.t("solutionpackager.projectLoader.errors.pathRequired"));
+    }
+    const projectFilePath = Path.join(projectPath, ProjectTool.ProjectFileName);
+    const projectFileExists = await this.fileSystem.exists(projectFilePath);
+    if (projectFileExists) {
+      return await this.loadFromProjectFile(projectPath, projectFilePath);
+    }
+    const projectJsonPath = Path.join(projectPath, ProjectLoader.ProjectJsonFileName);
+    if (await this.fileSystem.exists(projectJsonPath)) {
+      return await this.loadFromProjectFile(projectPath, projectJsonPath, true);
+    }
+    const webAppManifestPath = Path.join(projectPath, ProjectLoader.WebAppManifestFileName);
+    const webAppManifestExists = await this.fileSystem.exists(webAppManifestPath);
+    if (webAppManifestExists) {
+      return this.loadFromWebAppManifest(projectPath, webAppManifestPath);
+    }
+    throw new Error(translate.t("solutionpackager.projectLoader.errors.noProjectFile", {
+      projectFile: ProjectTool.ProjectFileName,
+      projectJsonFile: ProjectLoader.ProjectJsonFileName,
+      manifestFile: ProjectLoader.WebAppManifestFileName,
+      path: projectPath
+    }));
+  }
+  async loadFromProjectFile(projectPath, projectFilePath, useProjectJson = false) {
+    const fileContent = await this.fileSystem.readFile(projectFilePath);
+    if (!fileContent) {
+      throw new Error(translate.t("solutionpackager.projectLoader.errors.readFailed", {
+        path: projectFilePath
+      }));
+    }
+    const json = typeof fileContent === "string" ? fileContent : new TextDecoder("utf-8").decode(fileContent);
+    const projectData = JSON.parse(json);
+    const projectJson = useProjectJson ? projectData : undefined;
+    const outputType = projectJson?.designOptions?.outputType;
+    const projectType = outputType ?? (projectData?.ProjectType || projectData?.type);
+    if (!projectData || !projectType) {
+      throw new Error(translate.t("solutionpackager.projectLoader.errors.invalidProject", {
+        path: projectFilePath
+      }));
+    }
+    const declaredName = projectJson?.name?.trim() || projectData.Name;
+    const declaredDescription = projectJson?.description?.trim() || projectData.Description?.trim() || undefined;
+    const declaredAuthor = projectJson?.author?.trim() || projectData.Author?.trim() || undefined;
+    return {
+      type: projectType,
+      name: declaredName || Path.basename(projectPath),
+      projectPath,
+      projectFilePath,
+      description: declaredDescription,
+      author: declaredAuthor
+    };
+  }
+  loadFromWebAppManifest(projectPath, webAppManifestPath) {
+    const folderName = Path.basename(projectPath);
+    return {
+      type: "AppV2" /* AppV2 */,
+      name: folderName,
+      projectPath,
+      projectFilePath: webAppManifestPath
+    };
+  }
+}
+
+// ../packager/project-packager/src/services/project-pack-options-builder.ts
+class ProjectPackOptionsBuilder {
+  packService;
+  fileSystem;
+  constructor(packService, fileSystem) {
+    this.packService = packService;
+    this.fileSystem = fileSystem;
+  }
+  async buildProjectPackOptions(parameters, project) {
+    if (!parameters.outputPath) {
+      throw new Error("Output path is required for Pack command");
+    }
+    await this.fileSystem.mkdir(parameters.outputPath);
+    const packageId = !parameters.package.id || parameters.package.id.trim() === "" ? project.name : parameters.package.id;
+    const packageInfo = {
+      ...parameters.package,
+      id: this.packService.sanitizePackageId(packageId),
+      description: parameters.package.description || project.description,
+      author: parameters.package.author || project.author
+    };
+    return {
+      projectPath: project.projectPath,
+      excludeConfiguredSources: parameters.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: parameters.nuGetSourcesConfigPath,
+      feedFolder: parameters.feedFolder,
+      logLevel: parameters.logLevel,
+      skipAnalyze: parameters.validateOptions.skipAnalyze,
+      skipValidate: parameters.validateOptions.skipValidate,
+      ignoredRules: parameters.validateOptions.ignoredRules,
+      detailedLogPath: parameters.detailedLogPath,
+      policyFilePath: parameters.validateOptions.governanceFilePath,
+      policyFileType: parameters.validateOptions.governanceFileType,
+      outputPath: parameters.outputPath,
+      outputType: parameters.outputType,
+      projectType: project.type,
+      package: packageInfo,
+      skipDependencyOptimization: parameters.packOptions?.skipDependencyOptimization ?? false,
+      includeSources: parameters.packOptions?.includeSources ?? false,
+      splitPackages: parameters.packOptions?.splitPackages ?? false
+    };
+  }
+}
+
+// ../packager/project-packager/src/services/project-pack-options-validator.ts
+class ProjectPackOptionsValidator extends ProjectBuildOptionsValidator {
+  async validateAsync(options, cancellationToken) {
+    const destinationResult = this.validateDestinationPath(options.destinationPath);
+    if (!destinationResult.isSuccess) {
+      return destinationResult;
+    }
+    const containmentResult = await this.validateDestinationOutsideProjectAsync(options.destinationPath, options.inputPath);
+    if (!containmentResult.isSuccess) {
+      return containmentResult;
+    }
+    return await super.validateAsync(options, cancellationToken);
+  }
+}
+
+// ../packager/project-packager/src/services/project-tool-executor.ts
+class ProjectToolExecutor {
+  toolsFactory;
+  telemetry;
+  constructor(toolsFactory, telemetry) {
+    this.toolsFactory = toolsFactory;
+    this.telemetry = telemetry;
+  }
+  async restoreAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Restore" /* ProjectToolRestore */, project.Type, async () => tool.restoreAsync(options, cancellationToken), {
+      [PackagerDimensions.ProjectId]: project.Id,
+      [PackagerDimensions.ProjectType]: project.Type
+    }));
+  }
+  async validateAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Validate" /* ProjectToolValidate */, project.Type, async () => tool.validateAsync(options, cancellationToken), {
+      [PackagerDimensions.ProjectId]: project.Id,
+      [PackagerDimensions.ProjectType]: project.Type
+    }));
+  }
+  async buildAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Build" /* ProjectToolBuild */, project.Type, async () => tool.buildAsync(options, cancellationToken), {
+      [PackagerDimensions.ProjectId]: project.Id,
+      [PackagerDimensions.ProjectType]: project.Type
+    }));
+  }
+  async packAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, async (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Pack" /* ProjectToolPack */, project.Type, async () => tool.packAsync(options, cancellationToken), {
+      [PackagerDimensions.ProjectId]: project.Id,
+      [PackagerDimensions.ProjectType]: project.Type
+    }));
+  }
+  async cleanupAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Cleanup" /* ProjectToolCleanup */, project.Type, async () => tool.cleanupAsync(options, cancellationToken), {
+      [PackagerDimensions.ProjectId]: project.Id,
+      [PackagerDimensions.ProjectType]: project.Type
+    }));
+  }
+  async executeToolOperationAsync(project, context, operation) {
+    try {
+      const tool = await this.toolsFactory.createProjectToolAsync(project, context);
+      try {
+        return await operation(tool);
+      } finally {
+        const disposeResult = tool.dispose();
+        if (disposeResult instanceof Promise) {
+          await disposeResult;
+        }
+      }
+    } catch (error) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+
+// ../packager/project-packager/src/services/project-validate-options-validator.ts
+class ProjectValidateOptionsValidator extends PackagerParametersValidator {
+  async validateAsync(options, _cancellationToken) {
+    return await this.validateGovernanceOptions(options.validateOptions);
+  }
+}
+
+// ../packager/project-packager/src/services/tools-factory.ts
+class ToolsFactory {
+  repository;
+  fileSystem;
+  constructor(repository, fileSystem) {
+    this.repository = repository;
+    this.fileSystem = fileSystem;
+  }
+  async createSolutionToolAsync(solutionName) {
+    const logger = new ToolLogger("ResourceBuilder", solutionName);
+    const factory = this.repository.getSolutionToolFactory();
+    return await factory.createAsync(logger, this.fileSystem);
+  }
+  async createProjectToolAsync(project, context) {
+    const sourceTarget = getSourceTarget();
+    const logger = new ToolLogger(project.Type, sourceTarget);
+    if (!project.ProjectPath) {
+      throw new Error(`Project path not set for project: ${project.Id}`);
+    }
+    const factory = this.repository.getProjectToolFactory(project.Type);
+    return await factory.createAsync(logger, this.fileSystem, context);
+    function getSourceTarget() {
+      const segments = project.ProjectRelativePath.split(/[/\\]/);
+      if (segments.length > 1) {
+        return segments[0];
+      }
+      return project.Id;
+    }
+  }
+}
+
+// ../packager/project-packager/src/services/project-packager.ts
+class ProjectPackager {
+  fileSystem;
+  telemetryService;
+  packageSignService;
+  repository;
+  temporaryStorage;
+  zipService;
+  logger;
+  optionsBuilder;
+  toolsFactory;
+  projectExecutor;
+  projectLoader;
+  validateOptionsValidator;
+  buildOptionsValidator;
+  packOptionsValidator;
+  nugetPackager;
+  governancePolicyService;
+  constructor(fileSystem, telemetryService, packageSignService) {
+    this.fileSystem = fileSystem;
+    this.telemetryService = telemetryService;
+    this.packageSignService = packageSignService;
+    this.repository = toolsFactoryRepository;
+    this.temporaryStorage = new TemporaryStorageService(this.fileSystem);
+    this.zipService = new ZipService(this.fileSystem);
+    this.nugetPackager = new NugetPackager(this.fileSystem);
+    this.logger = new ToolLogger("ProjectPackager", "PackProject");
+    this.validateOptionsValidator = new ProjectValidateOptionsValidator(this.logger, this.fileSystem);
+    this.buildOptionsValidator = new ProjectBuildOptionsValidator(this.logger, this.fileSystem);
+    this.packOptionsValidator = new ProjectPackOptionsValidator(this.logger, this.fileSystem);
+    const packService = new PackService;
+    this.optionsBuilder = new ProjectPackOptionsBuilder(packService, this.fileSystem);
+    this.toolsFactory = new ToolsFactory(this.repository, this.fileSystem);
+    this.projectExecutor = new ProjectToolExecutor(this.toolsFactory, this.telemetryService);
+    this.projectLoader = new ProjectLoader(this.fileSystem);
+    this.governancePolicyService = new GovernancePolicyService(this.fileSystem, this.temporaryStorage);
+  }
+  async setupAsync(input, operationId) {
+    this.telemetryService.setOperationId(operationId);
+    await this.temporaryStorage.cleanup();
+    if (typeof input === "string") {
+      return input;
+    }
+    const inputPath = await this.temporaryStorage.getTempSubfolderPathAsync("input");
+    await this.zipService.extractAsync(input, inputPath);
+    const entries = await this.fileSystem.readdir(inputPath);
+    if (entries.length === 1) {
+      const innerPath = Path.join(inputPath, entries[0]);
+      const stat = await this.fileSystem.stat(innerPath);
+      if (stat?.isDirectory()) {
+        return innerPath;
+      }
+    }
+    return inputPath;
+  }
+  async restoreProjectAsync(options, cancellationToken) {
+    return await this.executeProjectOperationAsync(options, "Restore", "ProjectPackager.Restore" /* ProjectPackagerRestore */, async (uiPathProject, loadedProject) => {
+      const restoreOptions = {
+        projectPath: loadedProject.projectPath,
+        excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+        nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+        feedFolder: options.feedFolder,
+        logLevel: options.logLevel,
+        outputPath: options.outputPath
+      };
+      const context = this.createOperationContext(options, uiPathProject);
+      return await this.projectExecutor.restoreAsync(restoreOptions, uiPathProject, context, cancellationToken);
+    }, cancellationToken);
+  }
+  async validateProjectAsync(options, cancellationToken) {
+    await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken, "analyze");
+    const validationResult = await this.validateOptionsValidator.validateAsync(options, cancellationToken);
+    if (!validationResult.isSuccess) {
+      return validationResult;
+    }
+    return await this.executeProjectOperationAsync(options, "Validate", "ProjectPackager.Validate" /* ProjectPackagerValidate */, async (uiPathProject, loadedProject) => {
+      const validateOptions = {
+        projectPath: loadedProject.projectPath,
+        excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+        nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+        feedFolder: options.feedFolder,
+        logLevel: options.logLevel,
+        skipAnalyze: options.validateOptions.skipAnalyze,
+        skipValidate: options.validateOptions.skipValidate,
+        ignoredRules: options.validateOptions.ignoredRules,
+        defaultSeverity: options.validateOptions.defaultSeverity,
+        detailedLogPath: options.detailedLogPath,
+        policyFilePath: options.validateOptions.governanceFilePath,
+        policyFileType: options.validateOptions.governanceFileType
+      };
+      const context = this.createOperationContext(options, uiPathProject);
+      return await this.projectExecutor.validateAsync(validateOptions, uiPathProject, context, cancellationToken);
+    }, cancellationToken);
+  }
+  async buildProjectAsync(options, cancellationToken) {
+    const [governanceError] = await catchError(this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken));
+    if (governanceError) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Project build failed: ${governanceError.message}`, carriedInstructions(governanceError));
+    }
+    const validationResult = await this.buildOptionsValidator.validateAsync(options, cancellationToken);
+    if (!validationResult.isSuccess) {
+      return validationResult;
+    }
+    return await this.executeProjectOperationAsync(options, "Build", "ProjectPackager.Build" /* ProjectPackagerBuild */, async (uiPathProject, loadedProject) => {
+      if (!options.outputPath) {
+        options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("output");
+      }
+      const buildOptions = {
+        projectPath: loadedProject.projectPath,
+        excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+        nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+        feedFolder: options.feedFolder,
+        logLevel: options.logLevel,
+        skipAnalyze: options.validateOptions.skipAnalyze,
+        skipValidate: options.validateOptions.skipValidate,
+        ignoredRules: options.validateOptions.ignoredRules,
+        detailedLogPath: options.detailedLogPath,
+        policyFilePath: options.validateOptions.governanceFilePath,
+        policyFileType: options.validateOptions.governanceFileType,
+        outputPath: options.outputPath,
+        outputType: options.outputType,
+        projectType: uiPathProject.Type
+      };
+      const context = this.createOperationContext(options, uiPathProject);
+      return await this.projectExecutor.buildAsync(buildOptions, uiPathProject, context, cancellationToken);
+    }, cancellationToken);
+  }
+  async packProjectAsync(options, cancellationToken) {
+    return await this.telemetryService.trackDependencyOperation("ProjectPackager.Pack" /* ProjectPackagerPack */, "pack", async () => {
+      try {
+        await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+        let result = await this.packOptionsValidator.validateAsync(options, cancellationToken);
+        if (!result.isSuccess) {
+          return result;
+        }
+        if (!options.outputPath) {
+          options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("output");
+        }
+        const loadedProject = await this.projectLoader.loadProject(options.inputPath);
+        this.telemetryService.trackEvent("ProjectPackager.ProjectLoaded" /* ProjectPackagerProjectLoaded */, { [PackagerDimensions.ProjectId]: loadedProject.name });
+        const projectPackOptions = await this.optionsBuilder.buildProjectPackOptions(options, loadedProject);
+        const uiPathProject = {
+          Type: loadedProject.type,
+          ProjectRelativePath: Path.basename(loadedProject.projectFilePath),
+          ProjectPath: loadedProject.projectPath,
+          Id: loadedProject.name
+        };
+        const context = this.createOperationContext(options, uiPathProject);
+        result = await this.projectExecutor.packAsync(projectPackOptions, uiPathProject, context, cancellationToken);
+        if (result.isSuccess && result.packages.length > 0) {
+          const destinationPackages = await this.copyPackagesToDestination(result.packages, options.destinationPath, projectPackOptions.package);
+          const signResult = await signNupkgsAsync(this.packageSignService, destinationPackages, options.signingInfo);
+          if (!signResult.isSuccess) {
+            return signResult;
+          }
+          result = new ToolResult("SUCCESS" /* Success */, undefined, destinationPackages);
+        }
+        if (result.isSuccess) {
+          this.logger.info(`Project pack completed successfully. Packages: ${result.packages.join(", ")}`);
+        } else {
+          this.logger.error(`Project pack failed with error code ${result.errorCode}: ${result.message}`);
+        }
+        return result;
+      } catch (error) {
+        const errorMessage2 = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage2}`);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Project pack failed: ${errorMessage2}`, carriedInstructions(error));
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  async cleanupProjectAsync(options, cancellationToken) {
+    return await this.executeProjectOperationAsync(options, "Cleanup", "ProjectPackager.Cleanup" /* ProjectPackagerCleanup */, async (uiPathProject, loadedProject) => {
+      const cleanupOptions = {
+        projectPath: loadedProject.projectPath,
+        excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+        nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+        feedFolder: options.feedFolder,
+        logLevel: options.logLevel,
+        dryRun: options.dryRun ?? false,
+        skipImports: options.skipImports ?? false
+      };
+      const context = {
+        ...this.createOperationContext(options, uiPathProject),
+        lockKey: options.lockKey
+      };
+      return await this.projectExecutor.cleanupAsync(cleanupOptions, uiPathProject, context, cancellationToken);
+    }, cancellationToken);
+  }
+  async getPackageStreamsAsync(result) {
+    if (!result.isSuccess) {
+      throw new Error(translate.t("solutionpackager.packager.errors.failedToGetStreams", {
+        errorCode: result.errorCode,
+        message: result.message ?? ""
+      }));
+    }
+    if (!result.packages || result.packages.length === 0) {
+      return [];
+    }
+    const packageStreams = [];
+    for (const packagePath of result.packages) {
+      const data = await this.fileSystem.readFile(packagePath);
+      if (!data) {
+        throw new Error(translate.t("solutionpackager.packager.errors.failedToReadPackage", {
+          path: packagePath
+        }));
+      }
+      const name = packagePath.split(/[\\/]/).pop() || packagePath;
+      packageStreams.push({ name, data });
+    }
+    return packageStreams;
+  }
+  async executeProjectOperationAsync(options, operationName, telemetryName, operation, _cancellationToken) {
+    return await this.telemetryService.trackDependencyOperation(telemetryName, operationName.toLowerCase(), async () => {
+      try {
+        const loadedProject = await this.projectLoader.loadProject(options.inputPath);
+        const uiPathProject = {
+          Type: loadedProject.type,
+          ProjectRelativePath: Path.basename(loadedProject.projectFilePath),
+          ProjectPath: loadedProject.projectPath,
+          Id: loadedProject.name
+        };
+        const operationResult = await operation(uiPathProject, loadedProject);
+        if (operationResult.isSuccess) {
+          this.logger.info(`Project ${operationName.toLowerCase()} completed successfully.`);
+        } else {
+          this.logger.error(`Project ${operationName.toLowerCase()} failed with error code ${operationResult.errorCode}: ${operationResult.message}`);
+        }
+        return operationResult;
+      } catch (error) {
+        const errorMessage2 = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage2}`);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Project ${operationName.toLowerCase()} failed: ${errorMessage2}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  createOperationContext(options, uiPathProject) {
+    return {
+      id: crypto.randomUUID(),
+      projects: [uiPathProject],
+      downloadUrl: options.downloadUrl,
+      projectId: options.projectId,
+      targetFramework: options.targetFramework ?? "Portable" /* Portable */,
+      connection: options.connection,
+      logger: this.logger,
+      workflowCompilerVersion: options.workflowCompilerVersion
+    };
+  }
+  async copyFileToDestination(sourcePath, destinationPath) {
+    const fileName = Path.basename(sourcePath);
+    const destPath = Path.join(destinationPath, fileName);
+    const data = await this.fileSystem.readFile(sourcePath);
+    if (!data) {
+      throw new Error(translate.t("solutionpackager.packager.errors.failedToReadPackage", { path: sourcePath }));
+    }
+    await this.fileSystem.writeFile(destPath, data);
+    return destPath;
+  }
+  async copyPackagesToDestination(packagePaths, destinationPath, packageInfo) {
+    await this.fileSystem.mkdir(destinationPath);
+    const destinationPackages = [];
+    for (const packagePath of packagePaths) {
+      const stat = await this.fileSystem.stat(packagePath);
+      if (stat?.isDirectory()) {
+        const nupkgs = await resolveProducedNupkgsAsync(this.fileSystem, packagePath);
+        if (nupkgs.length > 0) {
+          for (const filePath of nupkgs) {
+            destinationPackages.push(await this.copyFileToDestination(filePath, destinationPath));
+          }
+        } else {
+          const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
+          const destPath = Path.join(destinationPath, nupkgFileName);
+          const packResult = await this.nugetPackager.packAsync(packagePath, packageInfo, destPath);
+          destinationPackages.push(packResult.outputPath);
+        }
+      } else {
+        destinationPackages.push(await this.copyFileToDestination(packagePath, destinationPath));
+      }
+    }
+    return destinationPackages;
+  }
+}
+
+// ../packager/project-packager/src/node-project-packager-factory.ts
+class NodeProjectPackagerFactory extends BaseNodePackagerFactory {
+  async createAsync(config) {
+    const logger = new ToolLogger("ProjectPackagerFactory", "Create");
+    this.configureLanguage(config);
+    this.configureLogHandler(config);
+    logger.info("Creating ProjectPackager instance...");
+    const fileSystem = this.getOrCreateFileSystem(config);
+    const telemetryService = this.getOrCreateTelemetryService(config);
+    this.dotnetDiscovery = new DotnetDiscoveryService;
+    const packageSignService = new NodePackageSignService(this.dotnetDiscovery, logger);
+    const projectPackager = new ProjectPackager(fileSystem, telemetryService, packageSignService);
+    this.checkDotnetAvailability(logger);
+    logger.info("ProjectPackager created successfully.");
+    return projectPackager;
+  }
+}
+async function createNodeProjectPackager(options) {
+  const factory = new NodeProjectPackagerFactory;
+  return factory.createAsync(options);
+}
+// ../packager/project-packager/src/publish/models/publish-options.ts
+var PublishDestinationKind;
+((PublishDestinationKind2) => {
+  PublishDestinationKind2["LocalFolder"] = "LocalFolder";
+  PublishDestinationKind2["NugetFeed"] = "NugetFeed";
+  PublishDestinationKind2["OrchestratorPersonalWorkspace"] = "OrchestratorPersonalWorkspace";
+  PublishDestinationKind2["OrchestratorTenantProcesses"] = "OrchestratorTenantProcesses";
+  PublishDestinationKind2["OrchestratorSharedLibraries"] = "OrchestratorSharedLibraries";
+  PublishDestinationKind2["OrchestratorCustom"] = "OrchestratorCustom";
+})(PublishDestinationKind ||= {});
+
+class ProjectPublishOptions {
+  packagePaths;
+  destination;
+  constructor(packagePaths, destination) {
+    this.packagePaths = packagePaths;
+    this.destination = destination;
+  }
+}
+// ../packager/project-packager/src/publish/services/local-folder-publisher.ts
+class LocalFolderPublisher {
+  fileSystem;
+  logger;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+    this.logger = new ToolLogger("ProjectPublisher", "LocalFolder");
+  }
+  async publishAsync(packagePaths, destination) {
+    const overwrite = destination.overwrite ?? true;
+    if (!destination.folderPath) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.localFolderRequired"));
+    }
+    if (!await this.fileSystem.exists(destination.folderPath)) {
+      await this.fileSystem.mkdir(destination.folderPath);
+    }
+    const written = [];
+    for (const sourcePath of packagePaths) {
+      const fileName = this.fileSystem.path.basename(sourcePath);
+      const destPath = this.fileSystem.path.join(destination.folderPath, fileName);
+      if (!overwrite && await this.fileSystem.exists(destPath)) {
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.localFolderFileExists", { path: destPath }));
+      }
+      const data = await this.fileSystem.readFile(sourcePath);
+      if (!data) {
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.failedToReadPackage", { path: sourcePath }));
+      }
+      await this.fileSystem.writeFile(destPath, data);
+      written.push(destPath);
+      this.logger.info(`Copied package to ${destPath}`);
+    }
+    return new ToolResult("SUCCESS" /* Success */, undefined, written);
+  }
+}
+
+// ../packager/project-packager/src/publish/services/nuget-feed-publisher.ts
+var NUGET_V3_PACKAGE_PUBLISH_TYPE = "PackagePublish/2.0.0";
+
+class NugetFeedPublisher {
+  fileSystem;
+  logger;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+    this.logger = new ToolLogger("ProjectPublisher", "NugetFeed");
+  }
+  async publishAsync(packagePaths, destination) {
+    if (!destination.feedUrl) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.nugetFeedUrlRequired"));
+    }
+    let pushUrl;
+    try {
+      pushUrl = await this.resolvePushUrl(destination.feedUrl, destination.apiKey);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.nugetPushUrlResolutionFailed", { feedUrl: destination.feedUrl, message }));
+    }
+    const published = [];
+    for (const packagePath of packagePaths) {
+      const data = await this.fileSystem.readFile(packagePath);
+      if (!data) {
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.failedToReadPackage", { path: packagePath }));
+      }
+      const fileName = this.fileSystem.path.basename(packagePath);
+      const form = new FormData;
+      form.append("package", new Blob([data], {
+        type: "application/octet-stream"
+      }), fileName);
+      const headers = {};
+      if (destination.apiKey) {
+        headers["X-NuGet-ApiKey"] = destination.apiKey;
+      }
+      this.logger.info(`Pushing ${fileName} to ${pushUrl}`);
+      const response = await fetch(pushUrl, {
+        method: "PUT",
+        headers,
+        body: form
+      });
+      if (!response.ok) {
+        const body = await this.safeReadBody(response);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.nugetPushFailed", {
+          fileName,
+          status: response.status,
+          statusText: response.statusText,
+          body: body ? ` - ${body}` : ""
+        }));
+      }
+      published.push(packagePath);
+      this.logger.info(`Pushed ${fileName} successfully.`);
+    }
+    return new ToolResult("SUCCESS" /* Success */, undefined, published);
+  }
+  async resolvePushUrl(feedUrl, apiKey) {
+    let end = feedUrl.length;
+    while (end > 0 && feedUrl.charCodeAt(end - 1) === 47)
+      end--;
+    const trimmed = feedUrl.slice(0, end);
+    if (/\/api\/v2\/package\/?$/i.test(trimmed)) {
+      return trimmed;
+    }
+    if (/\.json$/i.test(trimmed)) {
+      return this.resolveFromServiceIndex(trimmed, apiKey);
+    }
+    return `${trimmed}/api/v2/package`;
+  }
+  async resolveFromServiceIndex(serviceIndexUrl, apiKey) {
+    const headers = { Accept: "application/json" };
+    if (apiKey) {
+      headers["X-NuGet-ApiKey"] = apiKey;
+    }
+    const response = await fetch(serviceIndexUrl, { headers });
+    if (!response.ok) {
+      throw new Error(`service index returned ${response.status} ${response.statusText}`);
+    }
+    const index = await response.json();
+    const resource = index.resources?.find((r) => r["@type"] === NUGET_V3_PACKAGE_PUBLISH_TYPE);
+    if (!resource?.["@id"]) {
+      throw new Error(`service index has no ${NUGET_V3_PACKAGE_PUBLISH_TYPE} resource`);
+    }
+    return resource["@id"];
+  }
+  async safeReadBody(response) {
+    try {
+      const text = await response.text();
+      return text.slice(0, 500);
+    } catch {
+      return "";
+    }
+  }
+}
+
+// ../packager/project-packager/src/publish/services/orchestrator-feed-types.ts
+var PackageFeedDtoPurposeEnum = {
+  Undefined: "Undefined",
+  Processes: "Processes",
+  Libraries: "Libraries",
+  PersonalWorkspace: "PersonalWorkspace",
+  FolderHierarchy: "FolderHierarchy"
+};
+var PackageFeedDtoAuthenticationTypeEnum = {
+  Secure: "Secure",
+  ApiKey: "ApiKey",
+  Basic: "Basic"
+};
+var ExtendedFolderDtoFeedTypeEnum = {
+  Undefined: "Undefined",
+  Processes: "Processes",
+  Libraries: "Libraries",
+  PersonalWorkspace: "PersonalWorkspace",
+  FolderHierarchy: "FolderHierarchy"
+};
+
+// ../packager/project-packager/src/publish/services/orchestrator-feeds-service.ts
+var HEADER_TENANT_ID = "X-UIPATH-TenantId";
+var FEEDS_PATH = "/api/PackageFeeds/GetFeeds";
+var FOLDERS_PATH = "/api/FoldersNavigation/GetAllFoldersForCurrentUser";
+var SDK_USER_AGENT = `${package_default.name.replace(/^@uipath\//, "")}/${package_default.version}`;
+
+class OrchestratorFeedsService {
+  logger;
+  constructor() {
+    this.logger = new ToolLogger("OrchestratorFeedsService", "Feeds");
+  }
+  async getAccessibleFeedsAsync(connection) {
+    this.ensureOrchestratorUrl(connection);
+    this.logger.info(`Fetching accessible feeds from ${connection.orchestratorUrl}`);
+    try {
+      const json = await orchestratorGet(connection, FEEDS_PATH);
+      return Array.isArray(json) ? json : [];
+    } catch (error) {
+      const { status, statusText, body } = await describeResponseError(error);
+      throw new Error(translate.t("solutionpackager.publish.errors.getAccessibleFeedsFailed", { status, statusText, body }));
+    }
+  }
+  async getFoldersForCurrentUserAsync(connection) {
+    this.ensureOrchestratorUrl(connection);
+    this.logger.info(`Fetching folders from ${connection.orchestratorUrl}`);
+    try {
+      const json = await orchestratorGet(connection, FOLDERS_PATH);
+      return Array.isArray(json) ? json.map(mapExtendedFolder) : [];
+    } catch (error) {
+      const { status, statusText, body } = await describeResponseError(error);
+      throw new Error(translate.t("solutionpackager.publish.errors.getFoldersForCurrentUserFailed", { status, statusText, body }));
+    }
+  }
+  ensureOrchestratorUrl(connection) {
+    if (!connection.orchestratorUrl) {
+      throw new Error(translate.t("solutionpackager.publish.errors.orchestratorUrlRequired"));
+    }
+  }
+}
+function mapExtendedFolder(json) {
+  return {
+    isSelectable: json.IsSelectable,
+    hasChildren: json.HasChildren,
+    level: json.Level,
+    key: json.Key,
+    displayName: json.DisplayName,
+    fullyQualifiedName: json.FullyQualifiedName,
+    description: json.Description,
+    folderType: json.FolderType,
+    isPersonal: json.IsPersonal,
+    provisionType: json.ProvisionType,
+    permissionModel: json.PermissionModel,
+    parentId: json.ParentId,
+    parentKey: json.ParentKey,
+    feedType: json.FeedType,
+    id: json.Id
+  };
+}
+
+class OrchestratorResponseError extends Error {
+  response;
+  constructor(response) {
+    super(`Orchestrator request failed with status ${response.status}.`);
+    this.response = response;
+    this.name = "OrchestratorResponseError";
+  }
+}
+async function orchestratorGet(connection, relativePath) {
+  const url = `${normalizeOrchestratorBasePath(connection.orchestratorUrl)}${relativePath}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: buildHeaders(connection)
+  });
+  if (!response.ok) {
+    throw new OrchestratorResponseError(response);
+  }
+  const text = await response.text();
+  if (text === "" || text === "null") {
+    return null;
+  }
+  return JSON.parse(text);
+}
+function buildHeaders(connection) {
+  const headers = {};
+  if (connection.accessToken) {
+    headers.Authorization = `Bearer ${connection.accessToken}`;
+  }
+  if (connection.tenantId) {
+    headers[HEADER_TENANT_ID] = connection.tenantId;
+  }
+  return addSdkUserAgentHeader(headers, SDK_USER_AGENT);
+}
+function normalizeOrchestratorBasePath(orchestratorUrl) {
+  let end = orchestratorUrl.length;
+  while (end > 0 && orchestratorUrl.charCodeAt(end - 1) === 47)
+    end--;
+  const trimmed = orchestratorUrl.slice(0, end);
+  return /\/orchestrator_$/i.test(trimmed) ? trimmed : `${trimmed}/orchestrator_`;
+}
+async function describeResponseError(error) {
+  const response = error?.response;
+  if (response) {
+    let body = "";
+    try {
+      body = (await response.text()).slice(0, 500);
+    } catch {
+      body = "";
+    }
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      body: body ? ` - ${body}` : ""
+    };
+  }
+  const cause = error?.cause;
+  const message = cause instanceof Error ? cause.message : error instanceof Error ? error.message : String(error);
+  return { status: "?", statusText: message, body: "" };
+}
+
+// ../packager/project-packager/src/publish/services/orchestrator-publisher.ts
+var HEADER_FOLDER_ID = "X-UIPATH-OrganizationUnitId";
+var HEADER_TENANT_ID2 = "X-UIPATH-TenantId";
+var HEADER_NUGET_API_KEY = "X-NuGet-ApiKey";
+var ORCHESTRATOR_RELATIVE_URL = "/orchestrator_";
+var PROCESSES_UPLOAD_PATH = "/odata/Processes/UiPath.Server.Configuration.OData.UploadPackage";
+var LIBRARIES_UPLOAD_PATH = "/odata/Libraries/UiPath.Server.Configuration.OData.UploadPackage";
+
+class OrchestratorPublisher {
+  fileSystem;
+  logger;
+  feedsService;
+  constructor(fileSystem, feedsService) {
+    this.fileSystem = fileSystem;
+    this.logger = new ToolLogger("ProjectPublisher", "Orchestrator");
+    this.feedsService = feedsService ?? new OrchestratorFeedsService;
+  }
+  async publishAsync(packagePaths, destination) {
+    if (packagePaths.length === 0) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.orchestratorNoPackages"));
+    }
+    if (destination.kind === "OrchestratorCustom" /* OrchestratorCustom */) {
+      if (!destination.publishUrl) {
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.orchestratorCustomPublishUrlRequired"));
+      }
+      this.logger.info(`Publishing ${packagePaths.length} package(s) to ${destination.publishUrl} (custom)`);
+      return this.postPackages(packagePaths, destination.publishUrl, this.buildCustomHeaders(destination));
+    }
+    if (!destination.connectionInfo?.cloudUrl) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.orchestratorCloudUrlRequired"));
+    }
+    const orchestratorUrl = this.deriveOrchestratorUrl(destination.connectionInfo);
+    let feed;
+    try {
+      feed = await this.resolveFeed(destination, orchestratorUrl);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.orchestratorFeedResolutionFailed", { message }));
+    }
+    const targetUrl = this.buildPublishUrl(orchestratorUrl, feed);
+    const headers = this.buildHeaders(destination, feed);
+    this.logger.info(`Publishing ${packagePaths.length} package(s) to ${targetUrl} (feed ${feed.name}, ${feed.purpose})`);
+    return this.postPackages(packagePaths, targetUrl, headers);
+  }
+  async postPackages(packagePaths, targetUrl, headers) {
+    const form = new FormData;
+    for (const packagePath of packagePaths) {
+      const data = await this.fileSystem.readFile(packagePath);
+      if (!data) {
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.failedToReadPackage", { path: packagePath }));
+      }
+      const fileName = this.fileSystem.path.basename(packagePath);
+      form.append("file", new Blob([data], {
+        type: "application/octet-stream"
+      }), fileName);
+    }
+    const response = await fetch(targetUrl, {
+      method: "POST",
+      headers,
+      body: form
+    });
+    if (!response.ok) {
+      const body = await this.safeReadBody(response);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.orchestratorPublishFailed", {
+        status: response.status,
+        statusText: response.statusText,
+        body: body ? ` - ${body}` : ""
+      }));
+    }
+    this.logger.info("Orchestrator publish completed.");
+    return new ToolResult("SUCCESS" /* Success */, undefined, packagePaths);
+  }
+  async resolveFeed(destination, orchestratorUrl) {
+    const connection = {
+      orchestratorUrl,
+      accessToken: destination.connectionInfo.accessToken,
+      tenantId: destination.connectionInfo.tenantId
+    };
+    const feeds = await this.feedsService.getAccessibleFeedsAsync(connection);
+    if (destination.kind === "OrchestratorPersonalWorkspace" /* OrchestratorPersonalWorkspace */) {
+      const folders = await this.feedsService.getFoldersForCurrentUserAsync(connection);
+      const personalFolder = folders.find((f) => f.feedType === ExtendedFolderDtoFeedTypeEnum.PersonalWorkspace);
+      if (!personalFolder) {
+        const foldersDebug = folders.length === 0 ? "<none>" : folders.map((f) => `${f.displayName} (id=${f.id}, feedType=${f.feedType})`).join(", ");
+        throw new Error(translate.t("solutionpackager.publish.errors.orchestratorPersonalWorkspaceFolderNotFound", { folders: foldersDebug }));
+      }
+      if (personalFolder.id == null) {
+        throw new Error(`Personal-workspace folder "${personalFolder.displayName}" has no id; cannot resolve its feed.`);
+      }
+      const match2 = feeds.find((f) => f.folderId === personalFolder.id);
+      if (!match2) {
+        this.throwFeedNotFound(destination, feeds);
+      }
+      return match2;
+    }
+    const expectedPurpose = destination.kind === "OrchestratorSharedLibraries" /* OrchestratorSharedLibraries */ ? PackageFeedDtoPurposeEnum.Libraries : PackageFeedDtoPurposeEnum.Processes;
+    const match = feeds.find((f) => f.purpose === expectedPurpose && f.folderId == null);
+    if (!match) {
+      this.throwFeedNotFound(destination, feeds);
+    }
+    return match;
+  }
+  throwFeedNotFound(destination, feeds) {
+    const available = feeds.length === 0 ? "<none>" : feeds.map((f) => `${f.name} (purpose=${f.purpose}, folderId=${f.folderId ?? "null"})`).join(", ");
+    throw new Error(translate.t("solutionpackager.publish.errors.orchestratorFeedNotFound", {
+      kind: destination.kind,
+      available
+    }));
+  }
+  buildPublishUrl(orchestratorUrl, feed) {
+    const baseUrl = feed.publishUrl ? feed.publishUrl : `${orchestratorUrl}${feed.purpose === PackageFeedDtoPurposeEnum.Libraries ? LIBRARIES_UPLOAD_PATH : PROCESSES_UPLOAD_PATH}`;
+    const parsed = new URL(baseUrl);
+    if (feed.id) {
+      parsed.searchParams.set("feedId", feed.id);
+    }
+    return parsed.toString();
+  }
+  deriveOrchestratorUrl(connectionInfo) {
+    const raw = connectionInfo.cloudUrl ?? "";
+    let end = raw.length;
+    while (end > 0 && raw.charCodeAt(end - 1) === 47)
+      end--;
+    return `${raw.slice(0, end)}${ORCHESTRATOR_RELATIVE_URL}`;
+  }
+  buildHeaders(destination, feed) {
+    const headers = this.buildAuthHeaders(destination.connectionInfo);
+    const folderHeader = destination.kind === "OrchestratorSharedLibraries" /* OrchestratorSharedLibraries */ ? destination.folderId : feed.folderId;
+    if (folderHeader != null) {
+      headers[HEADER_FOLDER_ID] = String(folderHeader);
+    }
+    if (feed.authenticationType === PackageFeedDtoAuthenticationTypeEnum.ApiKey && feed.apiKey) {
+      headers[HEADER_NUGET_API_KEY] = feed.apiKey;
+    }
+    return headers;
+  }
+  buildCustomHeaders(destination) {
+    const headers = this.buildAuthHeaders(destination.connectionInfo);
+    if (destination.folderId != null) {
+      headers[HEADER_FOLDER_ID] = String(destination.folderId);
+    }
+    if (destination.apiKey) {
+      headers[HEADER_NUGET_API_KEY] = destination.apiKey;
+    }
+    return headers;
+  }
+  buildAuthHeaders(connectionInfo) {
+    const headers = {};
+    if (connectionInfo.accessToken) {
+      headers.Authorization = `Bearer ${connectionInfo.accessToken}`;
+    }
+    if (connectionInfo.tenantId) {
+      headers[HEADER_TENANT_ID2] = connectionInfo.tenantId;
+    }
+    return headers;
+  }
+  async safeReadBody(response) {
+    try {
+      const text = await response.text();
+      return text.slice(0, 500);
+    } catch {
+      return "";
+    }
+  }
+}
+
+// ../packager/project-packager/src/publish/services/project-publisher.ts
+class ProjectPublisher {
+  fileSystem;
+  logger;
+  localFolderPublisher;
+  nugetFeedPublisher;
+  orchestratorPublisher;
+  constructor(fileSystem, publishers) {
+    this.fileSystem = fileSystem;
+    this.logger = new ToolLogger("ProjectPublisher", "Publish");
+    this.localFolderPublisher = publishers?.localFolder ?? new LocalFolderPublisher(fileSystem);
+    this.nugetFeedPublisher = publishers?.nugetFeed ?? new NugetFeedPublisher(fileSystem);
+    this.orchestratorPublisher = publishers?.orchestrator ?? new OrchestratorPublisher(fileSystem);
+  }
+  async publishAsync(options) {
+    if (!options.packagePaths || options.packagePaths.length === 0) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.atLeastOnePackage"));
+    }
+    for (const path of options.packagePaths) {
+      if (!await this.fileSystem.exists(path)) {
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.packageNotFound", { path }));
+      }
+    }
+    try {
+      const destination = options.destination;
+      switch (destination.kind) {
+        case "LocalFolder" /* LocalFolder */:
+          return await this.localFolderPublisher.publishAsync(options.packagePaths, destination);
+        case "NugetFeed" /* NugetFeed */:
+          return await this.nugetFeedPublisher.publishAsync(options.packagePaths, destination);
+        case "OrchestratorPersonalWorkspace" /* OrchestratorPersonalWorkspace */:
+        case "OrchestratorTenantProcesses" /* OrchestratorTenantProcesses */:
+        case "OrchestratorSharedLibraries" /* OrchestratorSharedLibraries */:
+        case "OrchestratorCustom" /* OrchestratorCustom */:
+          return await this.orchestratorPublisher.publishAsync(options.packagePaths, destination);
+        default: {
+          const exhaustive = destination;
+          return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.unknownDestination", { destination: JSON.stringify(exhaustive) }));
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const localized = translate.t("solutionpackager.publish.errors.publishFailed", { message });
+      this.logger.error(localized);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, localized);
+    }
+  }
+}
+
+// ../packager/project-packager/src/publish/node-project-publisher-factory.ts
+class NodeProjectPublisherFactory extends BaseNodePackagerFactory {
+  async createAsync(config) {
+    const logger = new ToolLogger("ProjectPublisherFactory", "Create");
+    this.configureLanguage(config);
+    this.configureLogHandler(config);
+    logger.info("Creating ProjectPublisher instance...");
+    const fileSystem = this.getOrCreateFileSystem(config);
+    this.getOrCreateTelemetryService(config);
+    const projectPublisher = new ProjectPublisher(fileSystem);
+    logger.info("ProjectPublisher created successfully.");
+    return projectPublisher;
+  }
+}
+async function createNodeProjectPublisher(options) {
+  const factory = new NodeProjectPublisherFactory;
+  return factory.createAsync(options);
+}
+export {
+  BaseNodePackagerFactory,
+  ConsoleTelemetryProvider,
+  DebugTelemetryProvider,
+  DotnetDiscoveryService,
+  GovernancePolicyService,
+  NodeContextStorage,
+  NodePackageSignService,
+  PACKAGE_ID_TOO_LONG,
+  PackService,
+  PackagerParameters,
+  PackagerParametersValidator,
+  ProjectBuildOptions,
+  ProjectBuildOptionsValidator,
+  ProjectCleanupOptions,
+  ProjectLoader,
+  ProjectPackOptions,
+  ProjectPackager,
+  ProjectPublishOptions,
+  ProjectPublisher,
+  ProjectRestoreOptions,
+  ProjectToolExecutor,
+  ProjectValidateOptions,
+  ProjectValidateOptionsValidator,
+  PublishDestinationKind,
+  RulesConfigFileType,
+  TelemetryNames,
+  TelemetryService,
+  ToolLogger,
+  ToolsFactory,
+  createNodeProjectPackager,
+  createNodeProjectPublisher,
+  isPackageIdTooLongError,
+  resolveProducedNupkgsAsync,
+  setGlobalLogHandler,
+  signNupkgsAsync
+};
+
+//# debugId=CCBE7042B2E00F9F64756E2164756E21