@wandzai/utils 1.0.58-audience-page-discrepency-6 → 1.0.58-interactions-close-btn-2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wandzai/utils",
-  "version": "1.0.58-audience-page-discrepency-6",
+  "version": "1.0.58-interactions-close-btn-2",
   "description": "Common used utilities library",
   "main": "src/index",
   "scripts": {

package/src/cache.ts

@@ -0,0 +1 @@
+export const cacheKeyBuilder = (cacheKey: string, identifiers: any): string => `${cacheKey}${JSON.stringify(identifiers)}`;

package/src/common.ts

@@ -0,0 +1,104 @@
+export const fakeDelay = (milliSec: number) =>
+  new Promise((resolve) => {
+    setTimeout(resolve, milliSec);
+  });
+
+export const convertCamelCaseToUnderscore = (term: string):
+	string =>
+  term
+    .split(/\.?(?=[A-Z])/)
+    .join('_')
+    .toLowerCase();
+export const convertUnderscoreToCamelCase = (underscoreString: string): string => {
+  return underscoreString.replace(/_([a-z])/g, (_match: string, group) => {
+    return group.toUpperCase();
+  });
+};
+
+export const convertUnderscoreToCamelCaseObj = (obj: Record<string, any>): Record<string, any> => {
+  return Object.keys(obj).reduce((acc, key) => {
+    acc[convertUnderscoreToCamelCase(key)] = obj[key];
+    return acc;
+  }, {});
+};
+
+
+export const convertCamelCaseToUnderscoreObj = (obj: Record<string, any>): Record<string, any> => {
+	return Object.keys(obj).reduce((acc, key) => {
+		acc[convertCamelCaseToUnderscore(key)] = obj[key];
+		return acc;
+	}, {});
+}
+
+
+export const kebabToDisplayName = (kebabCase: string) => kebabCase
+	.split('-')
+	.map(word => word.charAt(0).toUpperCase() + word.slice(1))
+	.join(' ');
+
+export const stringifyWithSingleQuotes = (arr: any[]) => {
+    return JSON.stringify(arr, (key, value) => {
+        if (typeof value === 'string') {
+            return `'${value}'`; /** Wrap string values with single quotes */
+        }
+        return value;
+    })
+        .replace(/"([^"]+)":/g, "'$1':") /** Wrap keys with single quotes */
+        .replace(/"/g, ''); /** Remove any remaining double quotes */
+}
+
+export const upperCaseFirstChar = (word: string) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+
+export const upperCaseFirstCharOfEachWord = (str: string) => {
+  return (str || '').replace(/\b\w/g, function (match) {
+    return match.toUpperCase();
+  });
+};
+
+export const upperCaseFirstCharOfEachWordSplitBySpace = (str: string) => {
+    return (str || '').split(' ').map(upperCaseFirstChar).join(' ');
+};
+
+export const jsonToConsistentString = (jsonObj) => {
+    // Helper function to sort an object recursively
+    function sortObject(obj) {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+
+        if (Array.isArray(obj)) {
+            return obj.map(sortObject);
+        }
+
+        const sortedKeys = Object.keys(obj).sort();
+        const sortedObj = {};
+
+        for (const key of sortedKeys) {
+            sortedObj[key] = sortObject(obj[key]);
+        }
+
+        return sortedObj;
+    }
+
+    /** Sort the JSON object */
+    const sortedJsonObj = sortObject(jsonObj);
+
+    /** Convert the sorted JSON object to a string */
+    return JSON.stringify(sortedJsonObj);
+};
+
+export const booleanStringToBoolean = (value: string) => value === 'true';
+export const booleanStringToNumber = (value: string) =>
+    booleanStringToBoolean(value) ? 1 : 0;
+
+/**Convert snowflake response keys CAPITAL_CHAR into capitalChar **/
+export const normalizeSfResponseObjKeys = (obj: Record<string, any>) => {
+    return Object.fromEntries(
+        Object.entries(obj).map(([key, value]) => [
+            key
+                .toLowerCase()
+                .replace(/_([a-z])/g, (_, char) => char.toUpperCase()), // Convert _X to X
+            value
+        ])
+    );
+}

package/src/date.ts

@@ -0,0 +1,37 @@
+import {TimeUnits} from '@wandzai/wandz-interfaces';
+
+export const formatDateYearMonthDay = (date: string | Date) =>
+  new Date(date).toLocaleDateString('en-CA', { year: 'numeric', month: '2-digit', day: '2-digit' });
+
+export const calcDatesRange = (range: number) => {
+  const today = new Date();
+  const startDate = new Date(today);
+  startDate.setDate(today.getDate() - range);
+
+  return {
+    startDate: formatDateYearMonthDay(startDate),
+    endDate: formatDateYearMonthDay(today),
+  };
+};
+
+export const getTimeDifference = (date: Date, timeUnit: TimeUnits): number => {
+  /** Get the current date and time */
+  const now = new Date();
+
+  /** Calculate the time difference in milliseconds */
+  const timeDifference = now.getTime() - date.getTime();
+
+  /** Convert the time difference to the specified time unit */
+  switch (timeUnit) {
+    case TimeUnits.Hours:
+      return timeDifference / (1000 * 60 * 60);
+    case TimeUnits.Minutes:
+      return timeDifference / (1000 * 60);
+    case TimeUnits.Seconds:
+      return timeDifference / 1000;
+    case TimeUnits.Days:
+      return timeDifference / (1000 * 60 * 60 * 24);
+    default:
+      return timeDifference; /** Return milliseconds by default */
+  }
+};

package/src/encrypt-decrypt.ts

@@ -0,0 +1,14 @@
+const CryptoJS = require('crypto-js');
+const key = '66807eb6-f5c0-4245-8e4c-0c5d3f80f203';
+
+export const encryptData = (data: any): string => {
+  const encryptedData = CryptoJS.RC4.encrypt(JSON.stringify(data), key).toString();
+
+  return encodeURIComponent(encryptedData);
+};
+
+export const decryptData = (data: string): any => {
+  const decodedEncrypted = decodeURIComponent(data);
+  const bytes = CryptoJS.RC4.decrypt(decodedEncrypted, key);
+  return JSON.parse(bytes.toString(CryptoJS.enc.Utf8));
+};

package/src/gzip.ts

@@ -0,0 +1,30 @@
+/**
+ * Gzip single file or every file in given folder
+ * @file gzip.js
+ */
+
+import {createGzip} from 'zlib';
+import {createReadStream, createWriteStream} from 'fs';
+
+/**
+ * @method gzipFile
+ * @param {String} fileIn
+ * @param {String} fileOut
+ */
+export function gzipFile(fileIn: string, fileOut: string) {
+  return new Promise<void>((resolve, reject) => {
+    const inp = createReadStream(fileIn);
+    const out = createWriteStream(fileOut);
+    const gzip = createGzip();
+
+    inp
+      .pipe(gzip)
+      .pipe(out)
+      .on('finish', function () {
+        resolve();
+      })
+      .on('error', function (err) {
+        reject(err);
+      });
+  });
+}

package/src/hash.ts

@@ -0,0 +1,12 @@
+const hmacSHA512 = require('crypto-js/hmac-sha512');
+const Base64 = require('crypto-js/enc-base64');
+
+export const hashData = (strToHash: string, specificSalt: string): string => {
+  try {
+    const saltPrefix: string = 'YvSmHe0x5FC90fmk';
+    const salt: string = `${saltPrefix}-${specificSalt.toLowerCase()}`;
+    return Base64.stringify(hmacSHA512(strToHash, salt)).replaceAll('+', '');
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+};

package/src/http.ts

@@ -0,0 +1,64 @@
+import {Request} from 'express';
+import * as querystring from 'querystring';
+
+/**
+ * Extracts ip address from http request
+ * @param {Request} req - http request
+ */
+export function getIpFromHttpRequest(req: Request): string {
+  return req.headers['x-forwarded-for']
+    ? String(req.headers['x-forwarded-for']).split(',')[0].trim()
+    : req.socket.remoteAddress;
+}
+
+export function buildUriBodyString(queryParams: Record<string, any>): string {
+  return Object.keys(queryParams)
+    .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(JSON.stringify(queryParams[key]))}`)
+    .join('&');
+}
+
+/**
+ * On platform side we're stringifies all entries (also strings) as you can see buildUriBodyString above
+ * On the other hand, while using <getEncodedQueryParams> to verify network calls on Automation,
+ * the string values are not sent wrapped with double quotes,
+ * therefore we'll add a safety mechanism
+ * */
+export function getEncodedQueryParams(fullUrl: string): object {
+  const queryStringStartIndex = fullUrl.indexOf('?');
+  if (queryStringStartIndex === -1) {
+    return {}; // No query string found
+  }
+
+  const queryString = fullUrl.substring(queryStringStartIndex + 1);
+  const data = querystring.parse(queryString);
+
+  return Object.keys(data).reduce((acc, key) => {
+    try {
+      /** safety mechanism */
+      acc[key] = JSON.parse(data[key] as string);
+    } catch (e) {
+      acc[key] = data[key]; /** for non-object values*/
+    }
+    return acc;
+  }, {});
+}
+
+/**
+ * Builds a query string from an object of parameters.
+ *
+ * @param {Record<string, any>} params - The parameters to be converted into a query string.
+ * @returns {string} The constructed query string.
+ */
+export function buildQueryString(params: Record<string, any>): string {
+  const queryParams = new URLSearchParams();
+
+  Object.entries(params).forEach(([key, value]) => {
+    if (typeof value === 'object') {
+      queryParams.append(key, JSON.stringify(value));
+    } else {
+      queryParams.append(key, String(value));
+    }
+  });
+
+  return queryParams.toString();
+}

package/src/{index.d.ts → index.ts}

@@ -10,3 +10,4 @@ export * from './mysql';
 export * from './snowflake';
 export * from './schedule';
 export * from './cache';
+export * from './interactions';

package/src/interactions.ts

@@ -0,0 +1,79 @@
+import {Devices, IInteraction, IInteractionCloseButtonConfig} from "@wandzai/wandz-interfaces";
+
+
+const btnSvg = '<svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M9.87097 0.366057C10.3591 -0.121966 11.1504 -0.122072 11.6385 0.366057C12.1261 0.854212 12.1264 1.64566 11.6385 2.13363L7.76941 6.0018L11.6385 9.87094L11.7245 9.96567C12.1243 10.4566 12.0959 11.1811 11.6385 11.6385C11.1811 12.096 10.4567 12.1243 9.96569 11.7245L9.87097 11.6385L6.00085 7.76938L2.13366 11.6375C1.64563 12.1255 0.85426 12.1253 0.366085 11.6375C-0.121993 11.1494 -0.122063 10.3581 0.366085 9.86996L4.23327 6.0018L0.366085 2.13461C-0.12203 1.64652 -0.121894 0.855216 0.366085 0.367033C0.854135 -0.121035 1.64547 -0.121806 2.13366 0.366057L6.00183 4.23422L9.87097 0.366057Z" fill="#2F2F2F"/></svg>'
+const DEFAULTS = {
+  OFFSET: 8,
+  SIZE: 12,
+  COLOR: '#000000',
+  PADDING: 10,
+};
+
+export const getCloseButton = (
+  interaction: IInteraction,
+  deviceType: Devices.PC | Devices.MOB,
+  btnClassName: string = 'exit-btn',
+  btnId: string = 'wandz-interaction-close-btn',
+  tagType: string = 'span',
+  ) => {
+  let config = interaction.closeButtonConfig?.[deviceType] || interaction.closeButtonConfig?.[Devices.PC];
+  if (!config) {
+    config = {
+      color: interaction.closeButtonColor || DEFAULTS.COLOR,
+      size: DEFAULTS.SIZE,
+      offsetX: DEFAULTS.OFFSET,
+      offsetY: DEFAULTS.OFFSET,
+    } as IInteractionCloseButtonConfig;
+  }
+  let extraStyles = '';
+  const backgroundConfig = config.background;
+  if (backgroundConfig) {
+    extraStyles = `
+#${btnId} {
+    width: ${config.size + DEFAULTS.PADDING * 2}px;
+    height: ${config.size + DEFAULTS.PADDING * 2}px;
+    background-color: ${backgroundConfig.color};
+    border-radius: ${backgroundConfig.radius}px;
+    box-shadow: inset 0 0 0 1.5px ${backgroundConfig.borderColor};
+}`
+  }
+  return {
+    html: `<${tagType} id="${btnId}" class="${btnClassName}">${btnSvg}</${tagType}>`,
+    styles: `
+#${btnId} {
+    position: absolute;
+    top: ${config.offsetY}px;
+    right: ${config.offsetX}px;
+    line-height: ${config.size}px;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    overflow: hidden;
+}
+#${btnId} svg {
+    height: ${config.size}px;
+    width: ${config.size}px;
+}
+#${btnId} svg path {
+    fill: ${config.color};
+}
+#${btnId}::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: #ffffff;
+    opacity: 0;
+    transition: opacity 0.3s ease;
+    pointer-events: none;
+}
+#${btnId}:hover::after {
+    opacity: 0.3;
+}
+${extraStyles}
+`,
+  };
+};

package/src/mysql.ts

@@ -0,0 +1,14 @@
+const formatParamValue = (value: any): string => {
+  if (typeof value === 'object') {
+    /** Currently used for arrays (typeof [] is 'object') */
+    return `'${JSON.stringify(value)}'`;
+  } else if (typeof value === 'string') {
+    return `'${value}'`;
+  } else {
+    return value;
+  }
+};
+
+export const buildMysqlProcedureString = (procedure: string, params: any[]): string => {
+  return `CALL ${procedure}(${params.map((v) => formatParamValue(v)).join(',')});`;
+};

package/src/numeric.ts

@@ -0,0 +1,9 @@
+export const getRandomIntInclusive = (minVal: number, maxVal: number) => {
+  const min = Math.ceil(minVal);
+  const max = Math.floor(maxVal);
+  return Math.floor(Math.random() * (max - min + 1)) + min; //The maximum is inclusive and the minimum is inclusive
+};
+
+export const getRandomFloatInclusive = (minVal: number, maxVal: number) => {
+  return Number((Math.random() * (minVal - maxVal + 1) + minVal).toFixed(2));
+};

package/src/schedule.ts

@@ -0,0 +1,35 @@
+import * as dayjs from 'dayjs';
+import * as utc from 'dayjs/plugin/utc';
+import * as timezone from 'dayjs/plugin/timezone';
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+export { dayjs };
+
+export const nowInUTC = (asDate: boolean = true): Date | dayjs.Dayjs =>
+  asDate ? dayjs().utc().toDate() : dayjs().utc();
+
+export const isInPast = (date: Date | string): boolean => dayjs.utc(date).isBefore(nowInUTC());
+
+export const isSameDate = (date1: Date | string, date2: Date | string): boolean =>
+  dayjs(date1).isSame(dayjs(date2), 'day');
+
+export const getHourOfUTCDate = (date: Date | string): number => dayjs.utc(date).hour();
+
+export const formatUTCDateWithTimezone = (date: Date | string, timezone: string, format: string): string => {
+  return dayjs
+    .utc(date) // Explicitly treat the input as UTC
+    .tz(timezone) // Convert to user's timezone
+    .format(format);
+};
+
+export const getTimezoneOffsetInHours = (region: string): number => {
+  // Get the current time in the given timezone
+  const nowInTimezone = dayjs().tz(region);
+
+  // Get the offset in minutes and convert to hours
+  const offsetInHours = nowInTimezone.utcOffset() / 60;
+
+  // Return the offset in hours
+  return parseFloat(offsetInHours.toFixed(1));
+};

package/src/snowflake.ts

@@ -0,0 +1,23 @@
+const formatParamValue = (value: any): string => {
+  if (Array.isArray(value)) {
+    return `[${value.map(formatParamValue).join(',')}]`;
+  } else if (typeof value === 'boolean') {
+    return value ? 'TRUE' : 'FALSE';
+  } else if (typeof value === 'number') {
+    return value.toString();
+  } else if (value === null) {
+    return 'NULL';
+  } else if (typeof value === 'object') {
+    const content = Object.entries(value).map(([key, value]) => {
+      return `'${key}', ${formatParamValue(value)}`;
+    }).join(',');
+    return `object_construct(${content})`;
+  } else {
+    return `'${value}'`;
+  }
+};
+
+export const buildComplexTypedProcedure = (procedure: string, params: { [paramName: string]: any }): string =>
+  `CALL ${procedure}(${Object.entries(params)
+    .map(([paramName, paramValue]) => `${paramName} => ${formatParamValue(paramValue)}`)
+    .join(', ')})`;

package/src/wandz.ts

@@ -0,0 +1,132 @@
+import {
+    AdaptiveSearchReplaceLabels,
+    AffinityTypes,
+    AiFeatureDistributionType,
+    IAdaptiveSearch,
+    IAffinityBasedCustomAiFeatureConfig,
+    IAiFeaturesBasicConfig,
+    IAudience,
+    ICustomAiFeature,
+    ICustomAudience,
+    IEntity,
+    IEventBasedCustomAiFeatureConfig,
+    IPredictionModel,
+    IStorageBasedCustomAiFeatureConfig, IWandzAiFeaturesConfig,
+    WandzEntities,
+} from '@wandzai/wandz-interfaces';
+
+/** ai-features */
+export const entityTechNameBuilder = (entityName: string) => {
+  /** Convert display name to slug:
+	 transform to lowercase, replace spaces with underscores
+	 remove anything not alphanumeric, or underscore, or dot
+	 */
+  return entityName
+    .toLowerCase()
+    .replace(/ /g, '_')
+    .replace(/[^\w_.]+/g, '');
+};
+
+export function isAffinityBasedCustomAiFeature(
+  feature: ICustomAiFeature,
+): feature is IAffinityBasedCustomAiFeatureConfig {
+  return (feature as IAffinityBasedCustomAiFeatureConfig).affinityType != null;
+}
+
+export function isStorageBasedCustomAiFeature(
+  feature: ICustomAiFeature,
+): feature is IStorageBasedCustomAiFeatureConfig {
+  return (feature as IStorageBasedCustomAiFeatureConfig).storageLogic != null;
+}
+
+export function isEventBasedCustomAiFeature(feature: ICustomAiFeature): feature is IEventBasedCustomAiFeatureConfig {
+  return (feature as IEventBasedCustomAiFeatureConfig).eventLogic != null;
+}
+
+export const getCustomAiFeatureType = (feature: ICustomAiFeature): AiFeatureDistributionType => {
+  if (isEventBasedCustomAiFeature(feature)) {
+    return 'event';
+  } else if (isAffinityBasedCustomAiFeature(feature)) {
+    return feature.affinityType;
+  }
+  return 'storage';
+};
+
+export const isAiFeature = (entity: IEntity): entity is IAiFeaturesBasicConfig => {
+  return (entity as IAiFeaturesBasicConfig).aiFeature != null;
+};
+
+export const isAudience = (entity: IEntity): entity is IAudience => {
+  return (entity as IAudience).operator != null && (entity as IAudience).rules != null;
+};
+
+export const isCustomEntity = (entity: IEntity) => {
+  return (
+    /** checking if entity matches <ICreationMeta> interfaces */
+    entity.hasOwnProperty('createdBy')
+  );
+};
+
+export const isCustomAudience = (audience: IAudience): audience is ICustomAudience => {
+  return isCustomEntity(audience);
+};
+export const isCustomAiFeature = (feature: IAiFeaturesBasicConfig): feature is ICustomAiFeature => {
+  return isCustomEntity(feature);
+};
+export const isInHouseAiFeature = (entity: IEntity): entity is IWandzAiFeaturesConfig => {
+    return isAiFeature(entity) && !isCustomEntity(entity);
+};
+export const isModel = (entity: IEntity): entity is IPredictionModel => {
+  return (entity as IPredictionModel).targetRules != null;
+};
+
+export const getEntityID = (entity: IEntity): string => {
+  if (isAiFeature(entity)) {
+    return entity.id?.toString();
+  } else if (isAudience(entity)) {
+    return entity.guid;
+  } else if (isModel(entity)) {
+    return entity.guid;
+  }
+  return '';
+};
+
+export const getEntityType = (entity: IEntity): WandzEntities => {
+  if (isAiFeature(entity)) {
+    return WandzEntities.AI_FEATURE;
+  } else if (isAudience(entity)) {
+    return WandzEntities.AUDIENCE;
+  } else if (isModel(entity)) {
+    return WandzEntities.MODEL;
+  }
+  return WandzEntities.AI_FEATURE;
+};
+
+export const getEntityDisplayName = (entity: IEntity): string => {
+  if (isAiFeature(entity)) {
+    return entity.displayName;
+  } else if (isAudience(entity)) {
+    return entity.displayName;
+  } else if (isModel(entity)) {
+    return entity.name;
+  }
+  return '';
+};
+
+/** Adaptive search */
+export const getAdaptiveSearchDataByField = (search: IAdaptiveSearch, label: AdaptiveSearchReplaceLabels): any => {
+    switch (label) {
+        case AdaptiveSearchReplaceLabels.CONTENTS:
+            return search.whatToShow.contents;
+        case AdaptiveSearchReplaceLabels.PRIORITIZE_BY:
+            return search.whatToShow.priority;
+        case AdaptiveSearchReplaceLabels.SUGGESTIONS_MAX_QUANTITY:
+            return search.whatToShow.suggestionsAmount;
+        case AdaptiveSearchReplaceLabels.TEST_GROUP_SIZE:
+            return search.testGroupSize;
+        case AdaptiveSearchReplaceLabels.NUM_CHARACTERS_STOP_SHOWING:
+            return search.typedCharactersToStopShowing;
+        case AdaptiveSearchReplaceLabels.ADD_ADAPTIVE_URL_PARAM:
+            return search.addUrlParam;
+    }
+};

package/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "../../dist/libs/utils"
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts"]
+}

package/src/cache.d.ts

@@ -1 +0,0 @@
-export declare const cacheKeyBuilder: (cacheKey: string, identifiers: any) => string;

package/src/cache.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cacheKeyBuilder = void 0;
-const cacheKeyBuilder = (cacheKey, identifiers) => `${cacheKey}${JSON.stringify(identifiers)}`;
-exports.cacheKeyBuilder = cacheKeyBuilder;
-//# sourceMappingURL=cache.js.map

package/src/cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../../libs/utils/src/cache.ts"],"names":[],"mappings":";;;AAAO,MAAM,eAAe,GAAG,CAAC,QAAgB,EAAE,WAAgB,EAAU,EAAE,CAAC,GAAG,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,CAAC;AAA9G,QAAA,eAAe,mBAA+F"}

package/src/common.d.ts

@@ -1,16 +0,0 @@
-export declare const fakeDelay: (milliSec: number) => Promise<unknown>;
-export declare const convertCamelCaseToUnderscore: (term: string) => string;
-export declare const convertUnderscoreToCamelCase: (underscoreString: string) => string;
-export declare const convertUnderscoreToCamelCaseObj: (obj: Record<string, any>) => Record<string, any>;
-export declare const convertCamelCaseToUnderscoreObj: (obj: Record<string, any>) => Record<string, any>;
-export declare const kebabToDisplayName: (kebabCase: string) => string;
-export declare const stringifyWithSingleQuotes: (arr: any[]) => string;
-export declare const upperCaseFirstChar: (word: string) => string;
-export declare const upperCaseFirstCharOfEachWord: (str: string) => string;
-export declare const upperCaseFirstCharOfEachWordSplitBySpace: (str: string) => string;
-export declare const jsonToConsistentString: (jsonObj: any) => string;
-export declare const booleanStringToBoolean: (value: string) => value is "true";
-export declare const booleanStringToNumber: (value: string) => 1 | 0;
-export declare const normalizeSfResponseObjKeys: (obj: Record<string, any>) => {
-    [k: string]: any;
-};