@uipath/case-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/{packager-tool-gdtpsdn7.js → packager-tool-mm1x18d6.js}

@@ -1,5 +1,5 @@
 // ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer-names.js
-var JsonSerializerNames = {
+var JsonSerializerNames2 = {
   DefaultCaseInsensitive: "DefaultCaseInsensitive",
   CaseInsensitive: "CaseInsensitive",
   Indented: "Indented",
@@ -21,7 +21,7 @@ var JsonSerializerNames = {
 };
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer.js
-class JsonSerializer {
+class JsonSerializer2 {
   serialize(value) {
     if (value == null)
       return null;
@@ -154,16 +154,16 @@ class JsonSerializer {
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/pascal-case-enum-properties.js
-var CAMEL_CASE_ENUM_PROPERTIES = [
+var CAMEL_CASE_ENUM_PROPERTIES2 = [
   "scope",
   "replaceOption",
   "lookupStrategy",
   "folderType"
 ];
-var SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES = [
+var SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES2 = [
   "propertyCategory"
 ];
-var RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES = [
+var RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES2 = [
   "ValidationState.errorSeverity",
   "ValidationState.errorType",
   "AddOrUpdateResourceToSolutionResponse.status",
@@ -171,13 +171,13 @@ var RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES = [
   "OverwriteValidationError.severity",
   "ProjectResourceDescriptor.provisionType"
 ];
-var PASCAL_CASE_ENUM_PROPERTIES = [
-  ...SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES,
-  ...RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES
+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 JsonSerializerFactory {
+class JsonSerializerFactory2 {
   get() {
     return this.defaultSerializer;
   }
@@ -192,44 +192,44 @@ class JsonSerializerFactory {
     return serializer;
   }
   initializePredefinedSerializers() {
-    for (const name of JsonSerializerNames.AllNames)
+    for (const name of JsonSerializerNames2.AllNames)
       this.namedSerializers.set(name, this.createNamedSerializer(name));
   }
   createNamedSerializer(name) {
     const options = this.createOptionsForName(name);
-    return new JsonSerializer(options);
+    return new JsonSerializer2(options);
   }
   createOptionsForName(name) {
     const options = {
       ...this.baseOptions
     };
     switch (name) {
-      case JsonSerializerNames.DefaultCaseInsensitive:
+      case JsonSerializerNames2.DefaultCaseInsensitive:
         return {
           caseInsensitive: true
         };
-      case JsonSerializerNames.CaseInsensitive:
+      case JsonSerializerNames2.CaseInsensitive:
         options.caseInsensitive = true;
         break;
-      case JsonSerializerNames.Indented:
+      case JsonSerializerNames2.Indented:
         options.indented = true;
         break;
-      case JsonSerializerNames.CamelCase:
+      case JsonSerializerNames2.CamelCase:
         options.camelCase = true;
         break;
-      case JsonSerializerNames.CaseInsensitiveIndented:
+      case JsonSerializerNames2.CaseInsensitiveIndented:
         options.caseInsensitive = true;
         options.indented = true;
         break;
-      case JsonSerializerNames.IndentedIgnoreNull:
+      case JsonSerializerNames2.IndentedIgnoreNull:
         options.indented = true;
         options.ignoreNull = true;
         break;
-      case JsonSerializerNames.PreservePropertyNames:
+      case JsonSerializerNames2.PreservePropertyNames:
         options.preservePropertyNames = true;
         options.camelCase = false;
         break;
-      case JsonSerializerNames.CamelCaseIndented:
+      case JsonSerializerNames2.CamelCaseIndented:
         options.indented = true;
         options.camelCase = true;
         options.ignoreNull = true;
@@ -243,21 +243,21 @@ class JsonSerializerFactory {
     const defaults = {
       camelCase: true,
       enumCamelCase: true,
-      camelCaseEnumProperties: CAMEL_CASE_ENUM_PROPERTIES,
-      pascalCaseEnumProperties: PASCAL_CASE_ENUM_PROPERTIES
+      camelCaseEnumProperties: CAMEL_CASE_ENUM_PROPERTIES2,
+      pascalCaseEnumProperties: PASCAL_CASE_ENUM_PROPERTIES2
     };
     this.baseOptions = options ? {
       ...defaults,
       ...options
     } : defaults;
-    this.defaultSerializer = new JsonSerializer(this.baseOptions);
+    this.defaultSerializer = new JsonSerializer2(this.baseOptions);
     this.namedSerializers = new Map;
     this.initializePredefinedSerializers();
   }
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/serializer-proxy.js
-class JsonSerializerProxy {
+class JsonSerializerProxy2 {
   serialize(value) {
     return this.jsonSerializer.serialize(value);
   }
@@ -302,16 +302,16 @@ class JsonSerializerProxy {
   }
   constructor(jsonSerializerFactory, loggerFactory) {
     this.jsonSerializer = jsonSerializerFactory.get();
-    this.caseInsensitiveSerializer = jsonSerializerFactory.getByName(JsonSerializerNames.CaseInsensitive);
+    this.caseInsensitiveSerializer = jsonSerializerFactory.getByName(JsonSerializerNames2.CaseInsensitive);
     this.logger = loggerFactory.create("JsonSerializerProxy");
   }
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/stream-serializer.js
-class StreamSerializer {
+class StreamSerializer2 {
   async serializeAsync(data, cancellationToken) {
     cancellationToken?.throwIfAborted?.();
-    const serializer = this.jsonSerializerFactory.getByName(JsonSerializerNames.PreservePropertyNames);
+    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);
@@ -337,6 +337,201 @@ class StreamSerializer {
     this.disposeStream = disposeStream;
   }
 }
-export { JsonSerializerNames, JsonSerializer, CAMEL_CASE_ENUM_PROPERTIES, SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES, RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES, PASCAL_CASE_ENUM_PROPERTIES, JsonSerializerFactory, JsonSerializerProxy, StreamSerializer };
+// ../../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 { JsonSerializerNames2, JsonSerializer2, CAMEL_CASE_ENUM_PROPERTIES2, SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES2, RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES2, PASCAL_CASE_ENUM_PROPERTIES2, JsonSerializerFactory2, JsonSerializerProxy2, StreamSerializer2, FirstPartyServiceApi2 };
 
-//# debugId=B9E68BD7718EF2DB64756E2164756E21
+//# debugId=81CFEEB04DD9F5EC64756E2164756E21

package/dist/{packager-tool-mqy97y5f.js → packager-tool-p5gs9xqy.js}

@@ -1,34 +1,34 @@
 import {
   loadCaseSchemaAsync
-} from "./packager-tool-zf8f9pmm.js";
+} from "./packager-tool-zrbnms9b.js";
 // case-schema-floor.json
 var case_schema_floor_default = {
   writeVersion: "32.0.3"
 };
 
 // src/services/case-schema-version.ts
-var MIN_SUPPORTED_MAJOR = 20;
-async function resolveCaseSchemaVersion() {
+var MIN_SUPPORTED_MAJOR2 = 20;
+async function resolveCaseSchemaVersion2() {
   const { LATEST_CASE_SCHEMA_VERSION } = await loadCaseSchemaAsync();
-  if (parseCaseSchemaVersion(LATEST_CASE_SCHEMA_VERSION) === null) {
+  if (parseCaseSchemaVersion2(LATEST_CASE_SCHEMA_VERSION) === null) {
     throw new Error(`@uipath/case-schema exports a LATEST_CASE_SCHEMA_VERSION that is not "<major>.<minor>.<patch>": ${String(LATEST_CASE_SCHEMA_VERSION)}`);
   }
   return LATEST_CASE_SCHEMA_VERSION;
 }
-async function resolveCaseSchemaWriteVersion() {
+async function resolveCaseSchemaWriteVersion2() {
   const writes = case_schema_floor_default.writeVersion;
-  const parsed = parseCaseSchemaVersion(writes);
+  const parsed = parseCaseSchemaVersion2(writes);
   if (parsed === null) {
     throw new Error(`case-schema-floor.json's writeVersion is not "<major>.<minor>.<patch>": ${String(writes)}`);
   }
-  const reads = await resolveCaseSchemaVersion();
-  const readable = parseCaseSchemaVersion(reads);
-  if (readable !== null && compareCaseSchemaVersions(parsed, readable) > 0) {
+  const reads = await resolveCaseSchemaVersion2();
+  const readable = parseCaseSchemaVersion2(reads);
+  if (readable !== null && compareCaseSchemaVersions2(parsed, readable) > 0) {
     throw new Error(`case-schema-floor.json's writeVersion ${writes} is newer than ${reads}, the newest the pinned @uipath/case-schema reads`);
   }
   return writes;
 }
-function parseCaseSchemaVersion(version) {
+function parseCaseSchemaVersion2(version) {
   if (typeof version !== "string")
     return null;
   const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
@@ -40,13 +40,13 @@ function parseCaseSchemaVersion(version) {
     patch: Number.parseInt(match[3], 10)
   };
 }
-function compareCaseSchemaVersions(a, b) {
+function compareCaseSchemaVersions2(a, b) {
   return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
 }
-function isNewerCaseSchemaPatch(a, b) {
+function isNewerCaseSchemaPatch2(a, b) {
   return a.major === b.major && a.minor === b.minor && a.patch > b.patch;
 }
 
-export { MIN_SUPPORTED_MAJOR, resolveCaseSchemaVersion, resolveCaseSchemaWriteVersion, parseCaseSchemaVersion, compareCaseSchemaVersions, isNewerCaseSchemaPatch };
+export { MIN_SUPPORTED_MAJOR2, resolveCaseSchemaVersion2, resolveCaseSchemaWriteVersion2, parseCaseSchemaVersion2, compareCaseSchemaVersions2, isNewerCaseSchemaPatch2 };
 
-//# debugId=6239D835B421BBC264756E2164756E21
+//# debugId=7A18460E2C24AE4964756E2164756E21