@uipath/case-tool 1.206.0-preview.291 → 1.206.0-preview.292

package/dist/packager-tool-jjkypwge.js

@@ -0,0 +1,1324 @@
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer-names.js
+var JsonSerializerNames2 = {
+  DefaultCaseInsensitive: "DefaultCaseInsensitive",
+  CaseInsensitive: "CaseInsensitive",
+  Indented: "Indented",
+  CamelCase: "CamelCase",
+  CaseInsensitiveIndented: "CaseInsensitiveIndented",
+  IndentedIgnoreNull: "IndentedIgnoreNull",
+  PreservePropertyNames: "PreservePropertyNames",
+  CamelCaseIndented: "CamelCaseIndented",
+  AllNames: [
+    "DefaultCaseInsensitive",
+    "CaseInsensitive",
+    "Indented",
+    "CamelCase",
+    "CaseInsensitiveIndented",
+    "IndentedIgnoreNull",
+    "PreservePropertyNames",
+    "CamelCaseIndented"
+  ]
+};
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer.js
+var VERBATIM_VALUE_PROPERTIES = new Set([
+  "spec"
+]);
+
+class JsonSerializer2 {
+  serialize(value) {
+    if (value == null)
+      return null;
+    let toSerialize = value;
+    if (this.options.ignoreNull)
+      toSerialize = this.removeNullValues(value);
+    if (this.options.camelCase && !this.options.preservePropertyNames)
+      toSerialize = this.toCamelCase(toSerialize);
+    if (this.options.enumCamelCase !== false)
+      toSerialize = this.convertEnumValuesToCamelCase(toSerialize);
+    const json = JSON.stringify(toSerialize, null, this.options.indented ? 2 : undefined);
+    return json;
+  }
+  async serializeAsync(stream, value, cancellationToken) {
+    cancellationToken?.throwIfAborted?.();
+    const json = this.serialize(value);
+    if (json === null)
+      return;
+    const writer = stream.getWriter();
+    try {
+      const bytes = this.encoder.encode(json);
+      await writer.write(bytes);
+    } finally {
+      writer.releaseLock();
+    }
+  }
+  serializeToUtf8Bytes(value) {
+    const json = this.serialize(value);
+    if (json === null)
+      return new Uint8Array(0);
+    return this.encoder.encode(json);
+  }
+  deserialize(value) {
+    if (value == null || value === "")
+      return null;
+    try {
+      let cleanValue = value.charCodeAt(0) === 65279 ? value.slice(1) : value;
+      if (cleanValue.charCodeAt(cleanValue.length - 1) === 26)
+        cleanValue = cleanValue.slice(0, -1);
+      const parsed = JSON.parse(cleanValue);
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  deserializeAsType(value, _type) {
+    return this.deserialize(value);
+  }
+  removeNullValues(obj) {
+    if (obj == null)
+      return obj;
+    if (Array.isArray(obj))
+      return obj.map((item) => this.removeNullValues(item));
+    if (typeof obj == "object") {
+      const result = {};
+      for (const [key, val] of Object.entries(obj))
+        if (val != null)
+          result[key] = this.removeNullValues(val);
+      return result;
+    }
+    return obj;
+  }
+  toCamelCase(obj) {
+    if (obj == null)
+      return obj;
+    if (Array.isArray(obj))
+      return obj.map((item) => this.toCamelCase(item));
+    if (typeof obj == "object") {
+      const result = {};
+      for (const [key, val] of Object.entries(obj)) {
+        const camelKey = key.charAt(0).toLowerCase() + key.slice(1);
+        result[camelKey] = this.toCamelCase(val);
+      }
+      return result;
+    }
+    return obj;
+  }
+  convertEnumValuesToCamelCase(obj, className) {
+    if (obj == null)
+      return obj;
+    if (typeof obj == "string")
+      return this.tryConvertEnumStringToCamelCase(obj, undefined, undefined);
+    if (Array.isArray(obj))
+      return obj.map((item) => this.convertEnumValuesToCamelCase(item, className));
+    if (typeof obj == "object") {
+      const result = {};
+      const currentClassName = obj.constructor?.name !== "Object" ? obj.constructor.name : className;
+      for (const [key, val] of Object.entries(obj))
+        if (VERBATIM_VALUE_PROPERTIES.has(key))
+          result[key] = val;
+        else if (typeof val == "string")
+          result[key] = this.tryConvertEnumStringToCamelCase(val, currentClassName, key);
+        else if (Array.isArray(val))
+          result[key] = val.map((item) => {
+            if (typeof item == "string")
+              return this.tryConvertEnumStringToCamelCase(item, currentClassName, key);
+            return this.convertEnumValuesToCamelCase(item, currentClassName);
+          });
+        else
+          result[key] = this.convertEnumValuesToCamelCase(val, currentClassName);
+      return result;
+    }
+    return obj;
+  }
+  tryConvertEnumStringToCamelCase(value, className, propertyName) {
+    if (this.camelCaseEnumProperties.size > 0) {
+      if (!propertyName || !this.isKnownCamelCaseEnum(className, propertyName))
+        return value;
+    } else if (propertyName && this.isInPropertySet(this.pascalCaseEnumProperties, className, propertyName))
+      return value;
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(value))
+      return value.charAt(0).toLowerCase() + value.slice(1);
+    return value;
+  }
+  isKnownCamelCaseEnum(className, propertyName) {
+    if (this.isInPropertySet(this.pascalCaseEnumProperties, className, propertyName))
+      return false;
+    return this.isInPropertySet(this.camelCaseEnumProperties, className, propertyName);
+  }
+  isInPropertySet(propertySet, className, propertyName) {
+    if (className && propertySet.has(`${className}.${propertyName}`))
+      return true;
+    return propertySet.has(propertyName);
+  }
+  constructor(options = {}) {
+    this.isContextBased = false;
+    this.encoder = new TextEncoder;
+    this.options = options;
+    this.camelCaseEnumProperties = new Set(options.camelCaseEnumProperties ?? []);
+    this.pascalCaseEnumProperties = new Set(options.pascalCaseEnumProperties ?? []);
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/pascal-case-enum-properties.js
+var CAMEL_CASE_ENUM_PROPERTIES2 = [
+  "scope",
+  "replaceOption",
+  "lookupStrategy",
+  "folderType"
+];
+var SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES2 = [
+  "propertyCategory"
+];
+var RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES2 = [
+  "ValidationState.errorSeverity",
+  "ValidationState.errorType",
+  "AddOrUpdateResourceToSolutionResponse.status",
+  "Overwrite.type",
+  "OverwriteValidationError.severity",
+  "ProjectResourceDescriptor.provisionType"
+];
+var PASCAL_CASE_ENUM_PROPERTIES2 = [
+  ...SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES2,
+  ...RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES2
+];
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer-factory.js
+class JsonSerializerFactory2 {
+  get() {
+    return this.defaultSerializer;
+  }
+  getByName(name) {
+    if (!name)
+      return this.defaultSerializer;
+    let serializer = this.namedSerializers.get(name);
+    if (!serializer) {
+      serializer = this.createNamedSerializer(name);
+      this.namedSerializers.set(name, serializer);
+    }
+    return serializer;
+  }
+  initializePredefinedSerializers() {
+    for (const name of JsonSerializerNames2.AllNames)
+      this.namedSerializers.set(name, this.createNamedSerializer(name));
+  }
+  createNamedSerializer(name) {
+    const options = this.createOptionsForName(name);
+    return new JsonSerializer2(options);
+  }
+  createOptionsForName(name) {
+    const options = {
+      ...this.baseOptions
+    };
+    switch (name) {
+      case JsonSerializerNames2.DefaultCaseInsensitive:
+        return {
+          caseInsensitive: true
+        };
+      case JsonSerializerNames2.CaseInsensitive:
+        options.caseInsensitive = true;
+        break;
+      case JsonSerializerNames2.Indented:
+        options.indented = true;
+        break;
+      case JsonSerializerNames2.CamelCase:
+        options.camelCase = true;
+        break;
+      case JsonSerializerNames2.CaseInsensitiveIndented:
+        options.caseInsensitive = true;
+        options.indented = true;
+        break;
+      case JsonSerializerNames2.IndentedIgnoreNull:
+        options.indented = true;
+        options.ignoreNull = true;
+        break;
+      case JsonSerializerNames2.PreservePropertyNames:
+        options.preservePropertyNames = true;
+        options.camelCase = false;
+        break;
+      case JsonSerializerNames2.CamelCaseIndented:
+        options.indented = true;
+        options.camelCase = true;
+        options.ignoreNull = true;
+        break;
+      default:
+        break;
+    }
+    return options;
+  }
+  constructor(options) {
+    const defaults = {
+      camelCase: true,
+      enumCamelCase: true,
+      camelCaseEnumProperties: CAMEL_CASE_ENUM_PROPERTIES2,
+      pascalCaseEnumProperties: PASCAL_CASE_ENUM_PROPERTIES2
+    };
+    this.baseOptions = options ? {
+      ...defaults,
+      ...options
+    } : defaults;
+    this.defaultSerializer = new JsonSerializer2(this.baseOptions);
+    this.namedSerializers = new Map;
+    this.initializePredefinedSerializers();
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/serializer-proxy.js
+class JsonSerializerProxy2 {
+  serialize(value) {
+    return this.jsonSerializer.serialize(value);
+  }
+  serializeAsync(stream, value, cancellationToken) {
+    return this.jsonSerializer.serializeAsync(stream, value, cancellationToken);
+  }
+  serializeToUtf8Bytes(value) {
+    return this.jsonSerializer.serializeToUtf8Bytes(value);
+  }
+  deserialize(value) {
+    return this.jsonSerializer.deserialize(value);
+  }
+  tryDeserializeObject(json) {
+    if (!json || json.trim() === "")
+      return null;
+    try {
+      return this.jsonSerializer.isContextBased ? this.jsonSerializer.deserialize(json) : this.caseInsensitiveSerializer.deserialize(json);
+    } catch (ex) {
+      this.logger.info("Deserialization failed with exception.", ex);
+      return null;
+    }
+  }
+  tryDeserialize(value) {
+    if (!value || value.trim() === "")
+      return [
+        false,
+        null
+      ];
+    try {
+      const result = this.jsonSerializer.deserialize(value);
+      return [
+        true,
+        result
+      ];
+    } catch (ex) {
+      this.logger.info("Deserialization failed with exception.", ex);
+      return [
+        false,
+        null
+      ];
+    }
+  }
+  constructor(jsonSerializerFactory, loggerFactory) {
+    this.jsonSerializer = jsonSerializerFactory.get();
+    this.caseInsensitiveSerializer = jsonSerializerFactory.getByName(JsonSerializerNames2.CaseInsensitive);
+    this.logger = loggerFactory.create("JsonSerializerProxy");
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/stream-serializer.js
+class StreamSerializer2 {
+  async serializeAsync(data, cancellationToken) {
+    cancellationToken?.throwIfAborted?.();
+    const serializer = this.jsonSerializerFactory.getByName(JsonSerializerNames2.PreservePropertyNames);
+    const serializedContent = serializer.serialize(data);
+    const encoder = new TextEncoder;
+    const bytes = serializedContent ? encoder.encode(serializedContent) : new Uint8Array(0);
+    let streamClosed = false;
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(bytes);
+        controller.close();
+        streamClosed = true;
+      }
+    });
+    const disposeStream = this.disposeStream;
+    return {
+      stream,
+      dispose() {
+        if (disposeStream && !streamClosed)
+          stream.cancel().catch(() => {});
+      }
+    };
+  }
+  constructor(jsonSerializerFactory, disposeStream = true) {
+    this.jsonSerializerFactory = jsonSerializerFactory;
+    this.disposeStream = disposeStream;
+  }
+}
+// ../../node_modules/@uipath/resource-builder-sdk/dist/exceptions/error-codes.js
+var ErrorCodes = {
+  UnknownException: "0000",
+  AuthorizationException: "0004",
+  AuthenticationFailed: "0004",
+  ResourceNotFound: "1000",
+  FolderNotFound: "1001",
+  ResourcesNotFound: "1002",
+  ResourceLinkRemovedFromSource: "1003",
+  ImportCancelled: "1005",
+  InvalidBindings: "1006",
+  FileNotFound: "1008",
+  BindingsFileNotFound: "1010",
+  BindingsResourceCannotBeOverridden: "1011",
+  BindingsResourceNotFound: "1012",
+  NullOrEmptyAccessToken: "1013",
+  InvalidInput: "InvalidInput",
+  InvalidConfiguration: "InvalidConfiguration",
+  Resources: {
+    InvalidApiVersion: "2001",
+    InvalidName: "2002",
+    DuplicateProperties: "2003",
+    DuplicateResourceName: "2004",
+    PropertyIsRequired: "2005",
+    ChoiceTypeMissingOrInvalid: "2006",
+    InvalidPropertyType: "2007",
+    InvalidEnumValue: "2008",
+    InvalidChoiceValue: "2009",
+    RegularExpressionDoesNotMatch: "2010",
+    InvalidMultiselectValue: "2011",
+    ValueOutOfRange: "2012",
+    DeletingHiddenResourceIsNotAllowed: "2013",
+    InvalidResourceMetadataIdentifier: "2014",
+    DeletingProjectArtefactResourceIsNotAllowed: "2015",
+    ResourceHasNoFile: "2017",
+    InvalidResourceType: "2018",
+    DeletingResourceThatIsReferencedByOtherResourcesIsNotAllowed: "2019",
+    SyncingProcessArtefactResourceIsNotAllowed: "2020",
+    MissingDependencies: "2021",
+    MissingFileDependencies: "2022",
+    ResourceAttributeMismatch: "2023",
+    AppSystemNameConflict: "2024",
+    InvalidResourceFile: "2025",
+    DuplicatePackageName: "2026",
+    TooManySearchKinds: "2027",
+    SearchTypesWithSeveralKinds: "2028",
+    ResourceNotFound: "1000",
+    ResourceAlreadyExists: "Resources.ResourceAlreadyExists",
+    ResourceDependencyNotFound: "Resources.ResourceDependencyNotFound",
+    FileDependencyNotFound: "Resources.FileDependencyNotFound",
+    PropertyInvalidFormat: "Resources.PropertyInvalidFormat",
+    PropertyInvalidValue: "Resources.PropertyInvalidValue"
+  },
+  Solutions: {
+    ConfigurationNotFound: "3002",
+    SolutionNotFound: "3001",
+    SolutionInvalidState: "Solution.SolutionInvalidState",
+    SolutionReadOnly: "Solution.SolutionReadOnly"
+  },
+  Metadata: {
+    ResourceMetadataNotFound: "5001"
+  },
+  Project: {
+    ProjectNotFound: "Project.ProjectNotFound",
+    ProjectAlreadyExists: "Project.ProjectAlreadyExists",
+    ProjectInvalidType: "Project.ProjectInvalidType"
+  }
+};
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/exceptions/bad-request-exception.js
+class BadRequestException extends Error {
+  static create(errorCode, message, ...params) {
+    const formattedMessage = formatMessage(message, params);
+    return new BadRequestException(errorCode, formattedMessage);
+  }
+  constructor(errorCode, message, exceptionData) {
+    super(message);
+    this.name = "BadRequestException";
+    this.errorCode = errorCode;
+    this.exceptionData = exceptionData;
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, BadRequestException);
+  }
+}
+function formatMessage(template, params) {
+  return template.replace(/{(\d+)}/g, (match, index) => {
+    const paramIndex = parseInt(index, 10);
+    if (paramIndex < params.length) {
+      const param = params[paramIndex];
+      return param != null ? String(param) : "";
+    }
+    return match;
+  });
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/exceptions/invalid-operation-exception.js
+class InvalidOperationException extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidOperationException";
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, InvalidOperationException);
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/services/metadata/types.js
+var types_ResourceScope = /* @__PURE__ */ function(ResourceScope) {
+  ResourceScope["Folder"] = "Folder";
+  ResourceScope["Tenant"] = "Tenant";
+  ResourceScope["FolderAndTenant"] = "FolderAndTenant";
+  return ResourceScope;
+}({});
+function toResourceIdentifier(metadata, version) {
+  return {
+    kind: metadata.kind,
+    type: metadata.type,
+    version: version.version.uri
+  };
+}
+function toServiceName(version) {
+  return version.version.uri.split("/")[0] ?? "";
+}
+function getVersionOrDefault(metadata, apiVersion) {
+  if (!apiVersion)
+    return metadata.versions.find((v) => v.version.isCurrent);
+  return metadata.versions.find((v) => v.version.uri.toLowerCase() === apiVersion.toLowerCase());
+}
+var REFERENCE_TYPE = "reference";
+var FILE_REFERENCE_TYPE = "fileReference";
+var SECRET_TYPE = "secret";
+var ARRAY_TYPE = "array";
+var FILE_KIND = "file";
+function isSingleReferenceProperty(p) {
+  return p.type === REFERENCE_TYPE || p.type === FILE_REFERENCE_TYPE;
+}
+function isListOfReferenceProperties(p) {
+  return p.type === ARRAY_TYPE && p["arrayResourceType"] === REFERENCE_TYPE;
+}
+function isAnyReferenceProperty(p) {
+  return isSingleReferenceProperty(p) || isListOfReferenceProperties(p);
+}
+function isSecretProperty(p) {
+  return p.type === SECRET_TYPE;
+}
+var NAME_PROPERTY = "name";
+function isNameProperty(p) {
+  return p.property.toLowerCase() === NAME_PROPERTY;
+}
+function isFileReferenceProperty(p) {
+  return p.type === FILE_REFERENCE_TYPE && p["referenceKind"] === FILE_KIND;
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/solution/resource-definition-extensions.js
+var WellKnownProjectType = {
+  WebApp: "webapp",
+  Process: "process"
+};
+var WellKnownPropertyNames = {
+  Name: "name",
+  PackageName: "packageName",
+  Description: "description",
+  UiappFile: "uiappFile"
+};
+var ExcludedKindsAndTypes = [
+  "webapp"
+];
+var FailOnNameConflictKinds = [
+  "entity"
+];
+function toResourceIdentifier2(resource, trimVersion = false, ignoreType = false) {
+  return {
+    kind: resource.kind,
+    type: ignoreType ? undefined : resource.type,
+    version: trimVersion ? trimVersionString(resource.apiVersion) : resource.apiVersion
+  };
+}
+function trimVersionString(version) {
+  if (!version)
+    return version;
+  const slashIndex = version.indexOf("/");
+  if (slashIndex === -1)
+    return version;
+  return version.substring(0, slashIndex);
+}
+function isExcluded(resource) {
+  const type = resource.type?.trim().toLowerCase();
+  const kind = resource.kind?.trim().toLowerCase();
+  return type !== undefined && ExcludedKindsAndTypes.some((e) => e.toLowerCase() === type) || kind !== undefined && ExcludedKindsAndTypes.some((e) => e.toLowerCase() === kind);
+}
+function isVisible(resource, resourceMetadata) {
+  return resourceMetadata.visibleInDesigner && resourceMetadata.scope !== "Tenant" && !isExcluded(resource);
+}
+function filterVisibleFolderResources(resources, metadata) {
+  return resources.filter((resource) => {
+    const resourceMetadata = findMetadataForResource(resource, metadata);
+    return resourceMetadata && isVisible(resource, resourceMetadata);
+  }).map((resource) => ({
+    ...resource
+  }));
+}
+function filterHiddenResourceKeys(resources, metadata) {
+  const result = new Set;
+  for (const resource of resources) {
+    const resourceMetadata = findMetadataForResource(resource, metadata);
+    if (resourceMetadata && !isVisible(resource, resourceMetadata))
+      result.add(resource.key);
+  }
+  return result;
+}
+function filterHiddenUnsupportingDebugProvisioningKeys(resources, metadata) {
+  const result = new Set;
+  for (const resource of resources) {
+    const resourceMetadata = findMetadataForResource(resource, metadata);
+    if (resourceMetadata && !resourceMetadata.supportsDebugProvisioning && !isVisible(resource, resourceMetadata))
+      result.add(resource.key);
+  }
+  return result;
+}
+function supportsDebugProvisioningWithDependencies(solutionResource, directDependencies, resourceMetadata, metadata) {
+  if (!resourceMetadata || !resourceMetadata.supportsDebugProvisioning)
+    return false;
+  return !directDependencies.some((dependency) => {
+    const dependencyMetadata = findMetadataForResource(dependency, metadata);
+    return dependencyMetadata !== undefined && !dependencyMetadata.supportsDebugProvisioning && !isVisible(dependency, dependencyMetadata);
+  });
+}
+function supportsDebugProvisioning(solutionResource, solution, resourceMetadata, hiddenUnsupportingDebugProvisioningKeys) {
+  if (!resourceMetadata || !resourceMetadata.supportsDebugProvisioning)
+    return false;
+  const dependencies = solutionResource.dependencies ?? [];
+  for (const dependency of dependencies) {
+    const dependentResource = getResource(solution, dependency.name, dependency.kind);
+    if (dependentResource && hiddenUnsupportingDebugProvisioningKeys.has(dependentResource.key))
+      return false;
+  }
+  return true;
+}
+function isProcessArtefact(processResource) {
+  return processResource.isArtefactResource === true && processResource.kind.toLowerCase() === WellKnownProjectType.Process.toLowerCase();
+}
+var PACKAGE_NAME_MAX_LENGTH = 100;
+var PACKAGE_NAME_SEPARATION_CHARS = 2;
+var processTypeToPackageTypeMap = {
+  processorchestration: "agentic"
+};
+function truncate(str, maxLength) {
+  if (!str)
+    return "";
+  return str.length <= maxLength ? str : str.substring(0, maxLength);
+}
+function sanitizeNuGetPackageName(packageName) {
+  let result = packageName.trim();
+  result = result.replace(/\s/g, ".");
+  result = result.replace(/[^a-zA-Z0-9.\-]/g, "_");
+  result = result.replace(/^[.\-]+|[.\-]+$/g, "");
+  result = result.replace(/-{2,}/g, "-");
+  result = result.replace(/-\./g, ".");
+  result = result.replace(/\.-/g, ".");
+  result = result.replace(/\.{2,}/g, ".");
+  if (result === "")
+    result = "_";
+  return result;
+}
+function getPackageType(processResourceType) {
+  if (!processResourceType)
+    return processResourceType;
+  return processTypeToPackageTypeMap[processResourceType.toLowerCase()] ?? processResourceType;
+}
+function generatePackageName(solutionName, projectName, processResourceType) {
+  const packageType = getPackageType(processResourceType) ?? "";
+  const truncateCharsNo = Math.floor((PACKAGE_NAME_MAX_LENGTH - PACKAGE_NAME_SEPARATION_CHARS - packageType.length) / 2);
+  return sanitizeNuGetPackageName(`${truncate(solutionName, truncateCharsNo)}.${packageType}.${truncate(projectName, truncateCharsNo)}`);
+}
+function resolvePackageNameAfterRename(processResource, solutionName, projectName, oldSolutionName, oldProjectName) {
+  const currentPackageName = processResource.spec?.[WellKnownPropertyNames.PackageName];
+  if (!solutionName)
+    return currentPackageName ?? undefined;
+  const oldGeneratedPackageName = generatePackageName(oldSolutionName ?? "", oldProjectName ?? processResource.name, processResource.type);
+  return currentPackageName && currentPackageName.toLowerCase() !== oldGeneratedPackageName.toLowerCase() ? currentPackageName : generatePackageName(solutionName, projectName, processResource.type);
+}
+function findPackageNameConflict(solution, projectKey, solutionName, packageName) {
+  if (!packageName)
+    return;
+  const wanted = packageName.toLowerCase();
+  return solution.resources.find((resource) => resource.projectKey !== undefined && resource.projectKey !== projectKey && resource.kind.toLowerCase() === WellKnownProjectType.Process.toLowerCase() && effectivePackageName(resource, solutionName)?.toLowerCase() === wanted);
+}
+function effectivePackageName(processResource, solutionName) {
+  const packageName = processResource.spec?.[WellKnownPropertyNames.PackageName];
+  if (packageName)
+    return packageName;
+  return solutionName ? generatePackageName(solutionName, processResource.name, processResource.type) : undefined;
+}
+function changePackageName(processResource, solutionName, projectName, oldSolutionName, oldProjectName) {
+  if (!solutionName)
+    return false;
+  const spec = processResource.spec ?? {};
+  if (!(WellKnownPropertyNames.PackageName in spec))
+    spec[WellKnownPropertyNames.PackageName] = null;
+  processResource.spec = spec;
+  const currentPackageName = spec[WellKnownPropertyNames.PackageName];
+  const newPackageName = generatePackageName(solutionName, projectName, processResource.type);
+  const projectNameForOldPackage = oldProjectName ?? processResource.name;
+  const oldGeneratedPackageName = generatePackageName(oldSolutionName ?? "", projectNameForOldPackage, processResource.type);
+  if (!currentPackageName || currentPackageName.toLowerCase() === oldGeneratedPackageName.toLowerCase()) {
+    spec[WellKnownPropertyNames.PackageName] = newPackageName;
+    renamePackageDependencies(processResource, projectNameForOldPackage, projectName);
+    return true;
+  }
+  return false;
+}
+function renamePackageDependencies(processResource, oldProjectName, newProjectName) {
+  if (oldProjectName.toLowerCase() === newProjectName.toLowerCase())
+    return;
+  if (!processResource.dependencies)
+    return;
+  for (const dep of processResource.dependencies)
+    if (dep.kind.toLowerCase() === "package" && dep.name.toLowerCase() === oldProjectName.toLowerCase())
+      dep.name = newProjectName;
+}
+function getDefaultValue(property) {
+  const value = property.defaultValue;
+  return value !== null && typeof value == "object" ? structuredClone(value) : value;
+}
+function buildDefaultConfiguration(resource, properties) {
+  const spec = {};
+  for (const prop of properties ?? [])
+    spec[prop.property] = getDefaultValue(prop);
+  if (WellKnownPropertyNames.Name in spec)
+    spec[WellKnownPropertyNames.Name] = resource.name;
+  resource.spec = spec;
+  resource.locks = [];
+}
+function isDependencyToResource(resource, dependency) {
+  return resource.name.trim().toLowerCase() === dependency.name.trim().toLowerCase() && resource.kind.trim().toLowerCase() === dependency.kind.trim().toLowerCase();
+}
+function findResourcesWithReference(solution, resource) {
+  return (solution.resources ?? []).filter((r) => r !== resource && (r.dependencies ?? []).some((d) => isDependencyToResource(resource, d)));
+}
+function findResourceDependencies(solution, resource, throwIfMissing = true) {
+  const result = new Map;
+  const dependencies = resource.dependencies ?? [];
+  if (dependencies.length === 0)
+    return result;
+  const notFound = [];
+  for (const dependency of dependencies) {
+    const found = (solution.resources ?? []).find((r) => isDependencyToResource(r, dependency));
+    if (found)
+      result.set(dependency, found);
+    else
+      notFound.push(dependency);
+  }
+  if (notFound.length > 0 && throwIfMissing) {
+    const names = notFound.map((d) => d.name).join(", ");
+    throw new Error(`One or more resource dependencies were not found in the solution. Names: ${names}`);
+  }
+  return result;
+}
+function getSpecReferences(propertyValue) {
+  if (propertyValue == null)
+    return [];
+  if (Array.isArray(propertyValue))
+    return propertyValue.filter((v) => v != null && typeof v == "object");
+  if (typeof propertyValue == "object")
+    return [
+      propertyValue
+    ];
+  return [];
+}
+function specReferenceToObject(ref) {
+  const r = ref;
+  const result = {};
+  if (r["name"] !== undefined)
+    result["name"] = r["name"];
+  if (r["key"] !== undefined)
+    result["key"] = r["key"];
+  if (r["folderKey"] !== undefined)
+    result["folderKey"] = r["folderKey"];
+  if (r["lookupStrategy"] !== undefined)
+    result["lookupStrategy"] = r["lookupStrategy"];
+  if (r["info"] !== undefined)
+    result["info"] = r["info"];
+  return result;
+}
+function updateReferenceProps(resource, referenceKind, newName, isMatch, metadata) {
+  const spec = resource.spec;
+  if (!spec)
+    return;
+  const referenceProperties = (metadata.spec ?? []).filter((x) => isAnyReferenceProperty(x) && !isFileReferenceProperty(x));
+  for (const refProp of referenceProperties) {
+    const propertyValue = spec[refProp.property];
+    if (propertyValue == null)
+      continue;
+    const references = getSpecReferences(propertyValue);
+    const firstReference = references[0];
+    if (firstReference == null)
+      continue;
+    const refKind = refProp["referenceKind"];
+    const refKindStr = typeof refKind == "string" ? refKind : null;
+    for (const reference of references)
+      if (isMatch(reference) && refKindStr != null && invariantEquals(refKindStr, referenceKind))
+        reference.name = newName;
+    spec[refProp.property] = isSingleReferenceProperty(refProp) ? specReferenceToObject(firstReference) : references.map(specReferenceToObject);
+  }
+}
+function cloneResourceDefinition(resource) {
+  return {
+    ...resource,
+    dependencies: resource.dependencies?.map((dependency) => ({
+      ...dependency
+    })),
+    runtimeDependencies: resource.runtimeDependencies?.map(cloneRuntimeDependency),
+    files: resource.files?.map((file) => ({
+      ...file
+    })),
+    folders: resource.folders?.map((folder) => ({
+      ...folder
+    })),
+    spec: resource.spec ? {
+      ...resource.spec
+    } : undefined,
+    locks: resource.locks ? [
+      ...resource.locks
+    ] : undefined
+  };
+}
+function cloneRuntimeDependency(dependency) {
+  return {
+    ...dependency,
+    bindingValues: dependency.bindingValues ? {
+      ...dependency.bindingValues
+    } : undefined
+  };
+}
+function resourceNameIdentity(kind, name) {
+  return `${(kind ?? "").toLowerCase()}:${(name ?? "").toLowerCase()}`;
+}
+function getResource(solutionDefinition, name, kind) {
+  return solutionDefinition.resources.find((r) => r.name.toLowerCase() === name.toLowerCase() && r.kind.toLowerCase() === kind.toLowerCase());
+}
+function getResourceOrDefault(solutionDefinition, resourceKey) {
+  return solutionDefinition.resources.find((r) => r.key === resourceKey);
+}
+function findMetadataForResource(resource, metadata) {
+  const key = getResourceIdentifierKey(resource);
+  const exactMatch = metadata.get(key);
+  if (exactMatch)
+    return exactMatch;
+  for (const [mapKey, value] of metadata)
+    if (mapKey.toLowerCase() === key.toLowerCase())
+      return value;
+}
+function getResourceIdentifierKey(resource) {
+  return `${resource.kind}|${resource.type ?? ""}|${resource.apiVersion}`.toLowerCase();
+}
+function invariantEquals(a, b) {
+  if (a == null && b == null)
+    return true;
+  if (a == null || b == null)
+    return false;
+  return a.toLowerCase() === b.toLowerCase();
+}
+function getResourceNumber(resourceName) {
+  const match = resourceName.match(/_(\d+)$/);
+  return match?.[1] ? parseInt(match[1], 10) : 0;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function addResource(solution, resource) {
+  if (solution.resources.some((x) => x.key === resource.key))
+    throw new Error(`Cannot add resource (${resource.kind}, ${resource.name}) to solution due to duplicate key ${resource.key}`);
+  solution.resources.push(resource);
+}
+function addResourceWithUniqueName(solution, resource) {
+  resource.originalName = resource.name;
+  const exactNameTaken = solution.resources.some((r) => r.name.toLowerCase() === resource.name.toLowerCase() && r.kind.toLowerCase() === resource.kind.toLowerCase());
+  if (exactNameTaken) {
+    const escapedName = escapeRegex(resource.name);
+    const sameNameRegex = new RegExp(`^${escapedName}(_\\d+)?$`, "i");
+    const matchingResources = solution.resources.filter((r) => sameNameRegex.test(r.name) && r.kind.toLowerCase() === resource.kind.toLowerCase());
+    const lastResourceNumber = Math.max(...matchingResources.map((x) => getResourceNumber(x.name)));
+    resource.name += `_${lastResourceNumber + 1}`;
+    if (resource.spec && WellKnownPropertyNames.Name in resource.spec)
+      resource.spec[WellKnownPropertyNames.Name] = resource.name;
+  }
+  addResource(solution, resource);
+  return resource;
+}
+function upsertFile(solution, file) {
+  const existing = solution.files.find((x) => x.key === file.key);
+  if (!existing) {
+    solution.files.push(file);
+    return true;
+  }
+  updateResourceFileDependencies(solution, existing, file);
+  existing.name = file.name;
+  existing.kind = file.kind;
+  existing.version = file.version;
+  existing.url = file.url;
+  return false;
+}
+function updateResourceFileDependencies(solution, existing, updated) {
+  if (invariantEquals(existing.name, updated.name) && invariantEquals(existing.kind, updated.kind))
+    return;
+  for (const resource of solution.resources) {
+    const files = resource.files ?? [];
+    const remaining = files.filter((f) => !(invariantEquals(f.fileName, existing.name) && invariantEquals(f.kind, existing.kind)));
+    if (remaining.length !== files.length) {
+      if (!remaining.some((f) => invariantEquals(f.fileName, updated.name) && invariantEquals(f.kind, updated.kind)))
+        remaining.push({
+          fileName: updated.name,
+          kind: updated.kind
+        });
+      resource.files = remaining;
+    }
+  }
+}
+function getRootFolder(solution) {
+  const rootFolderKey = solution.items?.["RootFolderKey"] ?? solution.key;
+  return solution.folders.find((f) => f.key === rootFolderKey) ?? solution.folders.find((f) => f.key === solution.key) ?? solution.folders[0];
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/helpers/solution-definition-helper.js
+var VISIBLE_DEPENDENCIES_TO_DELETE = [
+  {
+    source: {
+      kind: "app",
+      type: undefined,
+      version: "apps.uipath.com/v1"
+    },
+    cascade: [
+      {
+        kind: "process",
+        type: "webApp",
+        version: "orchestrator.uipath.com/v1"
+      }
+    ]
+  }
+];
+function resourceIdentifierMatches(a, b) {
+  return invariantEquals(a.kind, b.kind) && invariantEquals(a.type ?? "", b.type ?? "") && invariantEquals(a.version, b.version);
+}
+function metadataMapKey(id) {
+  return `${id.kind}|${id.type ?? ""}|${id.version}`.toLowerCase();
+}
+function droppedNameKey(name, kind) {
+  return `${name}|${kind.toLowerCase()}`;
+}
+function resourceMetadataKey(resource) {
+  return `${resource.kind}|${resource.type ?? ""}|${resource.apiVersion}`.toLowerCase();
+}
+
+class SolutionDefinitionHelper2 {
+  async verifyIfResourceCanBeDeletedAsync(solution, resourceToDelete, allowProjectResourceDelete, cancellationToken) {
+    if (!allowProjectResourceDelete) {
+      if (resourceToDelete.projectKey != null) {
+        this.logger.error("Project artefact resource with key cannot be deleted", undefined, {
+          key: resourceToDelete.key
+        });
+        throw new BadRequestException(ErrorCodes.Resources.DeletingProjectArtefactResourceIsNotAllowed, `Deleting project artefact resource with key '${resourceToDelete.key}' is not allowed`);
+      }
+      const referencing = findResourcesWithReference(solution, resourceToDelete);
+      if (referencing.length > 0) {
+        this.logger.error("Resource cannot be deleted because it is referenced by other resources", undefined, {
+          key: resourceToDelete.key
+        });
+        const names = referencing.map((r) => r.name).join(", ");
+        throw new BadRequestException(ErrorCodes.Resources.DeletingResourceThatIsReferencedByOtherResourcesIsNotAllowed, `Resource '${resourceToDelete.name}' cannot be deleted because it is referenced by: ${names}`);
+      }
+    }
+    const metadataByKey = await this.loadMetadataMapAsync(solution, cancellationToken);
+    const metadata = findMetadataForResource(resourceToDelete, metadataByKey);
+    if (metadata && !metadata.visibleInDesigner) {
+      this.logger.error("Hidden resource with key cannot be deleted", undefined, {
+        key: resourceToDelete.key
+      });
+      throw new BadRequestException(ErrorCodes.Resources.DeletingHiddenResourceIsNotAllowed, `Deleting hidden resource with key '${resourceToDelete.key}' is not allowed`);
+    }
+  }
+  getResourcesToDelete(solution, resourceToDelete) {
+    const result = [
+      resourceToDelete
+    ];
+    const sourceId = toResourceIdentifier2(resourceToDelete);
+    const cascadeEntry = VISIBLE_DEPENDENCIES_TO_DELETE.find((e) => resourceIdentifierMatches(e.source, sourceId));
+    if (!cascadeEntry || cascadeEntry.cascade.length === 0)
+      return result;
+    const dependencies = findResourceDependencies(solution, resourceToDelete, false);
+    for (const depResource of dependencies.values()) {
+      const depId = toResourceIdentifier2(depResource);
+      if (cascadeEntry.cascade.some((c) => resourceIdentifierMatches(c, depId))) {
+        for (const r of this.getResourcesToDelete(solution, depResource))
+          if (!result.some((x) => x.key === r.key))
+            result.push(r);
+      }
+    }
+    return result;
+  }
+  async removeReferencesAsync(solution, resource, cancellationToken) {
+    const referencing = findResourcesWithReference(solution, resource);
+    if (referencing.length === 0)
+      return;
+    const referencingIdentifiers = referencing.map((r) => toResourceIdentifier2(r));
+    const metadataMap = await this.metadataReader.getResourcesMetadataAsync(referencingIdentifiers, cancellationToken);
+    const metadataByKey = new Map;
+    for (const [id, version] of metadataMap)
+      metadataByKey.set(metadataMapKey(id), version);
+    for (const referencingResource of referencing) {
+      if (referencingResource.dependencies && referencingResource.dependencies.length > 0)
+        referencingResource.dependencies = referencingResource.dependencies.filter((d) => !isDependencyToResource(resource, d) || (solution.resources ?? []).some((r) => r !== resource && isDependencyToResource(r, d)));
+      const metadata = metadataByKey.get(resourceMetadataKey(referencingResource));
+      if (!metadata)
+        continue;
+      const referenceProps = (metadata.spec ?? []).filter((p) => isAnyReferenceProperty(p) && !isFileReferenceProperty(p));
+      const spec = referencingResource.spec ?? {};
+      for (const refProp of referenceProps) {
+        if (!(refProp.property in spec))
+          continue;
+        const propertyValue = spec[refProp.property];
+        const references = this.extractReferences(propertyValue);
+        if (references.length === 0)
+          continue;
+        const referenceKind = refProp["referenceKind"];
+        const matches = (ref) => ref.name != null && invariantEquals(resource.name, ref.name) && referenceKind != null && invariantEquals(referenceKind, resource.kind);
+        const filtered = references.filter((r) => !matches(r));
+        if (filtered.length !== references.length)
+          spec[refProp.property] = isSingleReferenceProperty(refProp) ? filtered[0] ?? null : filtered;
+      }
+      referencingResource.spec = spec;
+    }
+  }
+  async removeHiddenResourcesWithNoRefAsync(solution, resourceToDelete, cancellationToken) {
+    const metadataByKey = await this.loadMetadataMapAsync(solution, cancellationToken);
+    const hiddenKeys = filterHiddenResourceKeys(solution.resources, metadataByKey);
+    return this.removeHiddenResourcesWithNoRefRecursive(solution, resourceToDelete, hiddenKeys);
+  }
+  removeFilesWithNoRef(solution) {
+    const remaining = [];
+    const removed = [];
+    for (const file of solution.files ?? [])
+      if (this.findResourcesForFile(solution, file).length === 0) {
+        this.logger.warn(`File '${file.name}' (kind '${file.kind}', key '${file.key}') is not referenced by any resource`, {
+          name: file.name,
+          kind: file.kind,
+          key: file.key
+        });
+        removed.push(file);
+      } else
+        remaining.push(file);
+    if (removed.length > 0) {
+      this.logger.info("Files removed: " + removed.map((f) => f.name).join(","), {
+        files: removed.map((f) => f.name)
+      });
+      solution.files = remaining;
+    }
+    return removed;
+  }
+  findResourcesForFile(solution, file) {
+    let matching = (solution.resources ?? []).filter((r) => (r.files ?? []).some((f) => invariantEquals(f.fileName, file.name) && invariantEquals(f.kind, file.kind)));
+    if (invariantEquals(file.kind, "appversion"))
+      matching = matching.filter((r) => invariantEquals(r.kind, "appversion")).filter((r) => {
+        const uiappFile = r.spec?.[WellKnownPropertyNames.UiappFile];
+        return uiappFile != null && invariantEquals(String(uiappFile), file.key);
+      });
+    return matching;
+  }
+  async replaceDuplicateKeysAsync(solution, cancellationToken) {
+    const resources = solution.resources ?? [];
+    const byKey = new Map;
+    for (const resource of resources) {
+      const group = byKey.get(resource.key);
+      if (group)
+        group.push(resource);
+      else
+        byKey.set(resource.key, [
+          resource
+        ]);
+    }
+    const survivorNameByDroppedName = new Map;
+    const affectedProjectKeys = new Set;
+    const dropped = new Set;
+    for (const [key, group] of byKey) {
+      if (group.length < 2)
+        continue;
+      const [survivor, ...duplicates] = group;
+      for (const duplicate of duplicates) {
+        survivorNameByDroppedName.set(droppedNameKey(duplicate.name, duplicate.kind), survivor?.name ?? duplicate.name);
+        this.logger.warn(`Removing duplicate resource key '${key}' with kind '${duplicate.kind}'`);
+        dropped.add(duplicate);
+        if (duplicate.projectKey)
+          affectedProjectKeys.add(duplicate.projectKey);
+      }
+    }
+    if (dropped.size === 0)
+      return [];
+    solution.resources = resources.filter((resource) => !dropped.has(resource));
+    const metadata = await this.loadMetadataMapAsync(solution, cancellationToken);
+    for (const resource of solution.resources)
+      if ((resource.dependencies ?? []).length !== 0) {
+        this.repointDependencies(resource, survivorNameByDroppedName);
+        this.repointSpecReferences(resource, survivorNameByDroppedName, metadata);
+      }
+    return [
+      ...affectedProjectKeys
+    ];
+  }
+  repointDependencies(resource, survivorNameByDroppedName) {
+    for (const dependency of resource.dependencies ?? []) {
+      const survivorName = survivorNameByDroppedName.get(droppedNameKey(dependency.name, dependency.kind));
+      if (survivorName !== undefined)
+        dependency.name = survivorName;
+    }
+  }
+  repointSpecReferences(resource, survivorNameByDroppedName, metadata) {
+    const metadataVersion = metadata.get(resourceMetadataKey(resource));
+    if (!metadataVersion)
+      throw new InvalidOperationException(`Cannot resolve duplicate resource keys for solution ${resource.key}: no metadata for kind '${resource.kind}', type '${resource.type ?? ""}', version '${resource.apiVersion}'`);
+    const spec = resource.spec;
+    if (!spec)
+      return;
+    const referenceProps = (metadataVersion.spec ?? []).filter((p) => isAnyReferenceProperty(p) && !isFileReferenceProperty(p));
+    for (const refProp of referenceProps) {
+      const referenceKind = refProp["referenceKind"];
+      if (referenceKind !== undefined && refProp.property in spec)
+        for (const reference of this.extractReferences(spec[refProp.property])) {
+          if (typeof reference.name != "string")
+            continue;
+          const survivorName = survivorNameByDroppedName.get(droppedNameKey(reference.name, referenceKind));
+          if (survivorName !== undefined)
+            reference.name = survivorName;
+        }
+    }
+  }
+  async loadMetadataMapAsync(solution, cancellationToken) {
+    const allIdentifiers = (solution.resources ?? []).map((r) => toResourceIdentifier2(r));
+    const metadataMap = await this.metadataReader.getResourcesMetadataAsync(allIdentifiers, cancellationToken);
+    const result = new Map;
+    for (const [id, version] of metadataMap)
+      result.set(metadataMapKey(id), version);
+    return result;
+  }
+  extractReferences(value) {
+    if (Array.isArray(value))
+      return value.filter((v) => v != null && typeof v == "object");
+    if (value != null && typeof value == "object")
+      return [
+        value
+      ];
+    return [];
+  }
+  removeHiddenResourcesWithNoRefRecursive(solution, resourceToDelete, hiddenKeys) {
+    const toRemove = new Set((solution.resources ?? []).filter((r) => hiddenKeys.has(r.key) && findResourcesWithReference(solution, r).length === 0));
+    this.collectDeletableHiddenResourcesForResourceToDelete(solution, resourceToDelete, hiddenKeys, toRemove);
+    if (toRemove.size > 0) {
+      solution.resources = (solution.resources ?? []).filter((r) => !toRemove.has(r));
+      const further = this.removeHiddenResourcesWithNoRefRecursive(solution, resourceToDelete, hiddenKeys);
+      for (const r of further)
+        toRemove.add(r);
+    }
+    return toRemove;
+  }
+  collectDeletableHiddenResourcesForResourceToDelete(solution, resourceToDelete, hiddenKeys, toRemove) {
+    if (!resourceToDelete)
+      return;
+    for (const dependency of resourceToDelete.dependencies ?? []) {
+      const candidates = (solution.resources ?? []).filter((r) => r.projectKey === resourceToDelete.projectKey && hiddenKeys.has(r.key) && isDependencyToResource(r, dependency));
+      for (const candidate of candidates)
+        if (!toRemove.has(candidate)) {
+          if (this.noOtherResourceInProjectReferencesDependency(solution, resourceToDelete, dependency))
+            toRemove.add(candidate);
+        }
+    }
+  }
+  noOtherResourceInProjectReferencesDependency(solution, resourceToDelete, dependency) {
+    return !(solution.resources ?? []).some((r) => r !== resourceToDelete && r.projectKey === resourceToDelete.projectKey && (r.dependencies ?? []).some((dep) => invariantEquals(dep.name.trim(), dependency.name.trim()) && invariantEquals(dep.kind.trim(), dependency.kind.trim())));
+  }
+  constructor(metadataReader, logger) {
+    this.metadataReader = metadataReader;
+    this.logger = logger;
+  }
+}
+// ../../node_modules/@uipath/resource-builder-sdk/dist/clients/generated/first-party-service.js
+class HttpClient {
+  encodeQueryParam(key, value) {
+    const encodedKey = encodeURIComponent(key);
+    return `${encodedKey}=${encodeURIComponent(typeof value == "number" ? value : `${value}`)}`;
+  }
+  addQueryParam(query, key) {
+    return this.encodeQueryParam(key, query[key]);
+  }
+  addArrayQueryParam(query, key) {
+    const value = query[key];
+    return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+  }
+  toQueryString(rawQuery) {
+    const query = rawQuery || {};
+    const keys = Object.keys(query).filter((key) => query[key] !== undefined);
+    return keys.map((key) => Array.isArray(query[key]) ? this.addArrayQueryParam(query, key) : this.addQueryParam(query, key)).join("&");
+  }
+  addQueryParams(rawQuery) {
+    const queryString = this.toQueryString(rawQuery);
+    return queryString ? `?${queryString}` : "";
+  }
+  mergeRequestParams(params1, params2) {
+    return {
+      ...this.baseApiParams,
+      ...params1,
+      ...params2 || {},
+      headers: {
+        ...this.baseApiParams.headers || {},
+        ...params1.headers || {},
+        ...params2 && params2.headers || {}
+      }
+    };
+  }
+  constructor(apiConfig = {}) {
+    this.baseUrl = "https://localhost:7008";
+    this.securityData = null;
+    this.abortControllers = new Map;
+    this.customFetch = (...fetchParams) => fetch(...fetchParams);
+    this.baseApiParams = {
+      credentials: "same-origin",
+      headers: {},
+      redirect: "follow",
+      referrerPolicy: "no-referrer"
+    };
+    this.setSecurityData = (data) => {
+      this.securityData = data;
+    };
+    this.contentFormatters = {
+      ["application/json"]: (input) => input !== null && (typeof input == "object" || typeof input == "string") ? JSON.stringify(input) : input,
+      ["application/vnd.api+json"]: (input) => input !== null && (typeof input == "object" || typeof input == "string") ? JSON.stringify(input) : input,
+      ["text/plain"]: (input) => input !== null && typeof input != "string" ? JSON.stringify(input) : input,
+      ["multipart/form-data"]: (input) => {
+        if (input instanceof FormData)
+          return input;
+        return Object.keys(input || {}).reduce((formData, key) => {
+          const property = input[key];
+          formData.append(key, property instanceof Blob ? property : typeof property == "object" && property !== null ? JSON.stringify(property) : `${property}`);
+          return formData;
+        }, new FormData);
+      },
+      ["application/x-www-form-urlencoded"]: (input) => this.toQueryString(input)
+    };
+    this.createAbortSignal = (cancelToken) => {
+      if (this.abortControllers.has(cancelToken)) {
+        const abortController = this.abortControllers.get(cancelToken);
+        if (abortController)
+          return abortController.signal;
+        return;
+      }
+      const abortController = new AbortController;
+      this.abortControllers.set(cancelToken, abortController);
+      return abortController.signal;
+    };
+    this.abortRequest = (cancelToken) => {
+      const abortController = this.abortControllers.get(cancelToken);
+      if (abortController) {
+        abortController.abort();
+        this.abortControllers.delete(cancelToken);
+      }
+    };
+    this.request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
+      const secureParams = (typeof secure == "boolean" ? secure : this.baseApiParams.secure) && this.securityWorker && await this.securityWorker(this.securityData) || {};
+      const requestParams = this.mergeRequestParams(params, secureParams);
+      const queryString = query && this.toQueryString(query);
+      const payloadFormatter = this.contentFormatters[type || "application/json"];
+      const responseFormat = format || requestParams.format;
+      return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, {
+        ...requestParams,
+        headers: {
+          ...requestParams.headers || {},
+          ...type && type !== "multipart/form-data" ? {
+            "Content-Type": type
+          } : {}
+        },
+        signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null,
+        body: body == null ? null : payloadFormatter(body)
+      }).then(async (response) => {
+        const r = response;
+        r.data = null;
+        r.error = null;
+        const responseToParse = responseFormat ? response.clone() : response;
+        const data = responseFormat ? await responseToParse[responseFormat]().then((data) => {
+          if (r.ok)
+            r.data = data;
+          else
+            r.error = data;
+          return r;
+        }).catch((e) => {
+          r.error = e;
+          return r;
+        }) : r;
+        if (cancelToken)
+          this.abortControllers.delete(cancelToken);
+        if (!response.ok)
+          throw data;
+        return data.data;
+      });
+    };
+    Object.assign(this, apiConfig);
+  }
+}
+
+class FirstPartyServiceApi2 extends HttpClient {
+  constructor(...args) {
+    super(...args), this.v2 = {
+      automationSolutionsGetMetadata: (params = {}) => this.request({
+        path: "/v2/automationsolutions/metadata",
+        method: "GET",
+        ...params
+      }),
+      automationSolutionsHeadMetadata: (params = {}) => this.request({
+        path: "/v2/automationsolutions/metadata",
+        method: "HEAD",
+        ...params
+      }),
+      automationSolutionsSetState: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "PATCH",
+        query,
+        body: data,
+        type: "application/json",
+        ...params
+      }),
+      automationSolutionsInstall: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "PUT",
+        query,
+        body: data,
+        format: "json",
+        ...params
+      }),
+      automationSolutionsUninstall: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "DELETE",
+        query,
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsExport: (data, params = {}) => this.request({
+        path: "/v2/automationsolutions/export",
+        method: "POST",
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsGetTranslations: (query, params = {}) => this.request({
+        path: "/v2/automationsolutions/translations",
+        method: "GET",
+        query,
+        format: "json",
+        ...params
+      }),
+      automationSolutionsValidate: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions/validate",
+        method: "POST",
+        query,
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsLookup: (query, params = {}) => this.request({
+        path: "/v2/automationsolutions/lookup",
+        method: "GET",
+        query,
+        format: "json",
+        ...params
+      })
+    };
+  }
+}
+export { ErrorCodes, BadRequestException, InvalidOperationException, types_ResourceScope, toResourceIdentifier, toServiceName, getVersionOrDefault, isSingleReferenceProperty, isAnyReferenceProperty, isSecretProperty, isNameProperty, isFileReferenceProperty, WellKnownProjectType, WellKnownPropertyNames, FailOnNameConflictKinds, toResourceIdentifier2, isExcluded, filterVisibleFolderResources, filterHiddenResourceKeys, filterHiddenUnsupportingDebugProvisioningKeys, supportsDebugProvisioningWithDependencies, supportsDebugProvisioning, isProcessArtefact, resolvePackageNameAfterRename, findPackageNameConflict, changePackageName, getDefaultValue, buildDefaultConfiguration, isDependencyToResource, updateReferenceProps, cloneResourceDefinition, resourceNameIdentity, getResource, getResourceOrDefault, findMetadataForResource, getResourceIdentifierKey, invariantEquals, addResource, addResourceWithUniqueName, upsertFile, getRootFolder, JsonSerializerNames2, JsonSerializer2, CAMEL_CASE_ENUM_PROPERTIES2, SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES2, RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES2, PASCAL_CASE_ENUM_PROPERTIES2, JsonSerializerFactory2, JsonSerializerProxy2, StreamSerializer2, SolutionDefinitionHelper2, FirstPartyServiceApi2 };
+
+//# debugId=6AA8492A0E5BD36D64756E2164756E21