@lokalise/node-core 9.8.1 → 10.0.0-RC1

package/dist/index.cjs

@@ -0,0 +1,898 @@
+'use strict';
+
+const undici = require('undici');
+const undiciRetry = require('undici-retry');
+const node_util = require('node:util');
+const pino = require('pino');
+const node_http2 = require('node:http2');
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class InternalError extends Error {
+  constructor(params) {
+    super(params.message);
+    __publicField$3(this, "details");
+    __publicField$3(this, "errorCode");
+    this.name = "InternalError";
+    this.details = params.details;
+    this.errorCode = params.errorCode;
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ResponseStatusError extends InternalError {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(requestResult, requestLabel = "N/A") {
+    super({
+      message: `Response status code ${requestResult.statusCode}`,
+      details: {
+        requestLabel,
+        response: {
+          statusCode: requestResult.statusCode,
+          body: requestResult.body
+        }
+      },
+      errorCode: "REQUEST_ERROR"
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    __publicField$2(this, "response");
+    __publicField$2(this, "isResponseStatusError", true);
+    this.response = requestResult;
+    this.name = "ResponseStatusError";
+  }
+}
+
+function copyWithoutUndefined(originalValue) {
+  return Object.keys(originalValue).reduce(
+    (acc, key) => {
+      if (originalValue[key] !== void 0) {
+        acc[key] = originalValue[key];
+      }
+      return acc;
+    },
+    {}
+  );
+}
+function pick(source, propNames) {
+  const result = {};
+  let idx = 0;
+  while (idx < propNames.length) {
+    if (propNames[idx] in source) {
+      result[propNames[idx]] = source[propNames[idx]];
+    }
+    idx += 1;
+  }
+  return result;
+}
+function pickWithoutUndefined(source, propNames) {
+  const result = {};
+  let idx = 0;
+  while (idx < propNames.length) {
+    if (propNames[idx] in source && source[propNames[idx]] !== void 0) {
+      result[propNames[idx]] = source[propNames[idx]];
+    }
+    idx += 1;
+  }
+  return result;
+}
+function isEmptyObject(params) {
+  for (const key in params) {
+    if (Object.hasOwn(params, key) && params[key] !== void 0) {
+      return false;
+    }
+  }
+  return true;
+}
+function groupBy(array, selector) {
+  return array.reduce(
+    (acc, item) => {
+      const key = item[selector];
+      if (key === void 0 || key === null) {
+        return acc;
+      }
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(item);
+      return acc;
+    },
+    {}
+  );
+}
+function groupByUnique(array, selector) {
+  return array.reduce(
+    (acc, item) => {
+      const key = item[selector];
+      if (key === void 0 || key === null) {
+        return acc;
+      }
+      if (acc[key] !== void 0) {
+        throw new InternalError({
+          message: `Duplicated item for selector ${selector.toString()} with value ${key.toString()}`,
+          errorCode: "DUPLICATED_ITEM",
+          details: { selector, value: key }
+        });
+      }
+      acc[key] = item;
+      return acc;
+    },
+    {}
+  );
+}
+function convertDateFieldsToIsoString(object) {
+  if (Array.isArray(object)) {
+    return object.map(convertDateFieldsToIsoStringAux);
+  }
+  return Object.entries(object).reduce((result, [key, value]) => {
+    result[key] = convertDateFieldsToIsoStringAux(value);
+    return result;
+  }, {});
+}
+function convertDateFieldsToIsoStringAux(item) {
+  if (item instanceof Date) {
+    return item.toISOString();
+  } else if (item && typeof item === "object") {
+    return convertDateFieldsToIsoString(item);
+  } else {
+    return item;
+  }
+}
+function deepClone(object) {
+  if (object === void 0 || object === null) {
+    return object;
+  }
+  return structuredClone(object);
+}
+
+const DEFAULT_OPTIONS = {
+  validateResponse: true,
+  throwOnError: true,
+  timeout: 3e4
+};
+const defaultClientOptions = {
+  keepAliveMaxTimeout: 3e5,
+  keepAliveTimeout: 4e3
+};
+async function sendGet(client, path, options = {}) {
+  const result = await undiciRetry.sendWithRetry(
+    client,
+    {
+      ...DEFAULT_OPTIONS,
+      path,
+      method: "GET",
+      query: options.query,
+      headers: copyWithoutUndefined({
+        "x-request-id": options.reqContext?.reqId,
+        ...options.headers
+      }),
+      reset: options.disableKeepAlive ?? false,
+      bodyTimeout: options.timeout,
+      throwOnError: false
+    },
+    resolveRetryConfig(options),
+    resolveRequestConfig(options)
+  );
+  return resolveResult(
+    result,
+    options.throwOnError ?? DEFAULT_OPTIONS.throwOnError,
+    options.validateResponse ?? DEFAULT_OPTIONS.validateResponse,
+    options.responseSchema,
+    options.requestLabel
+  );
+}
+async function sendDelete(client, path, options = {}) {
+  const result = await undiciRetry.sendWithRetry(
+    client,
+    {
+      ...DEFAULT_OPTIONS,
+      path,
+      method: "DELETE",
+      query: options.query,
+      headers: copyWithoutUndefined({
+        "x-request-id": options.reqContext?.reqId,
+        ...options.headers
+      }),
+      reset: options.disableKeepAlive ?? false,
+      bodyTimeout: options.timeout,
+      throwOnError: false
+    },
+    resolveRetryConfig(options),
+    resolveRequestConfig(options)
+  );
+  return resolveResult(
+    result,
+    options.throwOnError ?? DEFAULT_OPTIONS.throwOnError,
+    options.validateResponse ?? DEFAULT_OPTIONS.validateResponse,
+    options.responseSchema
+  );
+}
+async function sendPost(client, path, body, options = {}) {
+  const result = await undiciRetry.sendWithRetry(
+    client,
+    {
+      ...DEFAULT_OPTIONS,
+      path,
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0,
+      query: options.query,
+      headers: copyWithoutUndefined({
+        "x-request-id": options.reqContext?.reqId,
+        ...options.headers
+      }),
+      reset: options.disableKeepAlive ?? false,
+      bodyTimeout: options.timeout,
+      throwOnError: false
+    },
+    resolveRetryConfig(options),
+    resolveRequestConfig(options)
+  );
+  return resolveResult(
+    result,
+    options.throwOnError ?? DEFAULT_OPTIONS.throwOnError,
+    options.validateResponse ?? DEFAULT_OPTIONS.validateResponse,
+    options.responseSchema
+  );
+}
+async function sendPostBinary(client, path, body, options = {}) {
+  const result = await undiciRetry.sendWithRetry(
+    client,
+    {
+      ...DEFAULT_OPTIONS,
+      path,
+      method: "POST",
+      body,
+      query: options.query,
+      headers: copyWithoutUndefined({
+        "x-request-id": options.reqContext?.reqId,
+        ...options.headers
+      }),
+      reset: options.disableKeepAlive ?? false,
+      bodyTimeout: options.timeout,
+      throwOnError: false
+    },
+    resolveRetryConfig(options),
+    resolveRequestConfig(options)
+  );
+  return resolveResult(
+    result,
+    options.throwOnError ?? DEFAULT_OPTIONS.throwOnError,
+    options.validateResponse ?? DEFAULT_OPTIONS.validateResponse,
+    options.responseSchema
+  );
+}
+async function sendPut(client, path, body, options = {}) {
+  const result = await undiciRetry.sendWithRetry(
+    client,
+    {
+      ...DEFAULT_OPTIONS,
+      path,
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0,
+      query: options.query,
+      headers: copyWithoutUndefined({
+        "x-request-id": options.reqContext?.reqId,
+        ...options.headers
+      }),
+      reset: options.disableKeepAlive ?? false,
+      bodyTimeout: options.timeout,
+      throwOnError: false
+    },
+    resolveRetryConfig(options),
+    resolveRequestConfig(options)
+  );
+  return resolveResult(
+    result,
+    options.throwOnError ?? DEFAULT_OPTIONS.throwOnError,
+    options.validateResponse ?? DEFAULT_OPTIONS.validateResponse,
+    options.responseSchema
+  );
+}
+async function sendPutBinary(client, path, body, options = {}) {
+  const result = await undiciRetry.sendWithRetry(
+    client,
+    {
+      ...DEFAULT_OPTIONS,
+      path,
+      method: "PUT",
+      body,
+      query: options.query,
+      headers: copyWithoutUndefined({
+        "x-request-id": options.reqContext?.reqId,
+        ...options.headers
+      }),
+      reset: options.disableKeepAlive ?? false,
+      bodyTimeout: options.timeout,
+      throwOnError: false
+    },
+    resolveRetryConfig(options),
+    resolveRequestConfig(options)
+  );
+  return resolveResult(
+    result,
+    options.throwOnError ?? DEFAULT_OPTIONS.throwOnError,
+    options.validateResponse ?? DEFAULT_OPTIONS.validateResponse,
+    options.responseSchema
+  );
+}
+async function sendPatch(client, path, body, options = {}) {
+  const result = await undiciRetry.sendWithRetry(
+    client,
+    {
+      ...DEFAULT_OPTIONS,
+      path,
+      method: "PATCH",
+      body: body ? JSON.stringify(body) : void 0,
+      query: options.query,
+      headers: copyWithoutUndefined({
+        "x-request-id": options.reqContext?.reqId,
+        ...options.headers
+      }),
+      reset: options.disableKeepAlive ?? false,
+      bodyTimeout: options.timeout,
+      throwOnError: false
+    },
+    resolveRetryConfig(options),
+    resolveRequestConfig(options)
+  );
+  return resolveResult(
+    result,
+    options.throwOnError ?? DEFAULT_OPTIONS.throwOnError,
+    options.validateResponse ?? DEFAULT_OPTIONS.validateResponse,
+    options.responseSchema
+  );
+}
+function resolveRequestConfig(options) {
+  return {
+    safeParseJson: options.safeParseJson ?? false,
+    blobBody: options.blobResponseBody ?? false,
+    throwOnInternalError: false,
+    requestLabel: options.requestLabel
+  };
+}
+function resolveRetryConfig(options) {
+  return options.retryConfig ?? undiciRetry.NO_RETRY_CONFIG;
+}
+function buildClient(baseUrl, clientOptions) {
+  const newClient = new undici.Client(baseUrl, {
+    ...defaultClientOptions,
+    ...clientOptions
+  });
+  return newClient;
+}
+function resolveResult(requestResult, throwOnError, validateResponse, validationSchema, requestLabel) {
+  if (requestResult.error && throwOnError) {
+    if (undiciRetry.isRequestResult(requestResult.error)) {
+      throw new ResponseStatusError(requestResult.error, requestLabel);
+    }
+    throw requestResult.error;
+  }
+  if (requestResult.result && validateResponse && validationSchema) {
+    requestResult.result.body = validationSchema.parse(requestResult.result.body);
+  }
+  return requestResult;
+}
+const httpClient = {
+  get: sendGet,
+  post: sendPost,
+  put: sendPut,
+  patch: sendPatch,
+  del: sendDelete
+};
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class PublicNonRecoverableError extends Error {
+  constructor(params) {
+    super(params.message);
+    __publicField$1(this, "details");
+    __publicField$1(this, "errorCode");
+    __publicField$1(this, "httpStatusCode");
+    this.name = "PublicNonRecoverableError";
+    this.details = params.details;
+    this.errorCode = params.errorCode;
+    this.httpStatusCode = params.httpStatusCode ?? 500;
+  }
+}
+
+function isResponseStatusError(entity) {
+  return "isResponseStatusError" in entity;
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ConfigScope {
+  constructor(envOverride) {
+    __publicField(this, "env");
+    this.env = envOverride ?? { ...process.env };
+  }
+  updateEnv() {
+    this.env = { ...process.env };
+  }
+  getMandatoryInteger(param) {
+    const rawValue = this.env[param];
+    if (!rawValue) {
+      throw new InternalError({
+        message: `Missing mandatory configuration parameter: ${param}`,
+        errorCode: "CONFIGURATION_ERROR"
+      });
+    }
+    return validateNumber(
+      Number.parseInt(rawValue),
+      `Configuration parameter ${param}\` must be a number, but was ${rawValue}`
+    );
+  }
+  getMandatory(param) {
+    const result = this.env[param];
+    if (!result) {
+      throw new InternalError({
+        message: `Missing mandatory configuration parameter: ${param}`,
+        errorCode: "CONFIGURATION_ERROR"
+      });
+    }
+    return result;
+  }
+  getMandatoryOneOf(param, supportedValues) {
+    const result = this.getMandatory(param);
+    return validateOneOf(
+      result,
+      supportedValues,
+      `Unsupported ${param}: ${result}. Supported values: ${supportedValues.toString()}`
+    );
+  }
+  getMandatoryValidatedInteger(param, validator) {
+    const value = this.getMandatoryInteger(param);
+    if (!validator(value)) {
+      throw new InternalError({
+        message: `Value ${value} is invalid for parameter ${param}`,
+        errorCode: "CONFIGURATION_ERROR"
+      });
+    }
+    return value;
+  }
+  getOptionalNullable(param, defaultValue) {
+    return this.env[param] || defaultValue;
+  }
+  getOptional(param, defaultValue) {
+    return this.env[param] || defaultValue;
+  }
+  getOptionalInteger(param, defaultValue) {
+    const rawValue = this.env[param];
+    if (!rawValue) {
+      return defaultValue;
+    }
+    return validateNumber(
+      Number.parseInt(rawValue),
+      `Configuration parameter ${param}\` must be a number, but was ${rawValue}`
+    );
+  }
+  getOptionalNullableInteger(param, defaultValue) {
+    const rawValue = this.env[param];
+    if (!rawValue) {
+      return defaultValue;
+    }
+    return validateNumber(
+      Number.parseInt(rawValue),
+      `Configuration parameter ${param}\` must be a number, but was ${rawValue}`
+    );
+  }
+  getOptionalOneOf(param, defaultValue, supportedValues) {
+    const result = this.getOptional(param, defaultValue);
+    return validateOneOf(
+      result,
+      supportedValues,
+      `Unsupported ${param}: ${result}. Supported values: ${supportedValues.toString()}`
+    );
+  }
+  getOptionalValidated(param, defaultValue, validator) {
+    const value = this.env[param] || defaultValue;
+    if (!validator(value)) {
+      throw new InternalError({
+        message: `Value ${value} is invalid for parameter ${param}`,
+        errorCode: "CONFIGURATION_ERROR"
+      });
+    }
+    return value;
+  }
+  getOptionalValidatedInteger(param, defaultValue, validator) {
+    const value = this.getOptionalInteger(param, defaultValue);
+    if (!validator(value)) {
+      throw new InternalError({
+        message: `Value ${value} is invalid for parameter ${param}`,
+        errorCode: "CONFIGURATION_ERROR"
+      });
+    }
+    return value;
+  }
+  getOptionalTransformed(param, defaultValue, transformer) {
+    const value = this.env[param] || defaultValue;
+    return transformer(value);
+  }
+  getOptionalNullableTransformed(param, defaultValue, transformer) {
+    const value = this.env[param] || defaultValue;
+    return transformer(value);
+  }
+  getMandatoryTransformed(param, transformer) {
+    const value = this.getMandatory(param);
+    return transformer(value);
+  }
+  getOptionalBoolean(param, defaultValue) {
+    const rawValue = this.env[param]?.toLowerCase();
+    if (rawValue === void 0 || rawValue === "") {
+      return defaultValue;
+    }
+    validateOneOf(rawValue, ["true", "false"]);
+    return rawValue === "true";
+  }
+  getMandatoryJsonObject(param, schema) {
+    const rawValue = this.getMandatory(param);
+    return this.validateSchema(
+      JSON.parse(rawValue),
+      schema,
+      `Configuration parameter ${param} must be a valid JSON meeting the given schema, but was ${rawValue}`
+    );
+  }
+  getOptionalNullableJsonObject(param, schema, defaultValue) {
+    const rawValue = this.getOptionalNullable(param, void 0);
+    if (!rawValue) {
+      return defaultValue;
+    }
+    return this.validateSchema(
+      JSON.parse(rawValue),
+      schema,
+      `Configuration parameter ${param} must be a valid JSON meeting the given schema, but was ${rawValue}`
+    );
+  }
+  getOptionalJsonObject(param, schema, defaultValue) {
+    return this.getOptionalNullableJsonObject(param, schema, defaultValue);
+  }
+  isProduction() {
+    return this.env.NODE_ENV === "production";
+  }
+  isDevelopment() {
+    return this.env.NODE_ENV !== "production";
+  }
+  isTest() {
+    return this.env.NODE_ENV === "test";
+  }
+  validateSchema(value, schema, errorMessage) {
+    const parsedValue = schema.safeParse(value);
+    if (!parsedValue.success) {
+      throw new InternalError({
+        message: errorMessage,
+        errorCode: "CONFIGURATION_ERROR",
+        details: parsedValue.error
+      });
+    }
+    return parsedValue.data;
+  }
+}
+function validateOneOf(validatedEntity, expectedOneOfEntities, errorText) {
+  if (!expectedOneOfEntities.includes(validatedEntity)) {
+    throw new InternalError({
+      message: errorText || // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Validated entity ${validatedEntity} is not one of: ${expectedOneOfEntities.toString()}`,
+      errorCode: "CONFIGURATION_ERROR"
+    });
+  }
+  return validatedEntity;
+}
+function validateNumber(validatedObject, errorText) {
+  if (!Number.isFinite(validatedObject)) {
+    throw new InternalError({
+      message: errorText,
+      errorCode: "CONFIGURATION_ERROR"
+    });
+  }
+  return validatedObject;
+}
+
+const ensureClosingSlashTransformer = (value) => {
+  if (!value) {
+    return "";
+  }
+  const lastChar = value.at(-1);
+  if (lastChar !== "/") {
+    return `${value}/`;
+  }
+  return value;
+};
+
+const createRangeValidator = (greaterOrEqualThan, lessOrEqualThan) => {
+  return (value) => {
+    return value >= greaterOrEqualThan && value <= lessOrEqualThan;
+  };
+};
+
+const isFailure = (e) => {
+  return e.error !== void 0;
+};
+const isSuccess = (e) => {
+  return e.result !== void 0;
+};
+const failure = (error) => ({ error });
+const success = (result) => ({ result });
+
+function chunk(array, chunkSize) {
+  const length = array.length;
+  if (!length || chunkSize < 1) {
+    return [];
+  }
+  let index = 0;
+  let resIndex = 0;
+  const result = new Array(Math.ceil(length / chunkSize));
+  while (index < length) {
+    result[resIndex++] = array.slice(index, index += chunkSize);
+  }
+  return result;
+}
+async function callChunked(chunkSize, array, processFn) {
+  for (let i = 0; i < array.length; i += chunkSize) {
+    const arrayChunk = array.slice(i, i + chunkSize);
+    await processFn(arrayChunk);
+  }
+}
+function removeNullish(array) {
+  return array.filter((e) => e !== void 0 && e !== null);
+}
+function removeFalsy(array) {
+  return array.filter((e) => e);
+}
+
+function hasMessage(maybe) {
+  return isObject(maybe) && typeof maybe.message === "string";
+}
+function isObject(maybeObject) {
+  return typeof maybeObject === "object" && maybeObject !== null;
+}
+function isStandardizedError(error) {
+  return isObject(error) && typeof error.code === "string" && typeof error.message === "string";
+}
+function isInternalError(error) {
+  return isObject(error) && error.name === "InternalError";
+}
+function isPublicNonRecoverableError(error) {
+  return isObject(error) && error.name === "PublicNonRecoverableError";
+}
+
+function resolveMonorepoLoggerConfiguration(appConfig) {
+  if (appConfig.nodeEnv !== "development") {
+    return resolveLoggerConfiguration(appConfig);
+  }
+  return {
+    level: appConfig.logLevel,
+    formatters: {
+      level: (label) => {
+        return { level: label };
+      }
+    },
+    transport: {
+      target: "pino/file",
+      options: {
+        destination: appConfig.targetFile ?? "./service.log",
+        mkdir: true,
+        append: appConfig.append ?? false
+      }
+    }
+  };
+}
+function resolveLoggerConfiguration(appConfig) {
+  const config = {
+    level: appConfig.logLevel,
+    formatters: {
+      level: (label) => {
+        return { level: label };
+      }
+    },
+    base: appConfig.base
+  };
+  if (appConfig.nodeEnv !== "production") {
+    config.transport = {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "SYS:standard",
+        ignore: "hostname,pid"
+      }
+    };
+  }
+  return config;
+}
+
+const globalLogger = pino.pino({
+  formatters: {
+    level: (label, numericLevel) => {
+      const level = pino.levels.labels[numericLevel] || "unknown";
+      return { level };
+    }
+  }
+});
+function resolveGlobalErrorLogObject(err, correlationID) {
+  if (node_util.types.isNativeError(err)) {
+    return {
+      ...pino.stdSerializers.err(err),
+      correlationID
+    };
+  }
+  if (hasMessage(err)) {
+    return correlationID ? `${err.message} (${correlationID})` : err.message;
+  }
+  return "Unknown error";
+}
+function logGlobalErrorLogObject(logObject) {
+  if (typeof logObject === "string") {
+    globalLogger.error(`Global error: ${logObject}`);
+  } else {
+    globalLogger.error(logObject, logObject.message);
+  }
+}
+function executeAndHandleGlobalErrors(operation) {
+  try {
+    const result = operation();
+    return result;
+  } catch (err) {
+    const logObject = resolveGlobalErrorLogObject(err);
+    logGlobalErrorLogObject(logObject);
+    process.exit(1);
+  }
+}
+async function executeAsyncAndHandleGlobalErrors(operation, stopOnError = true) {
+  try {
+    const result = await operation();
+    return result;
+  } catch (err) {
+    const logObject = resolveGlobalErrorLogObject(err);
+    logGlobalErrorLogObject(logObject);
+    if (stopOnError) {
+      process.exit(1);
+    }
+  }
+}
+async function executeSettleAllAndHandleGlobalErrors(promises, stopOnError = true) {
+  const result = await Promise.allSettled(promises);
+  let errorsHappened;
+  for (const entry of result) {
+    if (entry.status === "rejected") {
+      const logObject = resolveGlobalErrorLogObject(entry.reason);
+      logGlobalErrorLogObject(logObject);
+      errorsHappened = true;
+    }
+  }
+  if (stopOnError && errorsHappened) {
+    process.exit(1);
+  }
+  return result;
+}
+
+class RequestValidationError extends PublicNonRecoverableError {
+  constructor(errors) {
+    super({
+      message: "Invalid params",
+      errorCode: "VALIDATION_ERROR",
+      httpStatusCode: node_http2.constants.HTTP_STATUS_BAD_REQUEST,
+      details: {
+        error: errors
+      }
+    });
+  }
+}
+class AccessDeniedError extends PublicNonRecoverableError {
+  constructor(params) {
+    super({
+      message: params.message,
+      errorCode: "ACCESS_DENIED",
+      httpStatusCode: node_http2.constants.HTTP_STATUS_FORBIDDEN,
+      details: params.details
+    });
+  }
+}
+class EntityNotFoundError extends PublicNonRecoverableError {
+  constructor(params) {
+    super({
+      message: params.message,
+      errorCode: "ENTITY_NOT_FOUND",
+      httpStatusCode: node_http2.constants.HTTP_STATUS_NOT_FOUND,
+      details: params.details
+    });
+  }
+}
+class AuthFailedError extends PublicNonRecoverableError {
+  constructor(params = {}) {
+    super({
+      message: params.message ?? "Authentication failed",
+      errorCode: "AUTH_FAILED",
+      httpStatusCode: node_http2.constants.HTTP_STATUS_UNAUTHORIZED,
+      details: params.details
+    });
+  }
+}
+
+const waitAndRetry = async (predicateFn, sleepTime = 20, maxRetryCount = 15) => {
+  return new Promise((resolve, reject) => {
+    let retryCount = 0;
+    function performCheck() {
+      if (maxRetryCount !== 0 && retryCount > maxRetryCount) {
+        resolve(predicateFn());
+      }
+      Promise.resolve().then(() => {
+        return predicateFn();
+      }).then((result) => {
+        if (result) {
+          resolve(result);
+        } else {
+          retryCount++;
+          setTimeout(performCheck, sleepTime);
+        }
+      }).catch((err) => {
+        reject(err);
+      });
+    }
+    performCheck();
+  });
+};
+
+exports.AccessDeniedError = AccessDeniedError;
+exports.AuthFailedError = AuthFailedError;
+exports.ConfigScope = ConfigScope;
+exports.EntityNotFoundError = EntityNotFoundError;
+exports.InternalError = InternalError;
+exports.PublicNonRecoverableError = PublicNonRecoverableError;
+exports.RequestValidationError = RequestValidationError;
+exports.ResponseStatusError = ResponseStatusError;
+exports.buildClient = buildClient;
+exports.callChunked = callChunked;
+exports.chunk = chunk;
+exports.convertDateFieldsToIsoString = convertDateFieldsToIsoString;
+exports.copyWithoutUndefined = copyWithoutUndefined;
+exports.createRangeValidator = createRangeValidator;
+exports.deepClone = deepClone;
+exports.ensureClosingSlashTransformer = ensureClosingSlashTransformer;
+exports.executeAndHandleGlobalErrors = executeAndHandleGlobalErrors;
+exports.executeAsyncAndHandleGlobalErrors = executeAsyncAndHandleGlobalErrors;
+exports.executeSettleAllAndHandleGlobalErrors = executeSettleAllAndHandleGlobalErrors;
+exports.failure = failure;
+exports.globalLogger = globalLogger;
+exports.groupBy = groupBy;
+exports.groupByUnique = groupByUnique;
+exports.hasMessage = hasMessage;
+exports.httpClient = httpClient;
+exports.isEmptyObject = isEmptyObject;
+exports.isFailure = isFailure;
+exports.isInternalError = isInternalError;
+exports.isObject = isObject;
+exports.isPublicNonRecoverableError = isPublicNonRecoverableError;
+exports.isResponseStatusError = isResponseStatusError;
+exports.isStandardizedError = isStandardizedError;
+exports.isSuccess = isSuccess;
+exports.pick = pick;
+exports.pickWithoutUndefined = pickWithoutUndefined;
+exports.removeFalsy = removeFalsy;
+exports.removeNullish = removeNullish;
+exports.resolveGlobalErrorLogObject = resolveGlobalErrorLogObject;
+exports.resolveLoggerConfiguration = resolveLoggerConfiguration;
+exports.resolveMonorepoLoggerConfiguration = resolveMonorepoLoggerConfiguration;
+exports.sendDelete = sendDelete;
+exports.sendGet = sendGet;
+exports.sendPatch = sendPatch;
+exports.sendPost = sendPost;
+exports.sendPostBinary = sendPostBinary;
+exports.sendPut = sendPut;
+exports.sendPutBinary = sendPutBinary;
+exports.success = success;
+exports.waitAndRetry = waitAndRetry;