@rockcarver/frodo-cli 3.0.5 → 3.0.6

package/dist/app.cjs

@@ -106883,7 +106883,7 @@ function stringify(obj) {
 }
 var package_default = {
   name: "@rockcarver/frodo-lib",
-  version: "3.1.0",
+  version: "3.3.0",
   type: "commonjs",
   main: "./dist/index.js",
   module: "./dist/index.mjs",
@@ -107079,6 +107079,12 @@ var State_default = (initialState) => {
     getRealm() {
       return state2.realm || process.env.FRODO_REALM;
     },
+    setUseRealmPrefixOnManagedObjects(useRealmPrefixOnManagedObjects) {
+      state2.useRealmPrefixOnManagedObjects = useRealmPrefixOnManagedObjects;
+    },
+    getUseRealmPrefixOnManagedObjects() {
+      return state2.useRealmPrefixOnManagedObjects || false;
+    },
     setDeploymentType(type) {
       state2.deploymentType = type;
     },
@@ -124829,6 +124835,81 @@ async function deleteRealm({
 }
 var import_replaceall = __toESM2(require_replaceall_min());
 var import_slugify2 = __toESM2(require_slugify());
+var FrodoError = class extends Error {
+  constructor(message, originalErrors = null) {
+    super(message);
+    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "originalErrors", []);
+    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "isHttpError", false);
+    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpCode");
+    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpStatus");
+    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpMessage");
+    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpDetail");
+    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpErrorText");
+    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpErrorReason");
+    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpDescription");
+    this.name = this.constructor.name;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+    if (originalErrors && Array.isArray(originalErrors)) {
+      this.originalErrors = originalErrors;
+    } else if (originalErrors) {
+      this.originalErrors = [originalErrors];
+    }
+    if (originalErrors) {
+      const error2 = this.originalErrors[0];
+      this.isHttpError = error2.name === "AxiosError";
+      this.httpCode = error2["code"];
+      this.httpStatus = error2["response"] ? error2["response"].status : null;
+      this.httpMessage = error2["response"] ? error2["response"].data ? error2["response"].data.message : null : null;
+      this.httpDetail = error2["response"] ? error2["response"].data ? error2["response"].data.detail : null : null;
+      this.httpErrorText = error2["response"] ? error2["response"].data ? error2["response"].data.error : null : null;
+      this.httpErrorReason = error2["response"] ? error2["response"].data ? error2["response"].data.reason : null : null;
+      this.httpDescription = error2["response"] ? error2["response"].data ? error2["response"].data.error_description : null : null;
+    }
+  }
+  getOriginalErrors() {
+    return this.originalErrors;
+  }
+  getCombinedMessage() {
+    let combinedMessage = this.message || "";
+    this.originalErrors.forEach((error2) => {
+      switch (error2.name) {
+        case "FrodoError":
+          combinedMessage += "\n  " + error2.getCombinedMessage();
+          break;
+        case "AxiosError":
+          {
+            combinedMessage += "\n  HTTP client error";
+            combinedMessage += this.httpCode ? `
+    Code: ${this.httpCode}` : "";
+            combinedMessage += this.httpStatus ? `
+    Status: ${this.httpStatus}` : "";
+            combinedMessage += this.httpErrorText ? `
+    Error: ${this.httpErrorText}` : "";
+            combinedMessage += this.httpErrorReason ? `
+    Reason: ${this.httpErrorReason}` : "";
+            combinedMessage += this.httpMessage ? `
+    Message: ${this.httpMessage}` : "";
+            combinedMessage += this.httpDetail ? `
+    Detail: ${this.httpDetail}` : "";
+            combinedMessage += this.httpDescription ? `
+    Description: ${this.httpDescription}` : "";
+          }
+          break;
+        default:
+          combinedMessage += "\n  " + error2.message;
+          break;
+      }
+    });
+    return combinedMessage;
+  }
+  toString() {
+    return this.getCombinedMessage();
+  }
+};
 var DEFAULT_REALM_KEY = "__default__realm__";
 var CLASSIC_DEPLOYMENT_TYPE_KEY = "classic";
 var CLOUD_DEPLOYMENT_TYPE_KEY = "cloud";
@@ -125229,102 +125310,55 @@ function isValidUrl(urlString) {
     return false;
   }
 }
-async function exportOrImportWithErrorHandling(func, parameters, errors, perform = true) {
-  try {
-    return perform ? await func(parameters) : null;
-  } catch (error2) {
-    if (errors && Array.isArray(errors)) {
-      errors.push(error2);
-    }
-    return null;
-  }
-}
-async function exportWithErrorHandling(func, parameters, errors, perform = true) {
-  return exportOrImportWithErrorHandling(func, parameters, errors, perform);
+async function exportWithErrorHandling(func, parameters, type, resultCallback = void 0, perform = true) {
+  return perform ? await getResult(
+    resultCallback,
+    `Error Exporting ${type}`,
+    func,
+    parameters
+  ) : null;
 }
-async function importWithErrorHandling(func, parameters, errors, id7, type, perform = true) {
+async function importWithErrorHandling(func, parameters, id7, type, resultCallback = void 0, perform = true) {
   updateProgressIndicator({
     id: id7,
     message: perform ? `Importing ${type}...` : `Skipping ${type}...`,
     state: parameters.state
   });
-  return exportOrImportWithErrorHandling(func, parameters, errors, perform);
+  return perform ? await getResult(
+    resultCallback,
+    `Error Importing ${type}`,
+    func,
+    parameters
+  ) : null;
 }
-var FrodoError = class extends Error {
-  constructor(message, originalErrors = null) {
-    super(message);
-    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "originalErrors", []);
-    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "isHttpError", false);
-    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpCode");
-    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpStatus");
-    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpMessage");
-    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpDetail");
-    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpErrorText");
-    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpErrorReason");
-    _chunkHEKQUNOBcjs.__publicField.call(void 0, this, "httpDescription");
-    this.name = this.constructor.name;
-    if (typeof Error.captureStackTrace === "function") {
-      Error.captureStackTrace(this, this.constructor);
+async function getResult(resultCallback, errorMessage, func, ...parameters) {
+  try {
+    const result = await func(...parameters);
+    if (resultCallback) {
+      resultCallback(void 0, result);
+    }
+    return result;
+  } catch (e) {
+    const error2 = errorMessage ? new FrodoError(errorMessage, e) : e;
+    if (resultCallback) {
+      resultCallback(error2, void 0);
     } else {
-      this.stack = new Error(message).stack;
+      throw error2;
     }
-    if (originalErrors && Array.isArray(originalErrors)) {
-      this.originalErrors = originalErrors;
-    } else if (originalErrors) {
-      this.originalErrors = [originalErrors];
+  }
+}
+function getErrorCallback(resultCallback, errorFilter = () => true) {
+  return (e) => {
+    if (!e || !errorFilter(e)) {
+      return;
     }
-    if (originalErrors) {
-      const error2 = this.originalErrors[0];
-      this.isHttpError = error2.name === "AxiosError";
-      this.httpCode = error2["code"];
-      this.httpStatus = error2["response"] ? error2["response"].status : null;
-      this.httpMessage = error2["response"] ? error2["response"].data ? error2["response"].data.message : null : null;
-      this.httpDetail = error2["response"] ? error2["response"].data ? error2["response"].data.detail : null : null;
-      this.httpErrorText = error2["response"] ? error2["response"].data ? error2["response"].data.error : null : null;
-      this.httpErrorReason = error2["response"] ? error2["response"].data ? error2["response"].data.reason : null : null;
-      this.httpDescription = error2["response"] ? error2["response"].data ? error2["response"].data.error_description : null : null;
+    if (resultCallback) {
+      resultCallback(e, void 0);
+      return;
     }
-  }
-  getOriginalErrors() {
-    return this.originalErrors;
-  }
-  getCombinedMessage() {
-    let combinedMessage = this.message || "";
-    this.originalErrors.forEach((error2) => {
-      switch (error2.name) {
-        case "FrodoError":
-          combinedMessage += "\n  " + error2.getCombinedMessage();
-          break;
-        case "AxiosError":
-          {
-            combinedMessage += "\n  HTTP client error";
-            combinedMessage += this.httpCode ? `
-    Code: ${this.httpCode}` : "";
-            combinedMessage += this.httpStatus ? `
-    Status: ${this.httpStatus}` : "";
-            combinedMessage += this.httpErrorText ? `
-    Error: ${this.httpErrorText}` : "";
-            combinedMessage += this.httpErrorReason ? `
-    Reason: ${this.httpErrorReason}` : "";
-            combinedMessage += this.httpMessage ? `
-    Message: ${this.httpMessage}` : "";
-            combinedMessage += this.httpDetail ? `
-    Detail: ${this.httpDetail}` : "";
-            combinedMessage += this.httpDescription ? `
-    Description: ${this.httpDescription}` : "";
-          }
-          break;
-        default:
-          combinedMessage += "\n  " + error2.message;
-          break;
-      }
-    });
-    return combinedMessage;
-  }
-  toString() {
-    return this.getCombinedMessage();
-  }
-};
+    throw e;
+  };
+}
 var RealmOps_default = (state2) => {
   return {
     readRealms() {
@@ -125668,8 +125702,12 @@ function getCurrentRealmManagedUser({
   state: state2
 }) {
   let realmManagedUser = "user";
-  if (state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY) {
+  if (state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY || state2.getUseRealmPrefixOnManagedObjects() === true) {
     realmManagedUser = `${getCurrentRealmName(state2)}_user`;
+    debugMessage({
+      message: `DeploymentType === cloud or UseRealmPrefixOnManagedObjects is true, returning '${realmManagedUser}'`,
+      state: state2
+    });
   }
   return realmManagedUser;
 }
@@ -127588,8 +127626,8 @@ var IdmConfigOps_default = (state2) => {
     async exportConfigEntities(options = {
       envReplaceParams: void 0,
       entitiesToExport: void 0
-    }) {
-      return exportConfigEntities({ options, state: state2 });
+    }, resultCallback = void 0) {
+      return exportConfigEntities({ options, resultCallback, state: state2 });
     },
     async createConfigEntity(entityId, entityData, wait = false) {
       return createConfigEntity({ entityId, entityData, wait, state: state2 });
@@ -127597,14 +127635,20 @@ var IdmConfigOps_default = (state2) => {
     async updateConfigEntity(entityId, entityData, wait = false) {
       return updateConfigEntity({ entityId, entityData, wait, state: state2 });
     },
-    async importConfigEntities(importData, entityId, options = { validate: false }) {
-      return importConfigEntities({ entityId, importData, options, state: state2 });
+    async importConfigEntities(importData, entityId, options = { validate: false }, resultCallback = void 0) {
+      return importConfigEntities({
+        entityId,
+        importData,
+        options,
+        resultCallback,
+        state: state2
+      });
     },
-    async deleteConfigEntities() {
-      return deleteConfigEntities({ state: state2 });
+    async deleteConfigEntities(resultCallback = void 0) {
+      return deleteConfigEntities({ resultCallback, state: state2 });
     },
-    async deleteConfigEntitiesByType(type) {
-      return deleteConfigEntitiesByType({ type, state: state2 });
+    async deleteConfigEntitiesByType(type, resultCallback = void 0) {
+      return deleteConfigEntitiesByType({ type, resultCallback, state: state2 });
     },
     async deleteConfigEntity(entityId) {
       return deleteConfigEntity({ entityId, state: state2 });
@@ -127757,75 +127801,65 @@ async function exportConfigEntity({
     exportData.idm[entity._id] = entity;
     return exportData;
   } catch (error2) {
-    printError(error2);
+    throw new FrodoError(`Error getting config entity ${entityId}`, error2);
   }
 }
 async function exportConfigEntities({
   options = { envReplaceParams: void 0, entitiesToExport: void 0 },
+  resultCallback = void 0,
   state: state2
 }) {
-  let indicatorId;
-  try {
-    let configurations = await readConfigEntities({ state: state2 });
-    if (options.entitiesToExport && options.entitiesToExport.length > 0) {
-      configurations = configurations.filter(
-        (c) => options.entitiesToExport.includes(c._id)
-      );
-    }
-    indicatorId = createProgressIndicator({
-      total: configurations.length,
-      message: "Exporting config entities...",
-      state: state2
-    });
-    const entityPromises = [];
-    for (const configEntity of configurations) {
-      updateProgressIndicator({
-        id: indicatorId,
-        message: `Exporting config entity ${configEntity._id}`,
-        state: state2
-      });
-      entityPromises.push(
-        readConfigEntity({ entityId: configEntity._id, state: state2 }).catch(
-          (readConfigEntityError) => {
-            const error2 = readConfigEntityError;
-            if (
-              // operation is not available in PingOne Advanced Identity Cloud
-              !(error2.httpStatus === 403 && error2.httpMessage === "This operation is not available in PingOne Advanced Identity Cloud.") && // list of config entities, which do not exist by default or ever.
-              !(IDM_UNAVAILABLE_ENTITIES.includes(configEntity._id) && error2.httpStatus === 404 && error2.httpErrorReason === "Not Found") && // https://bugster.forgerock.org/jira/browse/OPENIDM-18270
-              !(error2.httpStatus === 404 && error2.httpMessage === "No configuration exists for id org.apache.felix.fileinstall/openidm")
-            ) {
-              printMessage({
-                message: _optionalChain([readConfigEntityError, 'access', _92 => _92.response, 'optionalAccess', _93 => _93.data]),
-                type: "error",
-                state: state2
-              });
-              printMessage({
-                message: `Error getting config entity ${configEntity._id}: ${readConfigEntityError}`,
-                type: "error",
-                state: state2
-              });
-            }
-          }
-        )
-      );
-    }
-    const exportData = createConfigEntityExportTemplate({ state: state2 });
-    (await Promise.all(entityPromises)).filter((c) => c).forEach((entity) => {
-      exportData.idm[entity._id] = substituteEntityWithEnv(
-        entity,
-        options.envReplaceParams
-      );
-    });
-    stopProgressIndicator({
+  const exportData = createConfigEntityExportTemplate({ state: state2 });
+  let configurations = await readConfigEntities({ state: state2 });
+  if (options.entitiesToExport && options.entitiesToExport.length > 0) {
+    configurations = configurations.filter(
+      (c) => options.entitiesToExport.includes(c._id)
+    );
+  }
+  const indicatorId = createProgressIndicator({
+    total: configurations.length,
+    message: "Exporting config entities...",
+    state: state2
+  });
+  const entityPromises = [];
+  for (const configEntity of configurations) {
+    updateProgressIndicator({
       id: indicatorId,
-      message: `Exported ${configurations.length} config entities.`,
-      status: "success",
+      message: `Exporting config entity ${configEntity._id}`,
       state: state2
     });
-    return exportData;
-  } catch (error2) {
-    printError(error2);
+    entityPromises.push(
+      getResult(
+        getErrorCallback(
+          resultCallback,
+          (error2) => !// operation is not available in PingOne Advanced Identity Cloud
+          (error2.httpStatus === 403 && error2.httpMessage === "This operation is not available in PingOne Advanced Identity Cloud.") && // list of config entities, which do not exist by default or ever.
+          !(IDM_UNAVAILABLE_ENTITIES.includes(configEntity._id) && error2.httpStatus === 404 && error2.httpErrorReason === "Not Found") && // https://bugster.forgerock.org/jira/browse/OPENIDM-18270
+          !(error2.httpStatus === 404 && error2.httpMessage === "No configuration exists for id org.apache.felix.fileinstall/openidm")
+        ),
+        `Error exporting idm config entity ${configEntity._id}`,
+        readConfigEntity,
+        { entityId: configEntity._id, state: state2 }
+      )
+    );
   }
+  (await Promise.all(entityPromises)).filter((c) => c).forEach((entity) => {
+    const substitutedEntity = substituteEntityWithEnv(
+      entity,
+      options.envReplaceParams
+    );
+    exportData.idm[entity._id] = substitutedEntity;
+    if (resultCallback) {
+      resultCallback(void 0, substitutedEntity);
+    }
+  });
+  stopProgressIndicator({
+    id: indicatorId,
+    message: `Exported ${configurations.length} config entities.`,
+    status: "success",
+    state: state2
+  });
+  return exportData;
 }
 async function createConfigEntity({
   entityId,
@@ -127878,11 +127912,11 @@ async function importConfigEntities({
     entitiesToImport: void 0,
     validate: false
   },
+  resultCallback = void 0,
   state: state2
 }) {
   debugMessage({ message: `IdmConfigOps.importConfigEntities: start`, state: state2 });
   const response = [];
-  const errors = [];
   let ids = Object.keys(importData.idm);
   if (options.entitiesToImport && options.entitiesToImport.length > 0) {
     ids = ids.filter((id7) => options.entitiesToImport.includes(id7));
@@ -127905,32 +127939,36 @@ async function importConfigEntities({
           `Invalid script hook in the config object '${id7}'`
         );
       }
-      try {
-        const result = await updateConfigEntity({
-          entityId: id7,
-          entityData,
-          state: state2
-        });
-        response.push(result);
-      } catch (error2) {
-        if (
-          // protected entities (e.g. root realm email templates)
-          !(state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY && AIC_PROTECTED_ENTITIES.includes(id7) && error2.httpStatus === 403 && error2.httpCode === "ERR_BAD_REQUEST")
-        ) {
-          throw error2;
-        }
+      const result = await updateConfigEntity({
+        entityId: id7,
+        entityData,
+        state: state2
+      });
+      response.push(result);
+      if (resultCallback) {
+        resultCallback(void 0, result);
       }
     } catch (error2) {
-      errors.push(error2);
+      if (
+        // protected entities (e.g. root realm email templates)
+        !(state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY && AIC_PROTECTED_ENTITIES.includes(id7) && error2.httpStatus === 403 && error2.httpCode === "ERR_BAD_REQUEST")
+      ) {
+        if (resultCallback) {
+          resultCallback(error2, void 0);
+        } else {
+          throw new FrodoError(
+            `Error importing idm config entity ${id7}`,
+            error2
+          );
+        }
+      }
     }
   }
-  if (errors.length > 0) {
-    throw new FrodoError(`Error importing config entities`, errors);
-  }
   debugMessage({ message: `IdmConfigOps.importConfigEntities: end`, state: state2 });
   return response;
 }
 async function deleteConfigEntities({
+  resultCallback = void 0,
   state: state2
 }) {
   debugMessage({
@@ -127938,30 +127976,23 @@ async function deleteConfigEntities({
     state: state2
   });
   const result = [];
-  const errors = [];
-  try {
-    const configEntityStubs = await readConfigEntityStubs({ state: state2 });
-    for (const configEntityStub of configEntityStubs) {
-      try {
-        debugMessage({
-          message: `IdmConfigOps.deleteConfigEntities: '${configEntityStub["_id"]}'`,
+  const configEntityStubs = await readConfigEntityStubs({ state: state2 });
+  for (const configEntityStub of configEntityStubs) {
+    debugMessage({
+      message: `IdmConfigOps.deleteConfigEntities: '${configEntityStub["_id"]}'`,
+      state: state2
+    });
+    result.push(
+      await getResult(
+        resultCallback,
+        `Error deleting idm config entity ${configEntityStub._id}`,
+        deleteConfigEntity2,
+        {
+          entityId: configEntityStub["_id"],
           state: state2
-        });
-        result.push(
-          await deleteConfigEntity2({
-            entityId: configEntityStub["_id"],
-            state: state2
-          })
-        );
-      } catch (error2) {
-        errors.push(error2);
-      }
-    }
-  } catch (error2) {
-    errors.push(error2);
-  }
-  if (errors.length > 0) {
-    throw new FrodoError(`Error deleting config entities`, errors);
+        }
+      )
+    );
   }
   debugMessage({
     message: `IdmConfigOps.deleteConfigEntities: end`,
@@ -127971,6 +128002,7 @@ async function deleteConfigEntities({
 }
 async function deleteConfigEntitiesByType({
   type,
+  resultCallback = void 0,
   state: state2
 }) {
   debugMessage({
@@ -127978,39 +128010,29 @@ async function deleteConfigEntitiesByType({
     state: state2
   });
   const result = [];
-  const errors = [];
-  try {
-    const configEntities = await readConfigEntitiesByType({ type, state: state2 });
-    for (const configEntity of configEntities) {
-      try {
-        debugMessage({
-          message: `IdmConfigOps.deleteConfigEntitiesByType: '${configEntity["_id"]}'`,
-          state: state2
-        });
-        result.push(
-          await deleteConfigEntity2({
-            entityId: configEntity["_id"],
-            state: state2
-          })
-        );
-      } catch (error2) {
-        errors.push(error2);
-      }
-    }
-    if (errors.length > 0) {
-      throw new FrodoError(`Error deleting config entities by type`, errors);
-    }
+  const configEntities = await readConfigEntitiesByType({ type, state: state2 });
+  for (const configEntity of configEntities) {
     debugMessage({
-      message: `IdmConfigOps.deleteConfigEntitiesByType: end`,
+      message: `IdmConfigOps.deleteConfigEntitiesByType: '${configEntity["_id"]}'`,
       state: state2
     });
-    return result;
-  } catch (error2) {
-    if (errors.length > 0) {
-      throw error2;
-    }
-    throw new FrodoError(`Error deleting config entities by type`, error2);
+    result.push(
+      await getResult(
+        resultCallback,
+        `Error deleting idm config entity ${configEntity._id}`,
+        deleteConfigEntity2,
+        {
+          entityId: configEntity["_id"],
+          state: state2
+        }
+      )
+    );
   }
+  debugMessage({
+    message: `IdmConfigOps.deleteConfigEntitiesByType: end`,
+    state: state2
+  });
+  return result;
 }
 async function deleteConfigEntity({
   entityId,
@@ -128043,7 +128065,7 @@ async function readSubConfigEntity({
     }
     return subEntity;
   } catch (error2) {
-    printError(error2);
+    throw new FrodoError(`Error reading sub config ${entityId} ${name}`, error2);
   }
 }
 async function importSubConfigEntity({
@@ -128061,13 +128083,13 @@ async function importSubConfigEntity({
       entityId,
       state: state2
     });
-    const subEntityKey = Object.keys(_optionalChain([entityExport, 'access', _94 => _94.idm, 'optionalAccess', _95 => _95[entityId]])).find(
+    const subEntityKey = Object.keys(_optionalChain([entityExport, 'access', _92 => _92.idm, 'optionalAccess', _93 => _93[entityId]])).find(
       (key) => key !== "_id"
     );
-    if (!Array.isArray(_optionalChain([entityExport, 'access', _96 => _96.idm, 'optionalAccess', _97 => _97[entityId], 'optionalAccess', _98 => _98[subEntityKey]]))) {
+    if (!Array.isArray(_optionalChain([entityExport, 'access', _94 => _94.idm, 'optionalAccess', _95 => _95[entityId], 'optionalAccess', _96 => _96[subEntityKey]]))) {
       throw new FrodoError(`Error importing sub config of ${entityId}`);
     }
-    const existingSubEntityIndex = (_optionalChain([entityExport, 'access', _99 => _99.idm, 'optionalAccess', _100 => _100[entityId], 'optionalAccess', _101 => _101[subEntityKey]])).findIndex((item) => item.name === updatedSubConfigEntity.name);
+    const existingSubEntityIndex = (_optionalChain([entityExport, 'access', _97 => _97.idm, 'optionalAccess', _98 => _98[entityId], 'optionalAccess', _99 => _99[subEntityKey]])).findIndex((item) => item.name === updatedSubConfigEntity.name);
     if (existingSubEntityIndex !== -1) {
       entityExport.idm[entityId][subEntityKey][existingSubEntityIndex] = updatedSubConfigEntity;
     } else {
@@ -128725,7 +128747,7 @@ async function readOAuth2Provider({
   try {
     return await getOAuth2Provider({ state: state2 });
   } catch (error2) {
-    if (error2.httpStatus === 404 || _optionalChain([error2, 'access', _102 => _102.response, 'optionalAccess', _103 => _103.status]) === 404) {
+    if (error2.httpStatus === 404 || _optionalChain([error2, 'access', _100 => _100.response, 'optionalAccess', _101 => _101.status]) === 404) {
       return null;
     } else {
       throw new FrodoError(`Error reading oauth2 provider`, error2);
@@ -128884,32 +128906,6 @@ async function deleteScriptByName({
     state: state2
   });
 }
-async function deleteScripts({
-  state: state2
-}) {
-  const { result } = await getScripts({ state: state2 });
-  const scripts = result.filter((s4) => !s4.default);
-  const deletedScripts = [];
-  const errors = [];
-  for (const script of scripts) {
-    try {
-      deletedScripts.push(
-        await deleteScript({
-          scriptId: script._id,
-          state: state2
-        })
-      );
-    } catch (error2) {
-      errors.push(error2);
-    }
-  }
-  if (errors.length) {
-    const errorMessages = errors.map((error2) => error2.message).join("\n");
-    throw new Error(`Delete error:
-${errorMessages}`);
-  }
-  return deletedScripts;
-}
 var ScriptOps_default = (state2) => {
   return {
     createScriptExportTemplate() {
@@ -128939,8 +128935,8 @@ var ScriptOps_default = (state2) => {
     async deleteScriptByName(scriptName) {
       return deleteScriptByName2({ scriptName, state: state2 });
     },
-    async deleteScripts() {
-      return deleteScripts2({ state: state2 });
+    async deleteScripts(resultCallback = void 0) {
+      return deleteScripts({ resultCallback, state: state2 });
     },
     async exportScript(scriptId, options = {
       deps: true,
@@ -128960,20 +128956,21 @@ var ScriptOps_default = (state2) => {
       deps: true,
       includeDefault: false,
       useStringArrays: true
-    }) {
-      return exportScripts({ options, state: state2 });
+    }, resultCallback = void 0) {
+      return exportScripts({ options, resultCallback, state: state2 });
     },
     async importScripts(scriptId, scriptName, importData, options = {
       deps: true,
       reUuid: false,
       includeDefault: false
-    }, validate3 = false) {
+    }, validate3 = false, resultCallback = void 0) {
       return importScripts2({
         scriptId,
         scriptName,
         importData,
         options,
         validate: validate3,
+        resultCallback,
         state: state2
       });
     },
@@ -129116,7 +129113,7 @@ async function updateScript({
     }
     result = await putScript({ scriptId, scriptData, state: state2 });
   } catch (error2) {
-    if (_optionalChain([error2, 'access', _104 => _104.response, 'optionalAccess', _105 => _105.status]) === 409) {
+    if (_optionalChain([error2, 'access', _102 => _102.response, 'optionalAccess', _103 => _103.status]) === 409) {
       verboseMessage({
         message: `createOrUpdateScript WARNING: script with name ${scriptData.name} already exists, using renaming policy... <name> => <name - imported (n)>`,
         state: state2
@@ -129152,14 +129149,26 @@ async function deleteScriptByName2({
     throw new FrodoError(`Error deleting script ${scriptName}`, error2);
   }
 }
-async function deleteScripts2({
+async function deleteScripts({
+  resultCallback = void 0,
   state: state2
 }) {
-  try {
-    return deleteScripts({ state: state2 });
-  } catch (error2) {
-    throw new FrodoError(`Error deleting scripts`, error2);
+  const result = await readScripts({ state: state2 });
+  const scripts = result.filter((s4) => !s4.default);
+  const deletedScripts = [];
+  for (const script of scripts) {
+    const result2 = await getResult(
+      resultCallback,
+      `Error deleting script ${script.name}`,
+      deleteScript2,
+      {
+        scriptId: script._id,
+        state: state2
+      }
+    );
+    deletedScripts.push(result2);
   }
+  return deletedScripts;
 }
 async function exportScript({
   scriptId,
@@ -129205,58 +129214,42 @@ async function exportScripts({
     includeDefault: false,
     useStringArrays: true
   },
+  resultCallback = void 0,
   state: state2
 }) {
-  const errors = [];
-  let indicatorId;
-  try {
-    const { includeDefault, useStringArrays } = options;
-    let scriptList = await readScripts({ state: state2 });
-    if (!includeDefault)
-      scriptList = scriptList.filter((script) => !script.default);
-    const exportData = createScriptExportTemplate({ state: state2 });
-    indicatorId = createProgressIndicator({
-      total: scriptList.length,
-      message: `Exporting ${scriptList.length} scripts...`,
-      state: state2
-    });
-    for (const scriptData of scriptList) {
-      try {
-        updateProgressIndicator({
-          id: indicatorId,
-          message: `Reading script ${scriptData.name}`,
-          state: state2
-        });
-        exportData.script[scriptData._id] = await prepareScriptForExport({
-          scriptData,
-          useStringArrays,
-          state: state2
-        });
-      } catch (error2) {
-        errors.push(error2);
-      }
-    }
-    if (errors.length > 0) {
-      throw new FrodoError(``, errors);
-    }
-    stopProgressIndicator({
-      id: indicatorId,
-      message: `Exported ${scriptList.length} scripts.`,
-      state: state2
-    });
-    return exportData;
-  } catch (error2) {
-    stopProgressIndicator({
+  const { includeDefault, useStringArrays } = options;
+  let scriptList = await readScripts({ state: state2 });
+  if (!includeDefault)
+    scriptList = scriptList.filter((script) => !script.default);
+  const exportData = createScriptExportTemplate({ state: state2 });
+  const indicatorId = createProgressIndicator({
+    total: scriptList.length,
+    message: `Exporting ${scriptList.length} scripts...`,
+    state: state2
+  });
+  for (const scriptData of scriptList) {
+    updateProgressIndicator({
       id: indicatorId,
-      message: `Error exporting scripts`,
-      status: "fail",
+      message: `Reading script ${scriptData.name}`,
       state: state2
     });
-    if (errors.length > 0) {
-      throw error2;
-    }
-    throw new FrodoError(`Error exporting scripts`, error2);
+    exportData.script[scriptData._id] = await getResult(
+      resultCallback,
+      `Error exporting script ${scriptData.name}`,
+      prepareScriptForExport,
+      {
+        scriptData,
+        useStringArrays,
+        state: state2
+      }
+    );
   }
+  stopProgressIndicator({
+    id: indicatorId,
+    message: `Exported ${scriptList.length} scripts.`,
+    state: state2
+  });
+  return exportData;
 }
 async function importScripts2({
   scriptId,
@@ -129268,61 +129261,57 @@ async function importScripts2({
     includeDefault: false
   },
   validate: validate3 = false,
+  resultCallback = void 0,
   state: state2
 }) {
-  const errors = [];
-  try {
-    debugMessage({ message: `ScriptOps.importScripts: start`, state: state2 });
-    const response = [];
-    for (const existingId of Object.keys(importData.script)) {
-      try {
-        const scriptData = importData.script[existingId];
-        const isDefault = !options.includeDefault && scriptData.default;
-        const shouldNotImportScript = !options.deps && (scriptId && scriptId !== scriptData._id || !scriptId && scriptName && scriptName !== scriptData.name);
-        if (isDefault || shouldNotImportScript) continue;
+  debugMessage({ message: `ScriptOps.importScripts: start`, state: state2 });
+  const response = [];
+  for (const existingId of Object.keys(importData.script)) {
+    try {
+      const scriptData = importData.script[existingId];
+      const isDefault = !options.includeDefault && scriptData.default;
+      const shouldNotImportScript = !options.deps && (scriptId && scriptId !== scriptData._id || !scriptId && scriptName && scriptName !== scriptData.name);
+      if (isDefault || shouldNotImportScript) continue;
+      debugMessage({
+        message: `ScriptOps.importScripts: Importing script ${scriptData.name} (${existingId})`,
+        state: state2
+      });
+      let newId = existingId;
+      if (options.reUuid) {
+        newId = v4_default();
         debugMessage({
-          message: `ScriptOps.importScripts: Importing script ${scriptData.name} (${existingId})`,
+          message: `ScriptOps.importScripts: Re-uuid-ing script ${scriptData.name} ${existingId} => ${newId}...`,
           state: state2
         });
-        let newId = existingId;
-        if (options.reUuid) {
-          newId = v4_default();
-          debugMessage({
-            message: `ScriptOps.importScripts: Re-uuid-ing script ${scriptData.name} ${existingId} => ${newId}...`,
-            state: state2
-          });
-          scriptData._id = newId;
-        }
-        if (validate3) {
-          if (!isScriptValid({ scriptData, state: state2 })) {
-            errors.push(
-              new FrodoError(
-                `Error importing script '${scriptData.name}': Script is not valid`
-              )
-            );
-          }
+        scriptData._id = newId;
+      }
+      if (validate3) {
+        if (!isScriptValid({ scriptData, state: state2 })) {
+          throw new FrodoError(`Script is invalid`);
         }
-        const result = await updateScript({
-          scriptId: newId,
-          scriptData,
-          state: state2
-        });
-        response.push(result);
-      } catch (error2) {
-        errors.push(error2);
+      }
+      const result = await updateScript({
+        scriptId: newId,
+        scriptData,
+        state: state2
+      });
+      if (resultCallback) {
+        resultCallback(void 0, result);
+      }
+      response.push(result);
+    } catch (e) {
+      if (resultCallback) {
+        resultCallback(e, void 0);
+      } else {
+        throw new FrodoError(
+          `Error importing script '${importData.script[existingId].name}'`,
+          e
+        );
       }
     }
-    if (errors.length > 0) {
-      throw new FrodoError(`Error importing scripts`, errors);
-    }
-    debugMessage({ message: `ScriptOps.importScripts: end`, state: state2 });
-    return response;
-  } catch (error2) {
-    if (errors.length > 0) {
-      throw error2;
-    }
-    throw new FrodoError(`Error importing scripts`, error2);
   }
+  debugMessage({ message: `ScriptOps.importScripts: end`, state: state2 });
+  return response;
 }
 async function prepareScriptExport({
   scriptData,
@@ -129498,7 +129487,7 @@ async function updateOAuth2Client({
     debugMessage({ message: `OAuth2ClientOps.putOAuth2Client: end`, state: state2 });
     return response;
   } catch (error2) {
-    if (_optionalChain([error2, 'access', _106 => _106.response, 'optionalAccess', _107 => _107.status]) === 400 && _optionalChain([error2, 'access', _108 => _108.response, 'optionalAccess', _109 => _109.data, 'optionalAccess', _110 => _110.message]) === "Invalid attribute specified.") {
+    if (_optionalChain([error2, 'access', _104 => _104.response, 'optionalAccess', _105 => _105.status]) === 400 && _optionalChain([error2, 'access', _106 => _106.response, 'optionalAccess', _107 => _107.data, 'optionalAccess', _108 => _108.message]) === "Invalid attribute specified.") {
       try {
         const { validAttributes } = error2.response.data.detail;
         validAttributes.push("_id");
@@ -130230,7 +130219,7 @@ async function updateOAuth2TrustedJwtIssuer({
     });
     return response;
   } catch (error2) {
-    if (_optionalChain([error2, 'access', _111 => _111.response, 'optionalAccess', _112 => _112.status]) === 400 && _optionalChain([error2, 'access', _113 => _113.response, 'optionalAccess', _114 => _114.data, 'optionalAccess', _115 => _115.message]) === "Invalid attribute specified.") {
+    if (_optionalChain([error2, 'access', _109 => _109.response, 'optionalAccess', _110 => _110.status]) === 400 && _optionalChain([error2, 'access', _111 => _111.response, 'optionalAccess', _112 => _112.data, 'optionalAccess', _113 => _113.message]) === "Invalid attribute specified.") {
       try {
         const { validAttributes } = error2.response.data.detail;
         validAttributes.push("_id");
@@ -130620,8 +130609,12 @@ var OrganizationOps_default = (state2) => {
 };
 function getRealmManagedOrganization({ state: state2 }) {
   let realmManagedOrg = "organization";
-  if (state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY) {
+  if (state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY || state2.getUseRealmPrefixOnManagedObjects() === true) {
     realmManagedOrg = `${state2.getRealm()}_organization`;
+    debugMessage({
+      message: `DeploymentType === cloud or UseRealmPrefixOnManagedObjects is true, returning '${realmManagedOrg}'`,
+      state: state2
+    });
   }
   return realmManagedOrg;
 }
@@ -133509,7 +133502,7 @@ async function readAgents({
           (t) => t !== "SoapSTSAgent" || state2.getDeploymentType() === Constants_default.CLASSIC_DEPLOYMENT_TYPE_KEY
         ).map(
           (agentType) => getAgentsByType({ agentType, state: state2 }).catch((err) => {
-            if (err.httpStatus !== 501 && _optionalChain([err, 'access', _116 => _116.response, 'optionalAccess', _117 => _117.status]) !== 501) {
+            if (err.httpStatus !== 501 && _optionalChain([err, 'access', _114 => _114.response, 'optionalAccess', _115 => _115.status]) !== 501) {
               throw err;
             } else {
               return { result: [] };
@@ -134187,7 +134180,7 @@ async function importAgents({
           })
         );
       } catch (error2) {
-        if (error2.httpStatus !== 501 && _optionalChain([error2, 'access', _118 => _118.response, 'optionalAccess', _119 => _119.status]) !== 501) {
+        if (error2.httpStatus !== 501 && _optionalChain([error2, 'access', _116 => _116.response, 'optionalAccess', _117 => _117.status]) !== 501) {
           errors.push(
             new FrodoError(
               `Error importing agent ${agentId} of type ${agentType}`,
@@ -134239,7 +134232,7 @@ async function importAgentGroups({
           })
         );
       } catch (error2) {
-        if (error2.httpStatus !== 501 && _optionalChain([error2, 'access', _120 => _120.response, 'optionalAccess', _121 => _121.status]) !== 501) {
+        if (error2.httpStatus !== 501 && _optionalChain([error2, 'access', _118 => _118.response, 'optionalAccess', _119 => _119.status]) !== 501) {
           errors.push(
             new FrodoError(
               `Error importing agent group ${agentGroupId} of type ${agentType}`,
@@ -134401,7 +134394,7 @@ async function importAgent({
 }) {
   try {
     debugMessage({ message: `AgentOps.importAgent: start`, state: state2 });
-    const agentType = _optionalChain([importData, 'access', _122 => _122.agent, 'access', _123 => _123[agentId], 'optionalAccess', _124 => _124._type, 'access', _125 => _125._id]);
+    const agentType = _optionalChain([importData, 'access', _120 => _120.agent, 'access', _121 => _121[agentId], 'optionalAccess', _122 => _122._type, 'access', _123 => _123._id]);
     if (agentType === "SoapSTSAgent" && state2.getDeploymentType() !== Constants_default.CLASSIC_DEPLOYMENT_TYPE_KEY) {
       throw new FrodoError(
         `Can't import Soap STS agents for '${state2.getDeploymentType()}' deployment type.`
@@ -134427,7 +134420,7 @@ async function importAgentGroup({
 }) {
   try {
     debugMessage({ message: `AgentOps.importAgentGroup: start`, state: state2 });
-    const agentType = _optionalChain([importData, 'access', _126 => _126.agentGroup, 'access', _127 => _127[agentGroupId], 'optionalAccess', _128 => _128._type, 'access', _129 => _129._id]);
+    const agentType = _optionalChain([importData, 'access', _124 => _124.agentGroup, 'access', _125 => _125[agentGroupId], 'optionalAccess', _126 => _126._type, 'access', _127 => _127._id]);
     if (agentType === "SoapSTSAgent" && state2.getDeploymentType() !== Constants_default.CLASSIC_DEPLOYMENT_TYPE_KEY) {
       throw new FrodoError(
         `Can't import Soap STS agent groups for '${state2.getDeploymentType()}' deployment type.`
@@ -134455,7 +134448,7 @@ async function importIdentityGatewayAgent({
       message: `AgentOps.importIdentityGatewayAgent: start`,
       state: state2
     });
-    const agentType = _optionalChain([importData, 'access', _130 => _130.agent, 'access', _131 => _131[agentId], 'optionalAccess', _132 => _132._type, 'access', _133 => _133._id]);
+    const agentType = _optionalChain([importData, 'access', _128 => _128.agent, 'access', _129 => _129[agentId], 'optionalAccess', _130 => _130._type, 'access', _131 => _131._id]);
     if (agentType !== "IdentityGatewayAgent")
       throw new FrodoError(
         `Wrong agent type! Expected 'IdentityGatewayAgent' but got '${agentType}'.`
@@ -134486,7 +134479,7 @@ async function importJavaAgent({
 }) {
   try {
     debugMessage({ message: `AgentOps.importJavaAgent: start`, state: state2 });
-    const agentType = _optionalChain([importData, 'access', _134 => _134.agent, 'access', _135 => _135[agentId], 'optionalAccess', _136 => _136._type, 'access', _137 => _137._id]);
+    const agentType = _optionalChain([importData, 'access', _132 => _132.agent, 'access', _133 => _133[agentId], 'optionalAccess', _134 => _134._type, 'access', _135 => _135._id]);
     if (agentType !== "J2EEAgent")
       throw new FrodoError(
         `Wrong agent type! Expected 'J2EEAgent' but got '${agentType}'.`
@@ -134511,7 +134504,7 @@ async function importWebAgent({
 }) {
   try {
     debugMessage({ message: `AgentOps.importWebAgent: start`, state: state2 });
-    const agentType = _optionalChain([importData, 'access', _138 => _138.agent, 'access', _139 => _139[agentId], 'optionalAccess', _140 => _140._type, 'access', _141 => _141._id]);
+    const agentType = _optionalChain([importData, 'access', _136 => _136.agent, 'access', _137 => _137[agentId], 'optionalAccess', _138 => _138._type, 'access', _139 => _139._id]);
     if (agentType !== "WebAgent")
       throw new FrodoError(
         `Wrong agent type! Expected 'WebAgent' but got '${agentType}'.`
@@ -134969,17 +134962,17 @@ async function getConfigEntity2({
     state2.setRealm(currentRealm);
     return data2;
   } catch (error2) {
-    printError({
-      error: error2,
-      message: `Error getting config entity from resource path '${urlString}'`,
-      state: state2
-    });
+    throw new FrodoError(
+      `Error getting config entity from resource path '${urlString}'`,
+      error2
+    );
   }
 }
 async function getConfigEntities2({
   includeReadOnly = false,
   onlyRealm = false,
   onlyGlobal = false,
+  resultCallback = void 0,
   state: state2
 }) {
   const realms2 = await getRealmsForExport({ state: state2 });
@@ -134994,22 +134987,19 @@ async function getConfigEntities2({
     }
     const deploymentAllowed = entityInfo.deployments && entityInfo.deployments.includes(state2.getDeploymentType());
     if ((onlyGlobal || !onlyRealm) && entityInfo.global && (entityInfo.global.deployments && entityInfo.global.deployments.includes(state2.getDeploymentType()) || entityInfo.global.deployments == void 0 && deploymentAllowed)) {
-      try {
-        entities.global[key] = await getConfigEntity2({
+      entities.global[key] = await getResult(
+        resultCallback,
+        `Error getting '${key}' from resource path '${entityInfo.global.path}'`,
+        getConfigEntity2,
+        {
           state: state2,
           path: entityInfo.global.path,
           version: entityInfo.global.version,
           protocol: entityInfo.global.protocol,
           queryFilter: entityInfo.global.queryFilter ? entityInfo.global.queryFilter : entityInfo.queryFilter,
           action: entityInfo.global.action ? entityInfo.global.action : entityInfo.action
-        });
-      } catch (e) {
-        printMessage({
-          message: `Error getting '${key}' from resource path '${entityInfo.global.path}': ${e.message}`,
-          type: "error",
-          state: state2
-        });
-      }
+        }
+      );
     }
     if ((!onlyGlobal || onlyRealm) && entityInfo.realm && (entityInfo.realm.deployments && entityInfo.realm.deployments.includes(state2.getDeploymentType()) || entityInfo.realm.deployments == void 0 && deploymentAllowed)) {
       const activeRealm = state2.getRealm();
@@ -135017,8 +135007,11 @@ async function getConfigEntities2({
         if (onlyRealm && (activeRealm.startsWith("/") ? activeRealm : "/" + activeRealm) !== stateRealms[i2]) {
           continue;
         }
-        try {
-          entities.realm[realms2[i2]][key] = await getConfigEntity2({
+        entities.realm[realms2[i2]][key] = await getResult(
+          resultCallback,
+          `Error getting '${key}' from resource path '${entityInfo.realm.path}'`,
+          getConfigEntity2,
+          {
             state: state2,
             path: entityInfo.realm.path,
             version: entityInfo.realm.version,
@@ -135026,14 +135019,8 @@ async function getConfigEntities2({
             realm: stateRealms[i2],
             queryFilter: entityInfo.realm.queryFilter ? entityInfo.realm.queryFilter : entityInfo.queryFilter,
             action: entityInfo.realm.action ? entityInfo.realm.action : entityInfo.action
-          });
-        } catch (e) {
-          printMessage({
-            message: `Error getting '${key}' from resource path '${entityInfo.realm.path}': ${e.message}`,
-            type: "error",
-            state: state2
-          });
-        }
+          }
+        );
       }
     }
   }
@@ -135070,15 +135057,15 @@ async function putConfigEntity2({
     state2.setRealm(currentRealm);
     return data2;
   } catch (error2) {
-    printError({
-      error: error2,
-      message: `Error putting config entity at resource path '${urlString}'`,
-      state: state2
-    });
+    throw new FrodoError(
+      `Error putting config entity at resource path '${urlString}'`,
+      error2
+    );
   }
 }
 async function putConfigEntities({
   config,
+  resultCallback = void 0,
   state: state2
 }) {
   const realms2 = config.realm ? Object.keys(config.realm) : [];
@@ -135093,26 +135080,23 @@ async function putConfigEntities({
     }
     const deploymentAllowed = entityInfo.deployments && entityInfo.deployments.includes(state2.getDeploymentType());
     if (entityInfo.global && (entityInfo.global.deployments && entityInfo.global.deployments.includes(state2.getDeploymentType()) || entityInfo.global.deployments == void 0 && deploymentAllowed) && config.global && config.global[key]) {
-      try {
-        for (const [id7, entityData] of Object.entries(config.global[key])) {
-          if (!entities.global[key]) {
-            entities.global[key] = {};
-          }
-          entities.global[key][id7] = await putConfigEntity2({
+      for (const [id7, entityData] of Object.entries(config.global[key])) {
+        if (!entities.global[key]) {
+          entities.global[key] = {};
+        }
+        entities.global[key][id7] = await getResult(
+          resultCallback,
+          `Error putting entity '${id7}' of type '${key}' to global resource path '${entityInfo.global.path}'`,
+          putConfigEntity2,
+          {
             state: state2,
             entityData,
             path: entityInfo.global.path + (entityInfo.global.importWithId ? `/${id7}` : ""),
             version: entityInfo.global.version,
             protocol: entityInfo.global.protocol,
             ifMatch: entityInfo.global.ifMatch
-          });
-        }
-      } catch (e) {
-        printMessage({
-          message: `Error putting '${key}' from resource path '${entityInfo.global.path}': ${e.message}`,
-          type: "error",
-          state: state2
-        });
+          }
+        );
       }
     }
     if (entityInfo.realm && (entityInfo.realm.deployments && entityInfo.realm.deployments.includes(state2.getDeploymentType()) || entityInfo.realm.deployments == void 0 && deploymentAllowed)) {
@@ -135120,14 +135104,17 @@ async function putConfigEntities({
         if (!config.realm[realms2[i2]][key]) {
           continue;
         }
-        try {
-          for (const [id7, entityData] of Object.entries(
-            config.realm[realms2[i2]][key]
-          )) {
-            if (!entities.realm[realms2[i2]][key]) {
-              entities.realm[realms2[i2]][key] = {};
-            }
-            entities.realm[realms2[i2]][key][id7] = await putConfigEntity2({
+        for (const [id7, entityData] of Object.entries(
+          config.realm[realms2[i2]][key]
+        )) {
+          if (!entities.realm[realms2[i2]][key]) {
+            entities.realm[realms2[i2]][key] = {};
+          }
+          entities.realm[realms2[i2]][key][id7] = await getResult(
+            resultCallback,
+            `Error putting entity '${id7}' of type '${key}' to realm resource path '${entityInfo.realm.path}'`,
+            putConfigEntity2,
+            {
               state: state2,
               entityData,
               path: entityInfo.realm.path + (entityInfo.realm.importWithId ? `/${id7}` : ""),
@@ -135135,14 +135122,8 @@ async function putConfigEntities({
               protocol: entityInfo.realm.protocol,
               ifMatch: entityInfo.realm.ifMatch,
               realm: stateRealms[i2]
-            });
-          }
-        } catch (e) {
-          printMessage({
-            message: `Error putting '${key}' from resource path '${entityInfo.realm.path}': ${e.message}`,
-            type: "error",
-            state: state2
-          });
+            }
+          );
         }
       }
     }
@@ -135154,16 +135135,17 @@ var AmConfigOps_default = (state2) => {
     async createConfigEntityExportTemplate(realms2) {
       return createConfigEntityExportTemplate2({ realms: realms2, state: state2 });
     },
-    async exportAmConfigEntities(includeReadOnly = false, onlyRealm = false, onlyGlobal = false) {
+    async exportAmConfigEntities(includeReadOnly = false, onlyRealm = false, onlyGlobal = false, resultCallback = void 0) {
       return exportAmConfigEntities({
         includeReadOnly,
         onlyRealm,
         onlyGlobal,
+        resultCallback,
         state: state2
       });
     },
-    async importAmConfigEntities(importData) {
-      return importAmConfigEntities({ importData, state: state2 });
+    async importAmConfigEntities(importData, resultCallback = void 0) {
+      return importAmConfigEntities({ importData, resultCallback, state: state2 });
     }
   };
 };
@@ -135184,88 +135166,79 @@ async function exportAmConfigEntities({
   includeReadOnly = false,
   onlyRealm = false,
   onlyGlobal = false,
+  resultCallback = void 0,
   state: state2
 }) {
-  let indicatorId;
-  try {
-    debugMessage({
-      message: `AmConfigOps.exportAmConfigEntities: start`,
-      state: state2
-    });
-    const entities = await getConfigEntities2({
-      includeReadOnly,
-      onlyRealm,
-      onlyGlobal,
-      state: state2
-    });
-    const exportData = await createConfigEntityExportTemplate2({
-      state: state2,
-      realms: Object.keys(entities.realm)
-    });
-    const totalEntities = Object.keys(entities.global).length + Object.values(entities.realm).reduce(
-      (total, realmEntities) => total + Object.keys(realmEntities).length,
-      0
-    );
-    indicatorId = createProgressIndicator({
-      total: totalEntities,
-      message: "Exporting am config entities...",
-      state: state2
-    });
-    exportData.global = processConfigEntitiesForExport({
+  debugMessage({
+    message: `AmConfigOps.exportAmConfigEntities: start`,
+    state: state2
+  });
+  const entities = await getConfigEntities2({
+    includeReadOnly,
+    onlyRealm,
+    onlyGlobal,
+    resultCallback: getErrorCallback(resultCallback),
+    state: state2
+  });
+  const exportData = await createConfigEntityExportTemplate2({
+    state: state2,
+    realms: Object.keys(entities.realm)
+  });
+  const totalEntities = Object.keys(entities.global).length + Object.values(entities.realm).reduce(
+    (total, realmEntities) => total + Object.keys(realmEntities).length,
+    0
+  );
+  const indicatorId = createProgressIndicator({
+    total: totalEntities,
+    message: "Exporting am config entities...",
+    state: state2
+  });
+  exportData.global = processConfigEntitiesForExport({
+    state: state2,
+    indicatorId,
+    entities: entities.global,
+    resultCallback
+  });
+  Object.entries(entities.realm).forEach(
+    ([key, value]) => exportData.realm[key] = processConfigEntitiesForExport({
       state: state2,
       indicatorId,
-      entities: entities.global
-    });
-    Object.entries(entities.realm).forEach(
-      ([key, value]) => exportData.realm[key] = processConfigEntitiesForExport({
-        state: state2,
-        indicatorId,
-        entities: value
-      })
-    );
-    stopProgressIndicator({
-      id: indicatorId,
-      message: `Exported ${totalEntities} am config entities.`,
-      state: state2
-    });
-    debugMessage({ message: `AmConfigOps.exportAmConfigEntities: end`, state: state2 });
-    return exportData;
-  } catch (error2) {
-    stopProgressIndicator({
-      id: indicatorId,
-      message: `Error exporting am config entities.`,
-      status: "fail",
-      state: state2
-    });
-    throw new FrodoError(`Error exporting am config entities`, error2);
-  }
+      entities: value,
+      resultCallback
+    })
+  );
+  stopProgressIndicator({
+    id: indicatorId,
+    message: `Exported ${totalEntities} am config entities.`,
+    state: state2
+  });
+  return exportData;
 }
 async function importAmConfigEntities({
   importData,
+  resultCallback = void 0,
   state: state2
 }) {
   debugMessage({
     message: `ServiceOps.importAmConfigEntities: start`,
     state: state2
   });
-  try {
-    const result = await putConfigEntities({
-      config: importData,
-      state: state2
-    });
-    debugMessage({ message: `AmConfigOps.importAmConfigEntities: end`, state: state2 });
-    if (Object.keys(result.global).length === 0 && !Object.values(result.realm).find((r) => Object.keys(r).length > 0)) {
-      return null;
-    }
-    return result;
-  } catch (error2) {
-    throw new FrodoError(`Error importing am config entities`, error2);
+  const result = await putConfigEntities({
+    config: importData,
+    resultCallback,
+    state: state2
+  });
+  debugMessage({ message: `AmConfigOps.importAmConfigEntities: end`, state: state2 });
+  if (Object.keys(result.global).length === 0 && !Object.values(result.realm).find((r) => Object.keys(r).length > 0)) {
+    return null;
   }
+  return result;
 }
 function processConfigEntitiesForExport({
   state: state2,
   entities,
-  indicatorId
+  indicatorId,
+  resultCallback
 }) {
   const exportedEntities = {};
   const entries = Object.entries(entities);
@@ -135275,25 +135248,30 @@ function processConfigEntitiesForExport({
       message: `Exporting ${key}`,
       state: state2
     });
-    const exportedValue = {};
     if (!value) {
       continue;
     }
     if (!value.result) {
       if (value._id) {
-        exportedValue[value._id] = value;
-        exportedEntities[key] = exportedValue;
+        exportedEntities[key] = {
+          [value._id]: value
+        };
       } else if (value._type && value._type._id) {
-        exportedValue[value._type._id] = value;
-        exportedEntities[key] = exportedValue;
+        exportedEntities[key] = {
+          [value._type._id]: value
+        };
       } else {
         exportedEntities[key] = value;
       }
-      continue;
+    } else {
+      const { result } = value;
+      const exportedValue = {};
+      result.forEach((o) => exportedValue[o._id] = o);
+      exportedEntities[key] = exportedValue;
+    }
+    if (resultCallback) {
+      resultCallback(void 0, exportedEntities[key]);
     }
-    const { result } = value;
-    result.forEach((o) => exportedValue[o._id] = o);
-    exportedEntities[key] = exportedValue;
   }
   return exportedEntities;
 }
@@ -136354,7 +136332,7 @@ async function createCircleOfTrust2({
     const response = await createCircleOfTrust({ cotData, state: state2 });
     return response;
   } catch (createError) {
-    if (_optionalChain([createError, 'access', _142 => _142.response, 'optionalAccess', _143 => _143.data, 'optionalAccess', _144 => _144.code]) === 500 && _optionalChain([createError, 'access', _145 => _145.response, 'optionalAccess', _146 => _146.data, 'optionalAccess', _147 => _147.message]) === "Unable to update entity provider's circle of trust") {
+    if (_optionalChain([createError, 'access', _140 => _140.response, 'optionalAccess', _141 => _141.data, 'optionalAccess', _142 => _142.code]) === 500 && _optionalChain([createError, 'access', _143 => _143.response, 'optionalAccess', _144 => _144.data, 'optionalAccess', _145 => _145.message]) === "Unable to update entity provider's circle of trust") {
       try {
         const response = await updateCircleOfTrust({ cotId, cotData, state: state2 });
         return response;
@@ -136381,7 +136359,7 @@ async function updateCircleOfTrust2({
     const response = await updateCircleOfTrust({ cotId, cotData, state: state2 });
     return response || cotData;
   } catch (error2) {
-    if (_optionalChain([error2, 'access', _148 => _148.response, 'optionalAccess', _149 => _149.data, 'optionalAccess', _150 => _150.code]) === 500 && (_optionalChain([error2, 'access', _151 => _151.response, 'optionalAccess', _152 => _152.data, 'optionalAccess', _153 => _153.message]) === "Unable to update entity provider's circle of trust" || _optionalChain([error2, 'access', _154 => _154.response, 'optionalAccess', _155 => _155.data, 'optionalAccess', _156 => _156.message]) === "An error occurred while updating the COT memberships")) {
+    if (_optionalChain([error2, 'access', _146 => _146.response, 'optionalAccess', _147 => _147.data, 'optionalAccess', _148 => _148.code]) === 500 && (_optionalChain([error2, 'access', _149 => _149.response, 'optionalAccess', _150 => _150.data, 'optionalAccess', _151 => _151.message]) === "Unable to update entity provider's circle of trust" || _optionalChain([error2, 'access', _152 => _152.response, 'optionalAccess', _153 => _153.data, 'optionalAccess', _154 => _154.message]) === "An error occurred while updating the COT memberships")) {
       try {
         const response = await updateCircleOfTrust({ cotId, cotData, state: state2 });
         return response || cotData;
@@ -136777,7 +136755,7 @@ ${providers.map((it) => it.split("|")[0]).join("\n")}.`,
         }
       } catch (error2) {
         debugMessage({
-          message: `Error ${_optionalChain([error2, 'access', _157 => _157.response, 'optionalAccess', _158 => _158.status])} creating/updating circle of trust: ${_optionalChain([error2, 'access', _159 => _159.response, 'optionalAccess', _160 => _160.data, 'optionalAccess', _161 => _161.message])}`,
+          message: `Error ${_optionalChain([error2, 'access', _155 => _155.response, 'optionalAccess', _156 => _156.status])} creating/updating circle of trust: ${_optionalChain([error2, 'access', _157 => _157.response, 'optionalAccess', _158 => _158.data, 'optionalAccess', _159 => _159.message])}`,
           state: state2
         });
         errors.push(error2);
@@ -137285,11 +137263,15 @@ function createApplicationExportTemplate({
   };
 }
 function getRealmManagedApplication({ state: state2 }) {
-  let realmManagedOrg = "application";
-  if (state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY) {
-    realmManagedOrg = `${getCurrentRealmName(state2)}_application`;
+  let realmManagedApp = "application";
+  if (state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY || state2.getUseRealmPrefixOnManagedObjects() === true) {
+    realmManagedApp = `${getCurrentRealmName(state2)}_application`;
+    debugMessage({
+      message: `DeploymentType === cloud or UseRealmPrefixOnManagedObjects is true, returning '${realmManagedApp}'`,
+      state: state2
+    });
   }
-  return realmManagedOrg;
+  return realmManagedApp;
 }
 async function createApplication({
   applicationId,
@@ -138186,7 +138168,7 @@ async function readFeatures({
     const { result } = await getFeatures({ state: state2 });
     state2.setFeatures(JSON.parse(JSON.stringify(result)));
   } catch (error2) {
-    debugMessage({ message: _optionalChain([error2, 'access', _162 => _162.response, 'optionalAccess', _163 => _163.data]), state: state2 });
+    debugMessage({ message: _optionalChain([error2, 'access', _160 => _160.response, 'optionalAccess', _161 => _161.data]), state: state2 });
     state2.setFeatures([]);
   }
   return state2.getFeatures();
@@ -139782,7 +139764,7 @@ async function determineDeploymentType(state2) {
           state: state2
         });
       } catch (e) {
-        if (_optionalChain([e, 'access', _164 => _164.response, 'optionalAccess', _165 => _165.status]) === 302 && _optionalChain([e, 'access', _166 => _166.response, 'access', _167 => _167.headers, 'optionalAccess', _168 => _168.location, 'optionalAccess', _169 => _169.indexOf, 'call', _170 => _170("code=")]) > -1) {
+        if (_optionalChain([e, 'access', _162 => _162.response, 'optionalAccess', _163 => _163.status]) === 302 && _optionalChain([e, 'access', _164 => _164.response, 'access', _165 => _165.headers, 'optionalAccess', _166 => _166.location, 'optionalAccess', _167 => _167.indexOf, 'call', _168 => _168("code=")]) > -1) {
           verboseMessage({
             message: `ForgeRock Identity Cloud`["brightCyan"] + ` detected.`,
             state: state2
@@ -139798,7 +139780,7 @@ async function determineDeploymentType(state2) {
               state: state2
             });
           } catch (ex) {
-            if (_optionalChain([ex, 'access', _171 => _171.response, 'optionalAccess', _172 => _172.status]) === 302 && _optionalChain([ex, 'access', _173 => _173.response, 'access', _174 => _174.headers, 'optionalAccess', _175 => _175.location, 'optionalAccess', _176 => _176.indexOf, 'call', _177 => _177("code=")]) > -1) {
+            if (_optionalChain([ex, 'access', _169 => _169.response, 'optionalAccess', _170 => _170.status]) === 302 && _optionalChain([ex, 'access', _171 => _171.response, 'access', _172 => _172.headers, 'optionalAccess', _173 => _173.location, 'optionalAccess', _174 => _174.indexOf, 'call', _175 => _175("code=")]) > -1) {
               adminClientId = state2.getAdminClientId() || forgeopsClientId;
               verboseMessage({
                 message: `ForgeOps deployment`["brightCyan"] + ` detected.`,
@@ -139998,7 +139980,7 @@ async function getAuthCode(redirectUri, codeChallenge, codeChallengeMethod, stat
         throw error2;
       }
     }
-    const redirectLocationURL = _optionalChain([response, 'access', _178 => _178.headers, 'optionalAccess', _179 => _179.location]);
+    const redirectLocationURL = _optionalChain([response, 'access', _176 => _176.headers, 'optionalAccess', _177 => _177.location]);
     const queryObject = _url2.default.parse(redirectLocationURL, true).query;
     if ("code" in queryObject) {
       debugMessage({
@@ -140148,7 +140130,7 @@ async function getFreshSaBearerToken({
     });
   } catch (error2) {
     const err = error2;
-    if (err.isHttpError && err.httpErrorText === "invalid_scope" && _optionalChain([err, 'access', _180 => _180.httpDescription, 'optionalAccess', _181 => _181.startsWith, 'call', _182 => _182("Unsupported scope for service account: ")])) {
+    if (err.isHttpError && err.httpErrorText === "invalid_scope" && _optionalChain([err, 'access', _178 => _178.httpDescription, 'optionalAccess', _179 => _179.startsWith, 'call', _180 => _180("Unsupported scope for service account: ")])) {
       const invalidScopes = err.httpDescription.substring(39).split(",");
       const finalScopes = scope.split(" ").filter((el) => {
         return !invalidScopes.includes(el);
@@ -140265,9 +140247,9 @@ function scheduleAutoRefresh(forceLoginAsUser, autoRefresh, state2) {
     clearTimeout(timer);
   }
   if (autoRefresh) {
-    const expires = state2.getDeploymentType() === Constants_default.CLASSIC_DEPLOYMENT_TYPE_KEY ? _optionalChain([state2, 'access', _183 => _183.getUserSessionTokenMeta, 'call', _184 => _184(), 'optionalAccess', _185 => _185.expires]) : state2.getUseBearerTokenForAmApis() ? _optionalChain([state2, 'access', _186 => _186.getBearerTokenMeta, 'call', _187 => _187(), 'optionalAccess', _188 => _188.expires]) : Math.min(
-      _optionalChain([state2, 'access', _189 => _189.getBearerTokenMeta, 'call', _190 => _190(), 'optionalAccess', _191 => _191.expires]),
-      _optionalChain([state2, 'access', _192 => _192.getUserSessionTokenMeta, 'call', _193 => _193(), 'optionalAccess', _194 => _194.expires])
+    const expires = state2.getDeploymentType() === Constants_default.CLASSIC_DEPLOYMENT_TYPE_KEY ? _optionalChain([state2, 'access', _181 => _181.getUserSessionTokenMeta, 'call', _182 => _182(), 'optionalAccess', _183 => _183.expires]) : state2.getUseBearerTokenForAmApis() ? _optionalChain([state2, 'access', _184 => _184.getBearerTokenMeta, 'call', _185 => _185(), 'optionalAccess', _186 => _186.expires]) : Math.min(
+      _optionalChain([state2, 'access', _187 => _187.getBearerTokenMeta, 'call', _188 => _188(), 'optionalAccess', _189 => _189.expires]),
+      _optionalChain([state2, 'access', _190 => _190.getUserSessionTokenMeta, 'call', _191 => _191(), 'optionalAccess', _192 => _192.expires])
     );
     let timeout4 = expires - Date.now() - 1e3 * 25;
     if (timeout4 < 1e3 * 30) {
@@ -140379,10 +140361,10 @@ async function getTokens({
       throw new FrodoError(`Incomplete or no credentials`);
     }
     if (state2.getCookieValue() || state2.getUseBearerTokenForAmApis() && state2.getBearerToken()) {
-      if (_optionalChain([state2, 'access', _195 => _195.getBearerTokenMeta, 'call', _196 => _196(), 'optionalAccess', _197 => _197.from_cache])) {
+      if (_optionalChain([state2, 'access', _193 => _193.getBearerTokenMeta, 'call', _194 => _194(), 'optionalAccess', _195 => _195.from_cache])) {
         verboseMessage({ message: `Using cached bearer token.`, state: state2 });
       }
-      if (!state2.getUseBearerTokenForAmApis() && _optionalChain([state2, 'access', _198 => _198.getUserSessionTokenMeta, 'call', _199 => _199(), 'optionalAccess', _200 => _200.from_cache])) {
+      if (!state2.getUseBearerTokenForAmApis() && _optionalChain([state2, 'access', _196 => _196.getUserSessionTokenMeta, 'call', _197 => _197(), 'optionalAccess', _198 => _198.from_cache])) {
         verboseMessage({ message: `Using cached session token.`, state: state2 });
       }
       scheduleAutoRefresh(forceLoginAsUser, autoRefresh, state2);
@@ -140788,7 +140770,7 @@ async function readSecretStoreMappings({
     });
     return result;
   } catch (error2) {
-    if (error2.httpStatus === 404 || _optionalChain([error2, 'access', _201 => _201.response, 'optionalAccess', _202 => _202.status]) === 404) {
+    if (error2.httpStatus === 404 || _optionalChain([error2, 'access', _199 => _199.response, 'optionalAccess', _200 => _200.status]) === 404) {
     } else {
       throw new FrodoError(
         `Error reading secret store mappings for the secret store '${secretStoreId}'`,
@@ -141402,7 +141384,7 @@ async function importServers({
             state: state2
           });
         } catch (e) {
-          if (_optionalChain([e, 'access', _203 => _203.response, 'optionalAccess', _204 => _204.status]) !== 400 || _optionalChain([e, 'access', _205 => _205.response, 'optionalAccess', _206 => _206.data, 'optionalAccess', _207 => _207.message]) !== "Update not supported") {
+          if (_optionalChain([e, 'access', _201 => _201.response, 'optionalAccess', _202 => _202.status]) !== 400 || _optionalChain([e, 'access', _203 => _203.response, 'optionalAccess', _204 => _204.data, 'optionalAccess', _205 => _205.message]) !== "Update not supported") {
             throw new FrodoError(
               `Error creating server with id '${server._id}' and URL '${server.url}'`,
               e
@@ -141884,7 +141866,7 @@ async function updateAdminFederationProvider({
     });
     return response;
   } catch (importError) {
-    if (_optionalChain([importError, 'access', _208 => _208.response, 'optionalAccess', _209 => _209.status]) === 400 && _optionalChain([importError, 'access', _210 => _210.response, 'optionalAccess', _211 => _211.data, 'optionalAccess', _212 => _212.message]) === "Invalid attribute specified.") {
+    if (_optionalChain([importError, 'access', _206 => _206.response, 'optionalAccess', _207 => _207.status]) === 400 && _optionalChain([importError, 'access', _208 => _208.response, 'optionalAccess', _209 => _209.data, 'optionalAccess', _210 => _210.message]) === "Invalid attribute specified.") {
       const { validAttributes } = importError.response.data.detail;
       validAttributes.push("_id", "_type");
       for (const attribute of Object.keys(providerData)) {
@@ -145735,7 +145717,7 @@ async function checkForUpdates({
       state: state2
     });
   }
-  const updateCount = _optionalChain([updates, 'access', _213 => _213.secrets, 'optionalAccess', _214 => _214.length]) + _optionalChain([updates, 'access', _215 => _215.variables, 'optionalAccess', _216 => _216.length]) || 0;
+  const updateCount = _optionalChain([updates, 'access', _211 => _211.secrets, 'optionalAccess', _212 => _212.length]) + _optionalChain([updates, 'access', _213 => _213.variables, 'optionalAccess', _214 => _214.length]) || 0;
   if (updateCount > 0) {
     stopProgressIndicator({
       id: indicatorId,
@@ -145828,7 +145810,7 @@ async function applyUpdates({
   } catch (error2) {
     stopProgressIndicator({
       id: indicatorId,
-      message: `Error: ${_optionalChain([error2, 'access', _217 => _217.response, 'optionalAccess', _218 => _218.data, 'optionalAccess', _219 => _219.code]) || error2} - ${_optionalChain([error2, 'access', _220 => _220.response, 'optionalAccess', _221 => _221.data, 'optionalAccess', _222 => _222.message])}`,
+      message: `Error: ${_optionalChain([error2, 'access', _215 => _215.response, 'optionalAccess', _216 => _216.data, 'optionalAccess', _217 => _217.code]) || error2} - ${_optionalChain([error2, 'access', _218 => _218.response, 'optionalAccess', _219 => _219.data, 'optionalAccess', _220 => _220.message])}`,
       status: "fail",
       state: state2
     });
@@ -146091,7 +146073,7 @@ async function updateSocialIdentityProvider({
     });
     return response;
   } catch (error2) {
-    if (_optionalChain([error2, 'access', _223 => _223.response, 'optionalAccess', _224 => _224.status]) === 400 && _optionalChain([error2, 'access', _225 => _225.response, 'optionalAccess', _226 => _226.data, 'optionalAccess', _227 => _227.message]) === "Invalid attribute specified.") {
+    if (_optionalChain([error2, 'access', _221 => _221.response, 'optionalAccess', _222 => _222.status]) === 400 && _optionalChain([error2, 'access', _223 => _223.response, 'optionalAccess', _224 => _224.data, 'optionalAccess', _225 => _225.message]) === "Invalid attribute specified.") {
       const { validAttributes } = error2.response.data.detail;
       validAttributes.push("_id", "_type");
       for (const attribute of Object.keys(providerData)) {
@@ -148575,8 +148557,8 @@ var JourneyOps_default = (state2) => {
       useStringArrays: true,
       deps: true,
       coords: true
-    }) {
-      return exportJourneys({ options, state: state2 });
+    }, resultCallback = void 0) {
+      return exportJourneys({ options, resultCallback, state: state2 });
     },
     async readJourneys() {
       return readJourneys({ state: state2 });
@@ -148602,8 +148584,13 @@ var JourneyOps_default = (state2) => {
         index2
       );
     },
-    async importJourneys(treesMap, options) {
-      return importJourneys({ importData: treesMap, options, state: state2 });
+    async importJourneys(treesMap, options, resultCallback = void 0) {
+      return importJourneys({
+        importData: treesMap,
+        options,
+        resultCallback,
+        state: state2
+      });
     },
     getNodeRef(nodeObj, singleTreeExport) {
       return getNodeRef(nodeObj, singleTreeExport);
@@ -148636,8 +148623,8 @@ var JourneyOps_default = (state2) => {
     async deleteJourney(journeyId, options) {
       return deleteJourney({ journeyId, options, state: state2 });
     },
-    async deleteJourneys(options) {
-      return deleteJourneys({ options, state: state2 });
+    async deleteJourneys(options, resultCallback = void 0) {
+      return deleteJourneys({ options, resultCallback, state: state2 });
     },
     async enableJourney(journeyId) {
       return enableJourney({ journeyId, state: state2 });
@@ -148797,7 +148784,7 @@ async function getSaml2NodeDependencies(nodeObject, allProviders, allCirclesOfTr
         }
         saml2EntityPromises.push(providerResponse);
       } catch (error2) {
-        error2.message = `Error reading saml2 dependencies: ${_optionalChain([error2, 'access', _228 => _228.response, 'optionalAccess', _229 => _229.data, 'optionalAccess', _230 => _230.message]) || error2.message}`;
+        error2.message = `Error reading saml2 dependencies: ${_optionalChain([error2, 'access', _226 => _226.response, 'optionalAccess', _227 => _227.data, 'optionalAccess', _228 => _228.message]) || error2.message}`;
         errors.push(error2);
       }
     }
@@ -148826,7 +148813,7 @@ async function getSaml2NodeDependencies(nodeObject, allProviders, allCirclesOfTr
       circlesOfTrust
     };
   } catch (error2) {
-    error2.message = `Error reading saml2 dependencies: ${_optionalChain([error2, 'access', _231 => _231.response, 'optionalAccess', _232 => _232.data, 'optionalAccess', _233 => _233.message]) || error2.message}`;
+    error2.message = `Error reading saml2 dependencies: ${_optionalChain([error2, 'access', _229 => _229.response, 'optionalAccess', _230 => _230.data, 'optionalAccess', _231 => _231.message]) || error2.message}`;
     errors.push(error2);
   }
   if (errors.length) {
@@ -148937,7 +148924,7 @@ async function exportJourney({
             });
             emailTemplatePromises.push(emailTemplate);
           } catch (error2) {
-            error2.message = `Error reading email template ${nodeObject.emailTemplateName}: ${_optionalChain([error2, 'access', _234 => _234.response, 'optionalAccess', _235 => _235.data, 'optionalAccess', _236 => _236.message]) || error2.message}`;
+            error2.message = `Error reading email template ${nodeObject.emailTemplateName}: ${_optionalChain([error2, 'access', _232 => _232.response, 'optionalAccess', _233 => _233.data, 'optionalAccess', _234 => _234.message]) || error2.message}`;
             errors.push(error2);
           }
         }
@@ -149239,7 +149226,7 @@ async function exportJourney({
         for (const themeObject of themePromiseResults) {
           if (themeObject && // has the theme been specified by id or name in a page node?
           (themes.includes(themeObject._id) || themes.includes(themeObject.name) || // has this journey been linked to a theme?
-          _optionalChain([themeObject, 'access', _237 => _237.linkedTrees, 'optionalAccess', _238 => _238.includes, 'call', _239 => _239(treeObject._id)]))) {
+          _optionalChain([themeObject, 'access', _235 => _235.linkedTrees, 'optionalAccess', _236 => _236.includes, 'call', _237 => _237(treeObject._id)]))) {
             if (verbose)
               printMessage({
                 message: `
@@ -149281,57 +149268,41 @@ async function exportJourneys({
     deps: true,
     coords: true
   },
+  resultCallback = void 0,
   state: state2
 }) {
-  const errors = [];
-  let indicatorId;
-  try {
-    const trees = await readJourneys({ state: state2 });
-    const multiTreeExport = createMultiTreeExportTemplate({ state: state2 });
-    indicatorId = createProgressIndicator({
-      total: trees.length,
-      message: "Exporting journeys...",
-      state: state2
-    });
-    for (const tree of trees) {
-      try {
-        updateProgressIndicator({
-          id: indicatorId,
-          message: `Exporting journey ${tree._id}`,
-          state: state2
-        });
-        const exportData = await exportJourney({
-          journeyId: tree._id,
-          options,
-          state: state2
-        });
-        delete exportData.meta;
-        multiTreeExport.trees[tree._id] = exportData;
-      } catch (error2) {
-        errors.push(error2);
-      }
-    }
-    if (errors.length > 0) {
-      throw new FrodoError(`Error exporting journeys`, errors);
-    }
-    stopProgressIndicator({
-      id: indicatorId,
-      message: `Exported ${trees.length} journeys.`,
-      state: state2
-    });
-    return multiTreeExport;
-  } catch (error2) {
-    stopProgressIndicator({
+  const multiTreeExport = createMultiTreeExportTemplate({ state: state2 });
+  const trees = await readJourneys({ state: state2 });
+  const indicatorId = createProgressIndicator({
+    total: trees.length,
+    message: "Exporting journeys...",
+    state: state2
+  });
+  for (const tree of trees) {
+    updateProgressIndicator({
       id: indicatorId,
-      message: `Error exporting journeys.`,
-      status: "fail",
+      message: `Exporting journey ${tree._id}`,
       state: state2
     });
-    if (errors.length > 0) {
-      throw error2;
-    }
-    throw new FrodoError(`Error exporting journeys`, error2);
+    const exportData = await getResult(
+      resultCallback,
+      `Error exporting the journey ${tree._id}`,
+      exportJourney,
+      {
+        journeyId: tree._id,
+        options,
+        state: state2
+      }
+    );
+    delete exportData.meta;
+    multiTreeExport.trees[tree._id] = exportData;
   }
+  stopProgressIndicator({
+    id: indicatorId,
+    message: `Exported ${trees.length} journeys.`,
+    state: state2
+  });
+  return multiTreeExport;
 }
 async function readJourneys({
   state: state2
@@ -149522,7 +149493,7 @@ async function importJourney({
             state: state2
           });
         } catch (error2) {
-          if (_optionalChain([error2, 'access', _240 => _240.response, 'optionalAccess', _241 => _241.status]) === 500 && _optionalChain([error2, 'access', _242 => _242.response, 'optionalAccess', _243 => _243.data, 'optionalAccess', _244 => _244.message]) === "Unable to update SMS config: Data validation failed for the attribute, Redirect after form post URL") {
+          if (_optionalChain([error2, 'access', _238 => _238.response, 'optionalAccess', _239 => _239.status]) === 500 && _optionalChain([error2, 'access', _240 => _240.response, 'optionalAccess', _241 => _241.data, 'optionalAccess', _242 => _242.message]) === "Unable to update SMS config: Data validation failed for the attribute, Redirect after form post URL") {
             providerData["redirectAfterFormPostURI"] = "";
             try {
               await putProviderByTypeAndId2({
@@ -149633,7 +149604,7 @@ async function importJourney({
         try {
           await createCircleOfTrust({ cotData, state: state2 });
         } catch (error2) {
-          if (_optionalChain([error2, 'access', _245 => _245.response, 'optionalAccess', _246 => _246.status]) === 409 || _optionalChain([error2, 'access', _247 => _247.response, 'optionalAccess', _248 => _248.status]) === 500) {
+          if (_optionalChain([error2, 'access', _243 => _243.response, 'optionalAccess', _244 => _244.status]) === 409 || _optionalChain([error2, 'access', _245 => _245.response, 'optionalAccess', _246 => _246.status]) === 500) {
             try {
               await updateCircleOfTrust({ cotId, cotData, state: state2 });
             } catch (updateCotErr) {
@@ -149720,12 +149691,12 @@ async function importJourney({
             state: state2
           });
         } catch (nodeImportError) {
-          if (_optionalChain([nodeImportError, 'access', _249 => _249.response, 'optionalAccess', _250 => _250.status]) === 400 && _optionalChain([nodeImportError, 'access', _251 => _251.response, 'optionalAccess', _252 => _252.data, 'optionalAccess', _253 => _253.message]) === "Data validation failed for the attribute, Script") {
+          if (_optionalChain([nodeImportError, 'access', _247 => _247.response, 'optionalAccess', _248 => _248.status]) === 400 && _optionalChain([nodeImportError, 'access', _249 => _249.response, 'optionalAccess', _250 => _250.data, 'optionalAccess', _251 => _251.message]) === "Data validation failed for the attribute, Script") {
             throw new FrodoError(
               `Missing script ${innerNodeData["script"]} referenced by inner node ${innerNodeId}${innerNodeId === newUuid ? "" : ` [${newUuid}]`} (${innerNodeData["_type"]["_id"]}) in journey ${treeId}`,
               nodeImportError
             );
-          } else if (_optionalChain([nodeImportError, 'access', _254 => _254.response, 'optionalAccess', _255 => _255.status]) === 400 && _optionalChain([nodeImportError, 'access', _256 => _256.response, 'optionalAccess', _257 => _257.data, 'optionalAccess', _258 => _258.message]) === "Invalid attribute specified.") {
+          } else if (_optionalChain([nodeImportError, 'access', _252 => _252.response, 'optionalAccess', _253 => _253.status]) === 400 && _optionalChain([nodeImportError, 'access', _254 => _254.response, 'optionalAccess', _255 => _255.data, 'optionalAccess', _256 => _256.message]) === "Invalid attribute specified.") {
             const { validAttributes } = nodeImportError.response.data.detail;
             validAttributes.push("_id");
             for (const attribute of Object.keys(innerNodeData)) {
@@ -149754,7 +149725,7 @@ async function importJourney({
                 nodeImportError2
               );
             }
-          } else if (_optionalChain([nodeImportError, 'access', _259 => _259.response, 'optionalAccess', _260 => _260.status]) === 404) {
+          } else if (_optionalChain([nodeImportError, 'access', _257 => _257.response, 'optionalAccess', _258 => _258.status]) === 404) {
             throw new FrodoError(
               `Unable to import node ${innerNodeId}${innerNodeId === newUuid ? "" : ` [${newUuid}]`} in journey ${treeId} because its type ${innerNodeData._type._id} doesn't exist in deployment`,
               nodeImportError
@@ -149829,12 +149800,12 @@ async function importJourney({
         try {
           await putNode({ nodeId: newUuid, nodeType, nodeData, state: state2 });
         } catch (nodeImportError) {
-          if (_optionalChain([nodeImportError, 'access', _261 => _261.response, 'optionalAccess', _262 => _262.status]) === 400 && _optionalChain([nodeImportError, 'access', _263 => _263.response, 'optionalAccess', _264 => _264.data, 'optionalAccess', _265 => _265.message]) === "Data validation failed for the attribute, Script") {
+          if (_optionalChain([nodeImportError, 'access', _259 => _259.response, 'optionalAccess', _260 => _260.status]) === 400 && _optionalChain([nodeImportError, 'access', _261 => _261.response, 'optionalAccess', _262 => _262.data, 'optionalAccess', _263 => _263.message]) === "Data validation failed for the attribute, Script") {
             throw new FrodoError(
               `Missing script ${nodeData["script"]} referenced by node ${nodeId}${nodeId === newUuid ? "" : ` [${newUuid}]`} (${nodeData["_type"]["_id"]}) in journey ${treeId}`,
               nodeImportError
             );
-          } else if (_optionalChain([nodeImportError, 'access', _266 => _266.response, 'optionalAccess', _267 => _267.status]) === 400 && _optionalChain([nodeImportError, 'access', _268 => _268.response, 'optionalAccess', _269 => _269.data, 'optionalAccess', _270 => _270.message]) === "Invalid attribute specified.") {
+          } else if (_optionalChain([nodeImportError, 'access', _264 => _264.response, 'optionalAccess', _265 => _265.status]) === 400 && _optionalChain([nodeImportError, 'access', _266 => _266.response, 'optionalAccess', _267 => _267.data, 'optionalAccess', _268 => _268.message]) === "Invalid attribute specified.") {
             const { validAttributes } = nodeImportError.response.data.detail;
             validAttributes.push("_id");
             for (const attribute of Object.keys(nodeData)) {
@@ -149858,7 +149829,7 @@ async function importJourney({
                 nodeImportError2
               );
             }
-          } else if (_optionalChain([nodeImportError, 'access', _271 => _271.response, 'optionalAccess', _272 => _272.status]) === 404) {
+          } else if (_optionalChain([nodeImportError, 'access', _269 => _269.response, 'optionalAccess', _270 => _270.status]) === 404) {
             throw new FrodoError(
               `Unable to import node ${nodeId}${nodeId === newUuid ? "" : ` [${newUuid}]`} in journey ${treeId} because its type ${nodeData._type._id} doesn't exist in deployment`,
               nodeImportError
@@ -149922,7 +149893,7 @@ async function importJourney({
           state: state2
         });
     } catch (importError) {
-      if (_optionalChain([importError, 'access', _273 => _273.response, 'optionalAccess', _274 => _274.status]) === 400 && _optionalChain([importError, 'access', _275 => _275.response, 'optionalAccess', _276 => _276.data, 'optionalAccess', _277 => _277.message]) === "Invalid attribute specified.") {
+      if (_optionalChain([importError, 'access', _271 => _271.response, 'optionalAccess', _272 => _272.status]) === 400 && _optionalChain([importError, 'access', _273 => _273.response, 'optionalAccess', _274 => _274.data, 'optionalAccess', _275 => _275.message]) === "Invalid attribute specified.") {
         const { validAttributes } = importError.response.data.detail;
         validAttributes.push("_id");
         for (const attribute of Object.keys(importData.tree)) {
@@ -150020,10 +149991,10 @@ async function resolveDependencies(installedJorneys, journeyMap, unresolvedJourn
 async function importJourneys({
   importData,
   options,
+  resultCallback = void 0,
   state: state2
 }) {
   const response = [];
-  const errors = [];
   const installedJourneys = (await readJourneys({ state: state2 })).map((x) => x._id);
   const unresolvedJourneys = {};
   const resolvedJourneys = [];
@@ -150067,26 +150038,18 @@ async function importJourneys({
     state: state2
   });
   for (const tree of resolvedJourneys) {
-    try {
-      response.push(
-        await importJourney({
-          importData: importData.trees[tree],
-          options,
-          state: state2
-        })
-      );
-      updateProgressIndicator({ id: indicatorId, message: `${tree}`, state: state2 });
-    } catch (error2) {
-      errors.push(error2);
-    }
-  }
-  if (errors.length > 0) {
-    stopProgressIndicator({
-      id: indicatorId,
-      message: "Error importing journeys",
-      state: state2
-    });
-    throw new FrodoError(`Error importing journeys`, errors);
+    const result = await getResult(
+      resultCallback,
+      `Error importing the journey ${tree._id}`,
+      importJourney,
+      {
+        importData: importData.trees[tree],
+        options,
+        state: state2
+      }
+    );
+    response.push(result);
+    updateProgressIndicator({ id: indicatorId, message: `${tree}`, state: state2 });
   }
   stopProgressIndicator({
     id: indicatorId,
@@ -150134,7 +150097,7 @@ var fileByIdTreeExportResolver = async function(treeId, state2) {
       message: `fileByIdTreeExportResolver: resolved '${treeId}' to ${file}`,
       state: state2
     });
-    if (_optionalChain([jsonData, 'access', _278 => _278.tree, 'optionalAccess', _279 => _279._id]) === treeId) {
+    if (_optionalChain([jsonData, 'access', _276 => _276.tree, 'optionalAccess', _277 => _277._id]) === treeId) {
       treeExport = jsonData;
     } else if (jsonData.trees && jsonData.trees[treeId]) {
       treeExport = jsonData.trees[treeId];
@@ -150153,7 +150116,7 @@ function createFileParamTreeExportResolver(file, state2) {
     let treeExport = createSingleTreeExportTemplate({ state: state2 });
     try {
       const jsonData = JSON.parse(fs35.default.readFileSync(file, "utf8"));
-      if (_optionalChain([jsonData, 'access', _280 => _280.tree, 'optionalAccess', _281 => _281._id]) === treeId) {
+      if (_optionalChain([jsonData, 'access', _278 => _278.tree, 'optionalAccess', _279 => _279._id]) === treeId) {
         treeExport = jsonData;
       } else if (jsonData.trees && jsonData.trees[treeId]) {
         treeExport = jsonData.trees[treeId];
@@ -150378,7 +150341,7 @@ async function deleteJourney({
                   });
                 return response2;
               }).catch((error2) => {
-                if (_optionalChain([error2, 'optionalAccess', _282 => _282.response, 'optionalAccess', _283 => _283.data, 'optionalAccess', _284 => _284.code]) === 500 && error2.response.data.message === "Unable to read SMS config: Node did not exist") {
+                if (_optionalChain([error2, 'optionalAccess', _280 => _280.response, 'optionalAccess', _281 => _281.data, 'optionalAccess', _282 => _282.code]) === 500 && error2.response.data.message === "Unable to read SMS config: Node did not exist") {
                   status.nodes[containerNode._id] = { status: "success" };
                   if (verbose)
                     printMessage({
@@ -150477,19 +150440,19 @@ async function deleteJourney({
 }
 async function deleteJourneys({
   options,
+  resultCallback = void 0,
   state: state2
 }) {
-  let indicatorId;
-  try {
-    const { verbose } = options;
-    const status = {};
-    const trees = (await getTrees({ state: state2 })).result;
-    indicatorId = createProgressIndicator({
-      total: trees.length,
-      message: "Deleting journeys...",
-      state: state2
-    });
-    for (const tree of trees) {
+  const { verbose } = options;
+  const status = {};
+  const trees = (await getTrees({ state: state2 })).result;
+  const indicatorId = createProgressIndicator({
+    total: trees.length,
+    message: "Deleting journeys...",
+    state: state2
+  });
+  for (const tree of trees) {
+    try {
       if (verbose) printMessage({ message: "", state: state2 });
       options["progress"] = false;
       status[tree._id] = await deleteJourney({
@@ -150506,34 +150469,35 @@ async function deleteJourneys({
         await new Promise((r) => {
           setTimeout(r, 100);
         });
-    }
-    let journeyCount = 0;
-    let journeyErrorCount = 0;
-    let nodeCount = 0;
-    let nodeErrorCount = 0;
-    for (const journey of Object.keys(status)) {
-      journeyCount += 1;
-      if (status[journey].status === "error") journeyErrorCount += 1;
-      for (const node2 of Object.keys(status[journey].nodes)) {
-        nodeCount += 1;
-        if (status[journey].nodes[node2].status === "error") nodeErrorCount += 1;
+    } catch (e) {
+      if (resultCallback) {
+        resultCallback(e, void 0);
+      } else {
+        throw new FrodoError(`Error deleting the journey ${tree._id}`, e);
       }
     }
-    stopProgressIndicator({
-      id: indicatorId,
-      message: `Deleted ${journeyCount - journeyErrorCount}/${journeyCount} journeys and ${nodeCount - nodeErrorCount}/${nodeCount} nodes.`,
-      state: state2
-    });
-    return status;
-  } catch (error2) {
-    stopProgressIndicator({
-      id: indicatorId,
-      message: `Error deleting journeys`,
-      status: "fail",
-      state: state2
-    });
-    throw new FrodoError(`Error deleting journeys`, error2);
   }
+  let journeyCount = 0;
+  let journeyErrorCount = 0;
+  let nodeCount = 0;
+  let nodeErrorCount = 0;
+  for (const journey of Object.keys(status)) {
+    journeyCount += 1;
+    if (status[journey].status === "error") journeyErrorCount += 1;
+    for (const node2 of Object.keys(status[journey].nodes)) {
+      nodeCount += 1;
+      if (status[journey].nodes[node2].status === "error") nodeErrorCount += 1;
+    }
+    if (resultCallback) {
+      resultCallback(void 0, status[journey]);
+    }
+  }
+  stopProgressIndicator({
+    id: indicatorId,
+    message: `Deleted ${journeyCount - journeyErrorCount}/${journeyCount} journeys and ${nodeCount - nodeErrorCount}/${nodeCount} nodes.`,
+    state: state2
+  });
+  return status;
 }
 async function enableJourney({
   journeyId,
@@ -151370,7 +151334,7 @@ async function importPolicySet({
           response = await createPolicySet({ policySetData, state: state2 });
           imported.push(id7);
         } catch (error2) {
-          if (_optionalChain([error2, 'access', _285 => _285.response, 'optionalAccess', _286 => _286.status]) === 409) {
+          if (_optionalChain([error2, 'access', _283 => _283.response, 'optionalAccess', _284 => _284.status]) === 409) {
             response = await updatePolicySet({ policySetData, state: state2 });
             imported.push(id7);
           } else throw error2;
@@ -151429,7 +151393,7 @@ async function importFirstPolicySet({
         response = await createPolicySet({ policySetData, state: state2 });
         imported.push(id7);
       } catch (error2) {
-        if (_optionalChain([error2, 'access', _287 => _287.response, 'optionalAccess', _288 => _288.status]) === 409) {
+        if (_optionalChain([error2, 'access', _285 => _285.response, 'optionalAccess', _286 => _286.status]) === 409) {
           response = await updatePolicySet({ policySetData, state: state2 });
           imported.push(id7);
         } else throw error2;
@@ -151483,7 +151447,7 @@ async function importPolicySets({
       try {
         response.push(await createPolicySet({ policySetData, state: state2 }));
       } catch (error2) {
-        if (_optionalChain([error2, 'access', _289 => _289.response, 'optionalAccess', _290 => _290.status]) === 409) {
+        if (_optionalChain([error2, 'access', _287 => _287.response, 'optionalAccess', _288 => _288.status]) === 409) {
           response.push(await updatePolicySet({ policySetData, state: state2 }));
         } else throw error2;
       }
@@ -151701,7 +151665,7 @@ async function exportResourceType({
     debugMessage({ message: `ResourceTypeOps.exportResourceType: end`, state: state2 });
     return exportData;
   } catch (error2) {
-    if (_optionalChain([error2, 'access', _291 => _291.response, 'optionalAccess', _292 => _292.status]) === 404) {
+    if (_optionalChain([error2, 'access', _289 => _289.response, 'optionalAccess', _290 => _290.status]) === 404) {
       throw new FrodoError(
         `Resource type ${resourceTypeUuid} does not exist`,
         error2
@@ -151795,7 +151759,7 @@ async function importResourceType({
         try {
           response = await createResourceType({ resourceTypeData, state: state2 });
         } catch (createError) {
-          if (_optionalChain([createError, 'access', _293 => _293.response, 'optionalAccess', _294 => _294.status]) === 409)
+          if (_optionalChain([createError, 'access', _291 => _291.response, 'optionalAccess', _292 => _292.status]) === 409)
             response = await putResourceType({
               resourceTypeUuid: id7,
               resourceTypeData,
@@ -151838,7 +151802,7 @@ async function importResourceTypeByName({
         try {
           response = await createResourceType({ resourceTypeData, state: state2 });
         } catch (createError) {
-          if (_optionalChain([createError, 'access', _295 => _295.response, 'optionalAccess', _296 => _296.status]) === 409)
+          if (_optionalChain([createError, 'access', _293 => _293.response, 'optionalAccess', _294 => _294.status]) === 409)
             response = await putResourceType({
               resourceTypeUuid: id7,
               resourceTypeData,
@@ -151880,7 +151844,7 @@ async function importFirstResourceType({
       try {
         response = await createResourceType({ resourceTypeData, state: state2 });
       } catch (createError) {
-        if (_optionalChain([createError, 'access', _297 => _297.response, 'optionalAccess', _298 => _298.status]) === 409)
+        if (_optionalChain([createError, 'access', _295 => _295.response, 'optionalAccess', _296 => _296.status]) === 409)
           response = await putResourceType({
             resourceTypeUuid: id7,
             resourceTypeData,
@@ -151915,7 +151879,7 @@ async function importResourceTypes({
       try {
         response.push(await createResourceType({ resourceTypeData, state: state2 }));
       } catch (createError) {
-        if (_optionalChain([createError, 'access', _299 => _299.response, 'optionalAccess', _300 => _300.status]) === 409)
+        if (_optionalChain([createError, 'access', _297 => _297.response, 'optionalAccess', _298 => _298.status]) === 409)
           response.push(
             await putResourceType({
               resourceTypeUuid: id7,
@@ -152900,7 +152864,7 @@ async function exportScriptTypes({
           state: state2
         });
       } catch (e) {
-        if (e.httpStatus === 404 || _optionalChain([e, 'access', _301 => _301.response, 'optionalAccess', _302 => _302.status]) === 404) {
+        if (e.httpStatus === 404 || _optionalChain([e, 'access', _299 => _299.response, 'optionalAccess', _300 => _300.status]) === 404) {
         } else {
           printMessage({
             message: `Unable to get engine configuration for script type '${scriptType._id}': ${e.message}`,
@@ -153303,8 +153267,8 @@ async function getFullServices({
             nextDescendents
           };
         } catch (error2) {
-          if (!(_optionalChain([error2, 'access', _303 => _303.response, 'optionalAccess', _304 => _304.status]) === 403 && _optionalChain([error2, 'access', _305 => _305.response, 'optionalAccess', _306 => _306.data, 'optionalAccess', _307 => _307.message]) === "This operation is not available in PingOne Advanced Identity Cloud.")) {
-            const message = _optionalChain([error2, 'access', _308 => _308.response, 'optionalAccess', _309 => _309.data, 'optionalAccess', _310 => _310.message]);
+          if (!(_optionalChain([error2, 'access', _301 => _301.response, 'optionalAccess', _302 => _302.status]) === 403 && _optionalChain([error2, 'access', _303 => _303.response, 'optionalAccess', _304 => _304.data, 'optionalAccess', _305 => _305.message]) === "This operation is not available in PingOne Advanced Identity Cloud.")) {
+            const message = _optionalChain([error2, 'access', _306 => _306.response, 'optionalAccess', _307 => _307.data, 'optionalAccess', _308 => _308.message]);
             printMessage({
               message: `Unable to retrieve data for ${listItem._id} with error: ${message}`,
               type: "error",
@@ -153345,7 +153309,7 @@ async function putFullService({
         debugMessage({ message: `ServiceOps.putFullService: clean`, state: state2 });
         await deleteFullService({ serviceId, globalConfig, state: state2 });
       } catch (error2) {
-        if (!(_optionalChain([error2, 'access', _311 => _311.response, 'optionalAccess', _312 => _312.status]) === 404 && _optionalChain([error2, 'access', _313 => _313.response, 'optionalAccess', _314 => _314.data, 'optionalAccess', _315 => _315.message]) === "Not Found")) {
+        if (!(_optionalChain([error2, 'access', _309 => _309.response, 'optionalAccess', _310 => _310.status]) === 404 && _optionalChain([error2, 'access', _311 => _311.response, 'optionalAccess', _312 => _312.data, 'optionalAccess', _313 => _313.message]) === "Not Found")) {
           throw new FrodoError(
             `Error deleting service '${serviceId}' before import`,
             error2
@@ -153522,8 +153486,8 @@ async function deleteFullServices({
             state: state2
           });
         } catch (error2) {
-          if (!(_optionalChain([error2, 'access', _316 => _316.response, 'optionalAccess', _317 => _317.status]) === 403 && _optionalChain([error2, 'access', _318 => _318.response, 'optionalAccess', _319 => _319.data, 'optionalAccess', _320 => _320.message]) === "This operation is not available in PingOne Advanced Identity Cloud.")) {
-            const message = _optionalChain([error2, 'access', _321 => _321.response, 'optionalAccess', _322 => _322.data, 'optionalAccess', _323 => _323.message]);
+          if (!(_optionalChain([error2, 'access', _314 => _314.response, 'optionalAccess', _315 => _315.status]) === 403 && _optionalChain([error2, 'access', _316 => _316.response, 'optionalAccess', _317 => _317.data, 'optionalAccess', _318 => _318.message]) === "This operation is not available in PingOne Advanced Identity Cloud.")) {
+            const message = _optionalChain([error2, 'access', _319 => _319.response, 'optionalAccess', _320 => _320.data, 'optionalAccess', _321 => _321.message]);
             printMessage({
               message: `Delete service '${serviceListItem._id}': ${message}`,
               state: state2,
@@ -153704,8 +153668,8 @@ var ConfigOps_default = (state2) => {
       includeReadOnly: false,
       onlyRealm: false,
       onlyGlobal: false
-    }, collectErrors) {
-      return exportFullConfiguration({ options, collectErrors, state: state2 });
+    }, resultCallback = void 0) {
+      return exportFullConfiguration({ options, resultCallback, state: state2 });
     },
     async importFullConfiguration(importData, options = {
       reUuidJourneys: false,
@@ -153713,11 +153677,11 @@ var ConfigOps_default = (state2) => {
       cleanServices: false,
       includeDefault: false,
       includeActiveValues: true
-    }, collectErrors) {
+    }, resultCallback = void 0) {
       return importFullConfiguration({
         importData,
         options,
-        collectErrors,
+        resultCallback,
         state: state2
       });
     }
@@ -153735,15 +153699,9 @@ async function exportFullConfiguration({
     onlyRealm: false,
     onlyGlobal: false
   },
-  collectErrors,
+  resultCallback = void 0,
   state: state2
 }) {
-  let errors = [];
-  let throwErrors = true;
-  if (collectErrors && Array.isArray(collectErrors)) {
-    throwErrors = false;
-    errors = collectErrors;
-  }
   const {
     useStringArrays,
     noDecode,
@@ -153762,12 +153720,19 @@ async function exportFullConfiguration({
   const isCloudDeployment = state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY;
   const isForgeOpsDeployment = state2.getDeploymentType() === Constants_default.FORGEOPS_DEPLOYMENT_TYPE_KEY;
   const isPlatformDeployment = isCloudDeployment || isForgeOpsDeployment;
-  const config = await exportAmConfigEntities({
-    includeReadOnly,
-    onlyRealm,
-    onlyGlobal,
-    state: state2
-  });
+  const errorCallback = getErrorCallback(resultCallback);
+  const config = await exportWithErrorHandling(
+    exportAmConfigEntities,
+    {
+      includeReadOnly,
+      onlyRealm,
+      onlyGlobal,
+      errorCallback,
+      state: state2
+    },
+    "AM Config Entities",
+    resultCallback
+  );
   let globalConfig = {};
   if (!onlyRealm || onlyGlobal) {
     const mappings = await exportWithErrorHandling(
@@ -153781,13 +153746,15 @@ async function exportFullConfiguration({
         },
         state: state2
       },
-      errors,
+      "Mappings",
+      resultCallback,
       isPlatformDeployment
     );
     const serverExport = await exportWithErrorHandling(
       exportServers,
       { options: { includeDefault: true }, state: state2 },
-      errors,
+      "Servers",
+      resultCallback,
       isClassicDeployment
     );
     if (serverExport) {
@@ -153797,21 +153764,24 @@ async function exportFullConfiguration({
       agent: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportAgents,
         globalStateObj,
-        errors,
+        "Global Agents",
+        resultCallback,
         isClassicDeployment
-      )), 'optionalAccess', async _324 => _324.agent]),
+      )), 'optionalAccess', async _322 => _322.agent]),
       authentication: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportAuthenticationSettings,
         globalStateObj,
-        errors,
+        "Global Authentication Settings",
+        resultCallback,
         isClassicDeployment
-      )), 'optionalAccess', async _325 => _325.authentication]),
+      )), 'optionalAccess', async _323 => _323.authentication]),
       emailTemplate: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportEmailTemplates,
         stateObj,
-        errors,
+        "Email Templates",
+        resultCallback,
         isPlatformDeployment
-      )), 'optionalAccess', async _326 => _326.emailTemplate]),
+      )), 'optionalAccess', async _324 => _324.emailTemplate]),
       idm: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportConfigEntities,
         {
@@ -153819,60 +153789,74 @@ async function exportFullConfiguration({
             envReplaceParams: void 0,
             entitiesToExport: void 0
           },
+          resultCallback: errorCallback,
           state: state2
         },
-        errors,
+        "IDM Config Entities",
+        resultCallback,
         isPlatformDeployment
-      )), 'optionalAccess', async _327 => _327.idm]),
+      )), 'optionalAccess', async _325 => _325.idm]),
       internalRole: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportInternalRoles,
         stateObj,
-        errors,
+        "Internal Roles",
+        resultCallback,
         isPlatformDeployment
-      )), 'optionalAccess', async _328 => _328.internalRole]),
-      mapping: _optionalChain([mappings, 'optionalAccess', _329 => _329.mapping]),
+      )), 'optionalAccess', async _326 => _326.internalRole]),
+      mapping: _optionalChain([mappings, 'optionalAccess', _327 => _327.mapping]),
       realm: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportRealms,
         stateObj,
-        errors,
+        "Realms",
+        resultCallback,
         includeReadOnly || isClassicDeployment
-      )), 'optionalAccess', async _330 => _330.realm]),
+      )), 'optionalAccess', async _328 => _328.realm]),
       scripttype: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportScriptTypes,
         stateObj,
-        errors,
+        "Script Types",
+        resultCallback,
         includeReadOnly || isClassicDeployment
-      )), 'optionalAccess', async _331 => _331.scripttype]),
+      )), 'optionalAccess', async _329 => _329.scripttype]),
       secret: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportSecrets,
         { options: { includeActiveValues, target }, state: state2 },
-        errors,
+        "ESV Secrets",
+        resultCallback,
         isCloudDeployment
-      )), 'optionalAccess', async _332 => _332.secret]),
+      )), 'optionalAccess', async _330 => _330.secret]),
       secretstore: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportSecretStores,
         globalStateObj,
-        errors,
+        "Global Secret Stores",
+        resultCallback,
         isClassicDeployment
-      )), 'optionalAccess', async _333 => _333.secretstore]),
+      )), 'optionalAccess', async _331 => _331.secretstore]),
       server: serverExport,
-      service: await _asyncOptionalChain([(await exportWithErrorHandling(exportServices, globalStateObj, errors)), 'optionalAccess', async _334 => _334.service]),
+      service: await _asyncOptionalChain([(await exportWithErrorHandling(
+        exportServices,
+        globalStateObj,
+        "Services",
+        resultCallback
+      )), 'optionalAccess', async _332 => _332.service]),
       site: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportSites,
         stateObj,
-        errors,
+        "Sites",
+        resultCallback,
         isClassicDeployment
-      )), 'optionalAccess', async _335 => _335.site]),
-      sync: _optionalChain([mappings, 'optionalAccess', _336 => _336.sync]),
+      )), 'optionalAccess', async _333 => _333.site]),
+      sync: _optionalChain([mappings, 'optionalAccess', _334 => _334.sync]),
       variable: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportVariables,
         {
           noDecode,
           state: state2
         },
-        errors,
+        "ESV Variables",
+        resultCallback,
         isCloudDeployment
-      )), 'optionalAccess', async _337 => _337.variable]),
+      )), 'optionalAccess', async _335 => _335.variable]),
       ...config.global
     };
     if (globalConfig.idm) {
@@ -153893,73 +153877,98 @@ async function exportFullConfiguration({
       let saml = await _asyncOptionalChain([(await exportWithErrorHandling(
         exportSaml2Providers,
         stateObj,
-        errors
-      )), 'optionalAccess', async _338 => _338.saml]);
+        "SAML2 Providers",
+        resultCallback
+      )), 'optionalAccess', async _336 => _336.saml]);
       const cotExport = await exportWithErrorHandling(
         exportCirclesOfTrust,
         stateObj,
-        errors
+        "Circle of Trusts",
+        resultCallback
       );
       if (saml) {
-        saml.cot = _optionalChain([cotExport, 'optionalAccess', _339 => _339.saml, 'access', _340 => _340.cot]);
+        saml.cot = _optionalChain([cotExport, 'optionalAccess', _337 => _337.saml, 'access', _338 => _338.cot]);
       } else {
-        saml = _optionalChain([cotExport, 'optionalAccess', _341 => _341.saml]);
+        saml = _optionalChain([cotExport, 'optionalAccess', _339 => _339.saml]);
       }
       realmConfig[realm2] = {
-        agentGroup: await _asyncOptionalChain([(await exportWithErrorHandling(exportAgentGroups, stateObj, errors)), 'optionalAccess', async _342 => _342.agentGroup]),
-        agent: await _asyncOptionalChain([(await exportWithErrorHandling(exportAgents, realmStateObj, errors)), 'optionalAccess', async _343 => _343.agent]),
+        agentGroup: await _asyncOptionalChain([(await exportWithErrorHandling(
+          exportAgentGroups,
+          stateObj,
+          "Agent Groups",
+          resultCallback
+        )), 'optionalAccess', async _340 => _340.agentGroup]),
+        agent: await _asyncOptionalChain([(await exportWithErrorHandling(
+          exportAgents,
+          realmStateObj,
+          "Agents",
+          resultCallback
+        )), 'optionalAccess', async _341 => _341.agent]),
         application: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportOAuth2Clients,
           {
             options: { deps: false, useStringArrays },
             state: state2
           },
-          errors
-        )), 'optionalAccess', async _344 => _344.application]),
+          "OAuth2 Client Applications",
+          resultCallback
+        )), 'optionalAccess', async _342 => _342.application]),
         authentication: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportAuthenticationSettings,
           realmStateObj,
-          errors
-        )), 'optionalAccess', async _345 => _345.authentication]),
+          "Authentication Settings",
+          resultCallback
+        )), 'optionalAccess', async _343 => _343.authentication]),
         idp: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportSocialIdentityProviders,
           stateObj,
-          errors
-        )), 'optionalAccess', async _346 => _346.idp]),
+          "Social Identity Providers",
+          resultCallback
+        )), 'optionalAccess', async _344 => _344.idp]),
         trees: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportJourneys,
           {
             options: { deps: false, useStringArrays, coords },
+            resultCallback: errorCallback,
             state: state2
           },
-          errors
-        )), 'optionalAccess', async _347 => _347.trees]),
+          "Journeys",
+          resultCallback
+        )), 'optionalAccess', async _345 => _345.trees]),
         managedApplication: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportApplications,
           {
             options: { deps: false, useStringArrays },
             state: state2
           },
-          errors,
+          "Applications",
+          resultCallback,
           isPlatformDeployment
-        )), 'optionalAccess', async _348 => _348.managedApplication]),
+        )), 'optionalAccess', async _346 => _346.managedApplication]),
         policy: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportPolicies,
           {
             options: { deps: false, prereqs: false, useStringArrays },
             state: state2
           },
-          errors
-        )), 'optionalAccess', async _349 => _349.policy]),
+          "Policies",
+          resultCallback
+        )), 'optionalAccess', async _347 => _347.policy]),
         policyset: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportPolicySets,
           {
             options: { deps: false, prereqs: false, useStringArrays },
             state: state2
           },
-          errors
-        )), 'optionalAccess', async _350 => _350.policyset]),
-        resourcetype: await _asyncOptionalChain([(await exportWithErrorHandling(exportResourceTypes, stateObj, errors)), 'optionalAccess', async _351 => _351.resourcetype]),
+          "Policy Sets",
+          resultCallback
+        )), 'optionalAccess', async _348 => _348.policyset]),
+        resourcetype: await _asyncOptionalChain([(await exportWithErrorHandling(
+          exportResourceTypes,
+          stateObj,
+          "Resource Types",
+          resultCallback
+        )), 'optionalAccess', async _349 => _349.resourcetype]),
         saml,
         script: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportScripts,
@@ -153969,33 +153978,43 @@ async function exportFullConfiguration({
               includeDefault,
               useStringArrays
             },
+            resultCallback: errorCallback,
             state: state2
           },
-          errors
-        )), 'optionalAccess', async _352 => _352.script]),
+          "Scripts",
+          resultCallback
+        )), 'optionalAccess', async _350 => _350.script]),
         secretstore: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportSecretStores,
           realmStateObj,
-          errors,
+          "Secret Stores",
+          resultCallback,
           isClassicDeployment
-        )), 'optionalAccess', async _353 => _353.secretstore]),
-        service: await _asyncOptionalChain([(await exportWithErrorHandling(exportServices, realmStateObj, errors)), 'optionalAccess', async _354 => _354.service]),
+        )), 'optionalAccess', async _351 => _351.secretstore]),
+        service: await _asyncOptionalChain([(await exportWithErrorHandling(
+          exportServices,
+          realmStateObj,
+          "Services",
+          resultCallback
+        )), 'optionalAccess', async _352 => _352.service]),
         theme: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportThemes,
           {
             state: state2
           },
-          errors,
+          "Themes",
+          resultCallback,
           isPlatformDeployment
-        )), 'optionalAccess', async _355 => _355.theme]),
+        )), 'optionalAccess', async _353 => _353.theme]),
         trustedJwtIssuer: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportOAuth2TrustedJwtIssuers,
           {
             options: { deps: false, useStringArrays },
             state: state2
           },
-          errors
-        )), 'optionalAccess', async _356 => _356.trustedJwtIssuer]),
+          "Trusted JWT Issuers",
+          resultCallback
+        )), 'optionalAccess', async _354 => _354.trustedJwtIssuer]),
         ...config.realm[realm2]
       };
       if (realmConfig[realm2].service && realmConfig[realm2].service["SocialIdentityProviders"]) {
@@ -154004,14 +154023,12 @@ async function exportFullConfiguration({
     }
     state2.setRealm(activeRealm);
   }
-  if (throwErrors && errors.length > 0) {
-    throw new FrodoError(`Error exporting full config`, errors);
-  }
-  return {
+  const fullConfig = {
     meta: getMetadata(stateObj),
     global: globalConfig,
     realm: realmConfig
   };
+  return fullConfig;
 }
 async function importFullConfiguration({
   importData,
@@ -154023,16 +154040,10 @@ async function importFullConfiguration({
     includeActiveValues: true,
     source: ""
   },
-  collectErrors,
+  resultCallback = void 0,
   state: state2
 }) {
-  const response = [];
-  let errors = [];
-  let throwErrors = true;
-  if (collectErrors && Array.isArray(collectErrors)) {
-    throwErrors = false;
-    errors = collectErrors;
-  }
+  let response = [];
   const isClassicDeployment = state2.getDeploymentType() === Constants_default.CLASSIC_DEPLOYMENT_TYPE_KEY;
   const isCloudDeployment = state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY;
   const isForgeOpsDeployment = state2.getDeploymentType() === Constants_default.FORGEOPS_DEPLOYMENT_TYPE_KEY;
@@ -154045,6 +154056,7 @@ async function importFullConfiguration({
     includeActiveValues,
     source
   } = options;
+  const errorCallback = getErrorCallback(resultCallback);
   let indicatorId = createProgressIndicator({
     total: 14,
     message: `Importing everything for global...`,
@@ -154062,9 +154074,9 @@ async function importFullConfiguration({
         },
         state: state2
       },
-      errors,
       indicatorId,
       "Servers",
+      resultCallback,
       isClassicDeployment && !!importData.global.server
     )
   );
@@ -154077,9 +154089,9 @@ async function importFullConfiguration({
         importData: importData.global,
         state: state2
       },
-      errors,
       indicatorId,
       "Sites",
+      resultCallback,
       isClassicDeployment && !!importData.global.site
     )
   );
@@ -154092,9 +154104,9 @@ async function importFullConfiguration({
         importData: importData.global,
         state: state2
       },
-      errors,
       indicatorId,
       "Realms",
+      resultCallback,
       isClassicDeployment && !!importData.global.realm
     )
   );
@@ -154106,9 +154118,9 @@ async function importFullConfiguration({
         importData: importData.global,
         state: state2
       },
-      errors,
       indicatorId,
       "Script Types",
+      resultCallback,
       isClassicDeployment && !!importData.global.scripttype
     )
   );
@@ -154121,9 +154133,9 @@ async function importFullConfiguration({
         secretStoreId: "",
         state: state2
       },
-      errors,
       indicatorId,
       "Secret Stores",
+      resultCallback,
       isClassicDeployment && !!importData.global.secretstore
     )
   );
@@ -154138,9 +154150,9 @@ async function importFullConfiguration({
         },
         state: state2
       },
-      errors,
       indicatorId,
       "Secrets",
+      resultCallback,
       isCloudDeployment && !!importData.global.secret
     )
   );
@@ -154151,9 +154163,9 @@ async function importFullConfiguration({
         importData: importData.global,
         state: state2
       },
-      errors,
       indicatorId,
       "Variables",
+      resultCallback,
       isCloudDeployment && !!importData.global.variable
     )
   );
@@ -154167,11 +154179,12 @@ async function importFullConfiguration({
           entitiesToImport: void 0,
           validate: false
         },
+        resultCallback: errorCallback,
         state: state2
       },
-      errors,
       indicatorId,
       "IDM Config Entities",
+      resultCallback,
       isPlatformDeployment && !!importData.global.idm
     )
   );
@@ -154182,9 +154195,9 @@ async function importFullConfiguration({
         importData: importData.global,
         state: state2
       },
-      errors,
       indicatorId,
       "Email Templates",
+      resultCallback,
       isPlatformDeployment && !!importData.global.emailTemplate
     )
   );
@@ -154196,9 +154209,9 @@ async function importFullConfiguration({
         options: { deps: false },
         state: state2
       },
-      errors,
       indicatorId,
       "Mappings",
+      resultCallback,
       isPlatformDeployment
     )
   );
@@ -154210,9 +154223,9 @@ async function importFullConfiguration({
         options: { clean: cleanServices, global: true, realm: false },
         state: state2
       },
-      errors,
       indicatorId,
       "Services",
+      resultCallback,
       !!importData.global.service
     )
   );
@@ -154220,9 +154233,9 @@ async function importFullConfiguration({
     await importWithErrorHandling(
       importAgents,
       { importData: importData.global, globalConfig: true, state: state2 },
-      errors,
       indicatorId,
       "Agents",
+      resultCallback,
       isClassicDeployment && !!importData.global.agent
     )
   );
@@ -154234,9 +154247,9 @@ async function importFullConfiguration({
         globalConfig: true,
         state: state2
       },
-      errors,
       indicatorId,
       "Authentication Settings",
+      resultCallback,
       isClassicDeployment && !!importData.global.authentication
     )
   );
@@ -154247,9 +154260,9 @@ async function importFullConfiguration({
         importData: importData.global,
         state: state2
       },
-      errors,
       indicatorId,
       "Internal Roles",
+      resultCallback,
       isPlatformDeployment && !!importData.global.internalRole
     )
   );
@@ -154279,11 +154292,12 @@ async function importFullConfiguration({
             includeDefault
           },
           validate: false,
+          resultCallback: errorCallback,
           state: state2
         },
-        errors,
         indicatorId,
         "Scripts",
+        resultCallback,
         !!importData.realm[realm2].script
       )
     );
@@ -154294,9 +154308,9 @@ async function importFullConfiguration({
           importData: importData.realm[realm2],
           state: state2
         },
-        errors,
         indicatorId,
         "Themes",
+        resultCallback,
         isPlatformDeployment && !!importData.realm[realm2].theme
       )
     );
@@ -154309,9 +154323,9 @@ async function importFullConfiguration({
           secretStoreId: "",
           state: state2
         },
-        errors,
         indicatorId,
         "Secret Stores",
+        resultCallback,
         isClassicDeployment && !!importData.realm[realm2].secretstore
       )
     );
@@ -154319,9 +154333,9 @@ async function importFullConfiguration({
       await importWithErrorHandling(
         importAgentGroups,
         { importData: importData.realm[realm2], state: state2 },
-        errors,
         indicatorId,
         "Agent Groups",
+        resultCallback,
         !!importData.realm[realm2].agentGroup
       )
     );
@@ -154329,9 +154343,9 @@ async function importFullConfiguration({
       await importWithErrorHandling(
         importAgents,
         { importData: importData.realm[realm2], globalConfig: false, state: state2 },
-        errors,
         indicatorId,
         "Agents",
+        resultCallback,
         !!importData.realm[realm2].agent
       )
     );
@@ -154342,9 +154356,9 @@ async function importFullConfiguration({
           importData: importData.realm[realm2],
           state: state2
         },
-        errors,
         indicatorId,
         "Resource Types",
+        resultCallback,
         !!importData.realm[realm2].resourcetype
       )
     );
@@ -154355,9 +154369,9 @@ async function importFullConfiguration({
           importData: importData.realm[realm2],
           state: state2
         },
-        errors,
         indicatorId,
         "Circles of Trust",
+        resultCallback,
         !!importData.realm[realm2].saml && !!importData.realm[realm2].saml.cot
       )
     );
@@ -154369,9 +154383,9 @@ async function importFullConfiguration({
           options: { deps: false },
           state: state2
         },
-        errors,
         indicatorId,
         "Saml2 Providers",
+        resultCallback,
         !!importData.realm[realm2].saml
       )
     );
@@ -154383,9 +154397,9 @@ async function importFullConfiguration({
           options: { deps: false },
           state: state2
         },
-        errors,
         indicatorId,
         "Social Identity Providers",
+        resultCallback,
         !!importData.realm[realm2].idp
       )
     );
@@ -154397,9 +154411,9 @@ async function importFullConfiguration({
           options: { deps: false },
           state: state2
         },
-        errors,
         indicatorId,
         "OAuth2 Clients",
+        resultCallback,
         !!importData.realm[realm2].application
       )
     );
@@ -154410,9 +154424,9 @@ async function importFullConfiguration({
           importData: importData.realm[realm2],
           state: state2
         },
-        errors,
         indicatorId,
         "Trusted JWT Issuers",
+        resultCallback,
         !!importData.realm[realm2].trustedJwtIssuer
       )
     );
@@ -154424,9 +154438,9 @@ async function importFullConfiguration({
           options: { deps: false },
           state: state2
         },
-        errors,
         indicatorId,
         "Applications",
+        resultCallback,
         isPlatformDeployment && !!importData.realm[realm2].managedApplication
       )
     );
@@ -154438,9 +154452,9 @@ async function importFullConfiguration({
           options: { deps: false, prereqs: false },
           state: state2
         },
-        errors,
         indicatorId,
         "Policy Sets",
+        resultCallback,
         !!importData.realm[realm2].policyset
       )
     );
@@ -154452,9 +154466,9 @@ async function importFullConfiguration({
           options: { deps: false, prereqs: false },
           state: state2
         },
-        errors,
         indicatorId,
         "Policies",
+        resultCallback,
         !!importData.realm[realm2].policy
       )
     );
@@ -154464,11 +154478,12 @@ async function importFullConfiguration({
         {
           importData: importData.realm[realm2],
           options: { deps: false, reUuid: reUuidJourneys },
+          resultCallback: errorCallback,
           state: state2
         },
-        errors,
         indicatorId,
         "Journeys",
+        resultCallback,
         !!importData.realm[realm2].trees
       )
     );
@@ -154480,9 +154495,9 @@ async function importFullConfiguration({
           options: { clean: cleanServices, global: false, realm: true },
           state: state2
         },
-        errors,
         indicatorId,
         "Services",
+        resultCallback,
         !!importData.realm[realm2].service
       )
     );
@@ -154494,9 +154509,9 @@ async function importFullConfiguration({
           globalConfig: false,
           state: state2
         },
-        errors,
         indicatorId,
         "Authentication Settings",
+        resultCallback,
         !!importData.realm[realm2].authentication
       )
     );
@@ -154518,25 +154533,24 @@ async function importFullConfiguration({
       importAmConfigEntities,
       {
         importData,
+        resultCallback: errorCallback,
         state: state2
       },
-      errors,
       indicatorId,
-      "Other AM Config Entities"
+      "Other AM Config Entities",
+      resultCallback
     )
   );
+  response = response.filter(
+    (o) => o && (!Array.isArray(o) || o.length > 0) && (!o.server || Object.keys(o.server).length > 0)
+  );
   stopProgressIndicator({
     id: indicatorId,
     message: `Finished Importing all other AM config entities!`,
     status: "success",
     state: state2
   });
-  if (throwErrors && errors.length > 0) {
-    throw new FrodoError(`Error importing full config`, errors);
-  }
-  return response.filter(
-    (o) => o && (!Array.isArray(o) || o.length > 0) && (!o.server || Object.keys(o.server).length > 0)
-  );
+  return response;
 }
 var envInfoURLTemplate2 = "%s/environment/info";
 var apiVersion39 = "protocol=1.0,resource=1.0";
@@ -154872,7 +154886,7 @@ async function getUserConfig({
         current = current[part];
       }
     } catch (e) {
-      if (e.httpStatus === 404 || _optionalChain([e, 'access', _357 => _357.response, 'optionalAccess', _358 => _358.status]) === 404) {
+      if (e.httpStatus === 404 || _optionalChain([e, 'access', _355 => _355.response, 'optionalAccess', _356 => _356.status]) === 404) {
       } else {
         printMessage({
           message: `Error exporting config for user with id '${userId}' from url '${urlString}': ${e.message}`,
@@ -155531,7 +155545,7 @@ function v43(options, buf, offset) {
     return native_default3.randomUUID();
   }
   options = options || {};
-  const rnds = _nullishCoalesce(_nullishCoalesce(options.random, () => ( _optionalChain([options, 'access', _359 => _359.rng, 'optionalCall', _360 => _360()]))), () => ( rng3()));
+  const rnds = _nullishCoalesce(_nullishCoalesce(options.random, () => ( _optionalChain([options, 'access', _357 => _357.rng, 'optionalCall', _358 => _358()]))), () => ( rng3()));
   if (rnds.length < 16) {
     throw new Error("Random bytes length must be >= 16");
   }
@@ -156937,6 +156951,11 @@ _chunkHEKQUNOBcjs.init_cjs_shims.call(void 0, );
 function cloneDeep2(obj) {
   return JSON.parse(JSON.stringify(obj));
 }
+function errorHandler(error2) {
+  if (!error2) return;
+  printError2(error2);
+  process.exitCode = 1;
+}
 
 // src/ops/AdminOps.ts
 var {
@@ -157825,7 +157844,7 @@ In AM, create a trusted issuer in the ${state.getRealm()} realm with the followi
       ]);
       issuer.push([
         "Allowed Subjects              "["brightCyan"],
-        _optionalChain([artefacts, 'access', _361 => _361.issuer, 'access', _362 => _362.allowedSubjects, 'optionalAccess', _363 => _363.value, 'access', _364 => _364.length]) ? _optionalChain([artefacts, 'access', _365 => _365.issuer, 'access', _366 => _366.allowedSubjects, 'optionalAccess', _367 => _367.value, 'access', _368 => _368.join, 'call', _369 => _369(", ")]) : `Any ${state.getRealm()} realm user`
+        _optionalChain([artefacts, 'access', _359 => _359.issuer, 'access', _360 => _360.allowedSubjects, 'optionalAccess', _361 => _361.value, 'access', _362 => _362.length]) ? _optionalChain([artefacts, 'access', _363 => _363.issuer, 'access', _364 => _364.allowedSubjects, 'optionalAccess', _365 => _365.value, 'access', _366 => _366.join, 'call', _367 => _367(", ")]) : `Any ${state.getRealm()} realm user`
       ]);
       issuer.push([
         "JWKS (Public Key)"["brightCyan"],
@@ -157953,7 +157972,7 @@ async function executeRfc7523AuthZGrantFlow2(clientId, iss, jwk, sub, scope, jso
     stopProgressIndicator2(
       spinnerId,
       `Error executing rfc7523 authz grant flow: ${stringify3(
-        _optionalChain([error2, 'access', _370 => _370.response, 'optionalAccess', _371 => _371.data]) || error2.message
+        _optionalChain([error2, 'access', _368 => _368.response, 'optionalAccess', _369 => _369.data]) || error2.message
       )}`,
       "fail"
     );
@@ -165429,10 +165448,13 @@ async function exportManagedObjectToFile(name, file, envFile) {
 async function exportAllConfigEntitiesToFile(file, entitiesFile, envFile, includeMeta = true) {
   try {
     const options = getIdmImportExportOptions(entitiesFile, envFile);
-    const exportData = await exportConfigEntities2({
-      envReplaceParams: options.envReplaceParams,
-      entitiesToExport: options.entitiesToExportOrImport
-    });
+    const exportData = await exportConfigEntities2(
+      {
+        envReplaceParams: options.envReplaceParams,
+        entitiesToExport: options.entitiesToExportOrImport
+      },
+      errorHandler
+    );
     let fileName = getTypedFilename12(`all`, `idm`);
     if (file) {
       fileName = file;
@@ -165448,10 +165470,13 @@ async function exportAllConfigEntitiesToFiles(entitiesFile, envFile, separateMap
   const errors = [];
   try {
     const options = getIdmImportExportOptions(entitiesFile, envFile);
-    const exportData = await exportConfigEntities2({
-      envReplaceParams: options.envReplaceParams,
-      entitiesToExport: options.entitiesToExportOrImport
-    });
+    const exportData = await exportConfigEntities2(
+      {
+        envReplaceParams: options.envReplaceParams,
+        entitiesToExport: options.entitiesToExportOrImport
+      },
+      errorHandler
+    );
     for (const [id7, obj] of Object.entries(exportData.idm)) {
       try {
         if (separateMappings && id7 === "sync") {
@@ -165517,11 +165542,16 @@ async function importConfigEntityByIdFromFile(entityId, file, envFile, validate3
       importData = JSON.parse(fileData);
     }
     const options = getIdmImportExportOptions(void 0, envFile);
-    await importConfigEntities2(importData, entityId, {
-      envReplaceParams: options.envReplaceParams,
-      entitiesToImport: void 0,
-      validate: validate3
-    });
+    await importConfigEntities2(
+      importData,
+      entityId,
+      {
+        envReplaceParams: options.envReplaceParams,
+        entitiesToImport: void 0,
+        validate: validate3
+      },
+      errorHandler
+    );
     return true;
   } catch (error2) {
     printError2(error2);
@@ -165583,11 +165613,16 @@ async function importFirstConfigEntityFromFile(file, envFile, validate3 = false)
       ]);
     }
     const options = getIdmImportExportOptions(void 0, envFile);
-    await importConfigEntities2(importData, entityId, {
-      envReplaceParams: options.envReplaceParams,
-      entitiesToImport: void 0,
-      validate: validate3
-    });
+    await importConfigEntities2(
+      importData,
+      entityId,
+      {
+        envReplaceParams: options.envReplaceParams,
+        entitiesToImport: void 0,
+        validate: validate3
+      },
+      errorHandler
+    );
     stopProgressIndicator2(
       indicatorId,
       `Imported ${entityId} from ${filePath}.`,
@@ -165619,7 +165654,8 @@ async function importAllConfigEntitiesFromFile(file, entitiesFile, envFile, vali
         entitiesToImport: options.entitiesToExportOrImport,
         envReplaceParams: options.envReplaceParams,
         validate: validate3
-      }
+      },
+      errorHandler
     );
     stopProgressIndicator2(indicatorId, `Imported config entities`, "success");
     return true;
@@ -165684,7 +165720,8 @@ async function importAllConfigEntitiesFromFiles(entitiesFile, envFile, validate3
         entitiesToImport: options.entitiesToExportOrImport,
         envReplaceParams: options.envReplaceParams,
         validate: validate3
-      }
+      },
+      errorHandler
     );
     stopProgressIndicator2(indicatorId, `Imported config entities`, "success");
     return true;
@@ -167515,7 +167552,7 @@ var {
   importScripts: importScripts3,
   deleteScript: deleteScript3,
   deleteScriptByName: deleteScriptByName3,
-  deleteScripts: deleteScripts3
+  deleteScripts: deleteScripts2
 } = frodo.script;
 var langMap = { JAVASCRIPT: "JavaScript", GROOVY: "Groovy" };
 function getOneLineDescription(scriptObj) {
@@ -167714,7 +167751,7 @@ async function exportScriptsToFile(file, includeMeta = true, options) {
     if (file) {
       fileName = file;
     }
-    const scriptExport = await exportScripts2(options);
+    const scriptExport = await exportScripts2(options, errorHandler);
     saveJsonToFile13(scriptExport, getFilePath13(fileName, true), includeMeta);
     debugMessage2(`Cli.ScriptOps.exportScriptsToFile: end`);
     return true;
@@ -167726,56 +167763,50 @@ async function exportScriptsToFile(file, includeMeta = true, options) {
 async function exportScriptsToFiles(extract = false, includeMeta = true, options) {
   debugMessage2(`Cli.ScriptOps.exportScriptsToFiles: start`);
   const errors = [];
-  let barId;
-  try {
-    const scriptExport = await exportScripts2(options);
-    const scriptList = Object.values(scriptExport.script);
-    barId = createProgressIndicator2(
+  const scriptExport = await exportScripts2(options, errorHandler);
+  const scriptList = Object.values(scriptExport.script);
+  const barId = createProgressIndicator2(
+    "determinate",
+    scriptList.length,
+    "Exporting scripts to individual files..."
+  );
+  for (const script of scriptList) {
+    const fileBarId = createProgressIndicator2(
       "determinate",
-      scriptList.length,
-      "Exporting scripts to individual files..."
+      1,
+      `Exporting script ${script.name}...`
     );
-    for (const script of scriptList) {
-      const fileBarId = createProgressIndicator2(
-        "determinate",
-        1,
-        `Exporting script ${script.name}...`
-      );
+    try {
       const file = getFilePath13(getTypedFilename13(script.name, "script"), true);
-      try {
-        if (extract) {
-          extractScriptsToFiles({
-            script: {
-              [script._id]: script
-            }
-          });
-        }
-        saveToFile4("script", script, "_id", file, includeMeta);
-        updateProgressIndicator2(fileBarId, `Saving ${script.name} to ${file}.`);
-        stopProgressIndicator2(fileBarId, `${script.name} saved to ${file}.`);
-      } catch (error2) {
-        stopProgressIndicator2(
-          fileBarId,
-          `Error exporting ${script.name}`,
-          "fail"
-        );
-        errors.push(error2);
+      if (extract) {
+        extractScriptsToFiles({
+          script: {
+            [script._id]: script
+          }
+        });
       }
-      updateProgressIndicator2(barId, `Exported script ${script.name}`);
-    }
-    if (errors.length > 0) {
-      throw new FrodoError(`Error exporting scripts`, errors);
+      saveToFile4("script", script, "_id", file, includeMeta);
+      updateProgressIndicator2(fileBarId, `Saving ${script.name} to ${file}.`);
+      stopProgressIndicator2(fileBarId, `${script.name} saved to ${file}.`);
+    } catch (error2) {
+      stopProgressIndicator2(
+        fileBarId,
+        `Error exporting ${script.name}`,
+        "fail"
+      );
+      errors.push(error2);
     }
-    stopProgressIndicator2(
-      barId,
-      `Exported ${scriptList.length} scripts to individual files.`
-    );
-    debugMessage2(`Cli.ScriptOps.exportScriptsToFiles: end`);
-    return true;
-  } catch (error2) {
-    stopProgressIndicator2(barId, `Error exporting scripts`);
-    printError2(error2);
+    updateProgressIndicator2(barId, `Exported script ${script.name}`);
+  }
+  if (errors.length > 0) {
+    throw new FrodoError(`Error exporting scripts`, errors);
   }
+  stopProgressIndicator2(
+    barId,
+    `Exported ${scriptList.length} scripts to individual files.`
+  );
+  debugMessage2(`Cli.ScriptOps.exportScriptsToFiles: end`);
+  return true;
 }
 function extractScriptsToFiles(scriptExport, scriptId, directory, useScriptNamesForFiles = true) {
   try {
@@ -167875,7 +167906,7 @@ async function importScriptsFromFiles(watch2, options, validateScripts) {
     //       !path?.endsWith('.script.groovy')
     //     : // in regular mode, ignore everything but frodo script exports
     //       stats?.isFile() && !path?.endsWith('.script.json'),
-    ignored: (path9, stats) => _optionalChain([stats, 'optionalAccess', _372 => _372.isFile, 'call', _373 => _373()]) && !_optionalChain([path9, 'optionalAccess', _374 => _374.endsWith, 'call', _375 => _375(".script.json")]) && !_optionalChain([path9, 'optionalAccess', _376 => _376.endsWith, 'call', _377 => _377(".script.js")]) && !_optionalChain([path9, 'optionalAccess', _378 => _378.endsWith, 'call', _379 => _379(".script.groovy")]),
+    ignored: (path9, stats) => _optionalChain([stats, 'optionalAccess', _370 => _370.isFile, 'call', _371 => _371()]) && !_optionalChain([path9, 'optionalAccess', _372 => _372.endsWith, 'call', _373 => _373(".script.json")]) && !_optionalChain([path9, 'optionalAccess', _374 => _374.endsWith, 'call', _375 => _375(".script.js")]) && !_optionalChain([path9, 'optionalAccess', _376 => _376.endsWith, 'call', _377 => _377(".script.groovy")]),
     persistent: watch2,
     ignoreInitial: false
   });
@@ -167900,7 +167931,14 @@ async function handleScriptFileImport(id7 = "", name = "", file, options, valida
   const script = getScriptExportByScriptFile(file);
   const indicatorId = createProgressIndicator2("determinate", 1, `${file}`);
   try {
-    await importScripts3(id7, name, script, options, validateScripts);
+    await importScripts3(
+      id7,
+      name,
+      script,
+      options,
+      validateScripts,
+      errorHandler
+    );
     updateProgressIndicator2(indicatorId, `${file}`);
     stopProgressIndicator2(indicatorId, `${file}`);
   } catch (error2) {
@@ -167980,7 +168018,7 @@ async function deleteAllScripts() {
     `Deleting all non-default scripts...`
   );
   try {
-    await deleteScripts3();
+    await deleteScripts2(errorHandler);
     stopProgressIndicator2(
       spinnerId,
       `Deleted all non-default scripts.`,
@@ -168076,17 +168114,20 @@ async function getFullExportConfig(file = null) {
   }
   const workingDirectory = state.getDirectory();
   if (!workingDirectory) {
-    return await exportFullConfiguration2({
-      useStringArrays: true,
-      noDecode: false,
-      coords: true,
-      includeDefault: true,
-      includeActiveValues: false,
-      target: "",
-      includeReadOnly: true,
-      onlyRealm: false,
-      onlyGlobal: false
-    });
+    return await exportFullConfiguration2(
+      {
+        useStringArrays: true,
+        noDecode: false,
+        coords: true,
+        includeDefault: true,
+        includeActiveValues: false,
+        target: "",
+        includeReadOnly: true,
+        onlyRealm: false,
+        onlyGlobal: false
+      },
+      errorHandler
+    );
   }
   return await getFullExportConfigFromDirectory(workingDirectory);
 }
@@ -168274,16 +168315,12 @@ async function exportEverythingToFile(file, includeMeta = true, options = {
   onlyGlobal: false
 }) {
   try {
-    const collectErrors = [];
-    const exportData = await exportFullConfiguration3(options, collectErrors);
+    const exportData = await exportFullConfiguration3(options, errorHandler);
     let fileName = "all.config.json";
     if (file) {
       fileName = file;
     }
     saveJsonToFile15(exportData, getFilePath15(fileName, true), includeMeta);
-    if (collectErrors.length > 0) {
-      throw new FrodoError(`Errors occurred during full export`, collectErrors);
-    }
     return true;
   } catch (error2) {
     printError2(error2);
@@ -168305,7 +168342,7 @@ async function exportEverythingToFiles(extract = false, separateMappings = false
     const collectErrors = [];
     const exportData = await exportFullConfiguration3(
       options,
-      collectErrors
+      errorHandler
     );
     delete exportData.meta;
     const baseDirectory = getWorkingDirectory12(true);
@@ -168517,14 +168554,7 @@ async function importEverythingFromFile(file, options = {
 }) {
   try {
     const data2 = await getFullExportConfig(file);
-    const collectErrors = [];
-    await importFullConfiguration2(data2, options, collectErrors);
-    if (collectErrors.length > 0) {
-      throw new FrodoError(
-        `Errors occurred during full config import`,
-        collectErrors
-      );
-    }
+    await importFullConfiguration2(data2, options, errorHandler);
     return true;
   } catch (error2) {
     cleanupProgressIndicators();
@@ -168542,14 +168572,7 @@ async function importEverythingFromFiles(options = {
 }) {
   try {
     const data2 = await getFullExportConfigFromDirectory(getWorkingDirectory12());
-    const collectErrors = [];
-    await importFullConfiguration2(data2, options, collectErrors);
-    if (collectErrors.length > 0) {
-      throw new FrodoError(
-        `Errors occurred during full config import`,
-        collectErrors
-      );
-    }
+    await importFullConfiguration2(data2, options, errorHandler);
     return true;
   } catch (error2) {
     printError2(error2);
@@ -168588,14 +168611,7 @@ async function importEntityfromFile(file, global2 = false, options = {
       data2.realm[realm2] = {};
       await getConfig(data2.realm[realm2], file, void 0);
     }
-    const collectErrors = [];
-    const imports = await importFullConfiguration2(data2, options, collectErrors);
-    if (collectErrors.length > 0) {
-      throw new FrodoError(
-        `Error occurred during config import`,
-        collectErrors
-      );
-    }
+    const imports = await importFullConfiguration2(data2, options, errorHandler);
     if (imports.length === 0) {
       throw new FrodoError(`No imports were made`);
     }
@@ -169261,7 +169277,7 @@ async function tailLogs(source, levels, txid, cookie, nf) {
       filteredLogs = logsObject.result.filter(
         (el) => !noiseFilter.includes(
           el.payload.logger
-        ) && !noiseFilter.includes(el.type) && (levels[0] === "ALL" || levels.includes(resolvePayloadLevel2(el))) && (typeof txid === "undefined" || txid === null || _optionalChain([el, 'access', _380 => _380.payload, 'access', _381 => _381.transactionId, 'optionalAccess', _382 => _382.includes, 'call', _383 => _383(
+        ) && !noiseFilter.includes(el.type) && (levels[0] === "ALL" || levels.includes(resolvePayloadLevel2(el))) && (typeof txid === "undefined" || txid === null || _optionalChain([el, 'access', _378 => _378.payload, 'access', _379 => _379.transactionId, 'optionalAccess', _380 => _380.includes, 'call', _381 => _381(
           txid
         )]))
       );
@@ -169285,7 +169301,7 @@ async function fetchLogs(source, startTs, endTs, levels, txid, ffString, cookie,
       filteredLogs = logsObject.result.filter(
         (el) => !noiseFilter.includes(
           el.payload.logger
-        ) && !noiseFilter.includes(el.type) && (levels[0] === "ALL" || levels.includes(resolvePayloadLevel2(el))) && (typeof txid === "undefined" || txid === null || _optionalChain([el, 'access', _384 => _384.payload, 'access', _385 => _385.transactionId, 'optionalAccess', _386 => _386.includes, 'call', _387 => _387(
+        ) && !noiseFilter.includes(el.type) && (levels[0] === "ALL" || levels.includes(resolvePayloadLevel2(el))) && (typeof txid === "undefined" || txid === null || _optionalChain([el, 'access', _382 => _382.payload, 'access', _383 => _383.transactionId, 'optionalAccess', _384 => _384.includes, 'call', _385 => _385(
           txid
         )]))
       );
@@ -169439,9 +169455,9 @@ function setup79() {
                 `Created log API key ${creds.api_key_id} and secret.`
               );
             } catch (error2) {
-              printMessage2(_optionalChain([error2, 'access', _388 => _388.response, 'optionalAccess', _389 => _389.data]), "error");
+              printMessage2(_optionalChain([error2, 'access', _386 => _386.response, 'optionalAccess', _387 => _387.data]), "error");
               printMessage2(
-                `Error creating log API key and secret: ${_optionalChain([error2, 'access', _390 => _390.response, 'optionalAccess', _391 => _391.data, 'optionalAccess', _392 => _392.message])}`,
+                `Error creating log API key and secret: ${_optionalChain([error2, 'access', _388 => _388.response, 'optionalAccess', _389 => _389.data, 'optionalAccess', _390 => _390.message])}`,
                 "error"
               );
               process.exitCode = 1;
@@ -170147,7 +170163,7 @@ function setup86() {
           printMessage2(updatesTable.toString(), "data");
         }
         if (!options.checkOnly) {
-          if (_optionalChain([updates, 'access', _393 => _393.secrets, 'optionalAccess', _394 => _394.length]) || _optionalChain([updates, 'access', _395 => _395.variables, 'optionalAccess', _396 => _396.length]) || options.force) {
+          if (_optionalChain([updates, 'access', _391 => _391.secrets, 'optionalAccess', _392 => _392.length]) || _optionalChain([updates, 'access', _393 => _393.variables, 'optionalAccess', _394 => _394.length]) || options.force) {
             const ok = options.yes || await (0, import_yesno.default)({
               question: `
 Changes may take up to 10 minutes to propagate, during which time you will not be able to make further updates.
@@ -173856,7 +173872,7 @@ function getNodeClassificationMd(nodeType) {
 function getOneLineDescription5(nodeObj, nodeRef) {
   const description = `[${nodeObj._id["brightCyan"]}] (${getNodeClassification2(
     nodeObj._type._id
-  ).join(", ")}) ${nodeObj._type._id}${nodeRef ? " - " + _optionalChain([nodeRef, 'optionalAccess', _397 => _397.displayName]) : ""}`;
+  ).join(", ")}) ${nodeObj._type._id}${nodeRef ? " - " + _optionalChain([nodeRef, 'optionalAccess', _395 => _395.displayName]) : ""}`;
   return description;
 }
 function getTableHeaderMd5() {
@@ -174592,7 +174608,7 @@ async function listJourneys(long = false, analyze = false) {
           table.push([
             `${journeyStub._id}`,
             journeyStub.enabled === false ? "disabled"["brightRed"] : "enabled"["brightGreen"],
-            _optionalChain([journeyStub, 'access', _398 => _398.uiConfig, 'optionalAccess', _399 => _399.categories]) ? wordwrap(
+            _optionalChain([journeyStub, 'access', _396 => _396.uiConfig, 'optionalAccess', _397 => _397.categories]) ? wordwrap(
               JSON.parse(journeyStub.uiConfig.categories).join(", "),
               60
             ) : ""
@@ -174634,7 +174650,7 @@ async function listJourneys(long = false, analyze = false) {
               `${journeyExport.tree._id}`,
               journeyExport.tree.enabled === false ? "disabled"["brightRed"] : "enabled"["brightGreen"],
               getJourneyClassification2(journeyExport).join(", "),
-              _optionalChain([journeyExport, 'access', _400 => _400.tree, 'access', _401 => _401.uiConfig, 'optionalAccess', _402 => _402.categories]) ? wordwrap(
+              _optionalChain([journeyExport, 'access', _398 => _398.tree, 'access', _399 => _399.uiConfig, 'optionalAccess', _400 => _400.categories]) ? wordwrap(
                 JSON.parse(journeyExport.tree.uiConfig.categories).join(
                   ", "
                 ),
@@ -174678,9 +174694,10 @@ async function exportJourneyToFile(journeyId, file, includeMeta = true, options
       journeyId,
       options
     );
+    delete fileData.meta;
     if (verbose)
       spinnerId = createProgressIndicator2("indeterminate", 0, `${journeyId}`);
-    saveJsonToFile23(fileData, filePath, includeMeta);
+    saveJsonToFile23({ trees: { [fileData.tree._id]: fileData } }, filePath, includeMeta);
     stopProgressIndicator2(
       spinnerId,
       `Exported ${journeyId["brightCyan"]} to ${filePath["brightCyan"]}.`,
@@ -174709,7 +174726,10 @@ async function exportJourneysToFile(file, includeMeta = true, options = {
       file = getTypedFilename22(`all${getRealmString5()}Journeys`, "journey");
     }
     const filePath = getFilePath23(file, true);
-    const fileData = await exportJourneys2(options);
+    const fileData = await exportJourneys2(
+      options,
+      errorHandler
+    );
     saveJsonToFile23(fileData, filePath, includeMeta);
     return true;
   } catch (error2) {
@@ -174722,7 +174742,7 @@ async function exportJourneysToFiles(includeMeta = true, options = {
   coords: true
 }) {
   try {
-    const journeysExport = await exportJourneys2(options);
+    const journeysExport = await exportJourneys2(options, errorHandler);
     const trees = Object.entries(journeysExport.trees);
     for (const [treeId, treeValue] of trees) {
       const indicatorId = createProgressIndicator2(
@@ -174731,10 +174751,9 @@ async function exportJourneysToFiles(includeMeta = true, options = {
         `Saving ${treeId}...`
       );
       const file = getFilePath23(getTypedFilename22(`${treeId}`, "journey"), true);
-      treeValue["meta"] = journeysExport.meta;
       try {
         updateProgressIndicator2(indicatorId, `Saving ${treeId} to ${file}`);
-        saveJsonToFile23(treeValue, file, includeMeta);
+        saveJsonToFile23({ trees: { [treeValue.tree._id]: treeValue } }, file, includeMeta);
         stopProgressIndicator2(indicatorId, `${treeId} saved to ${file}`);
       } catch (error2) {
         stopProgressIndicator2(indicatorId, `Error saving ${treeId} to ${file}`);
@@ -174928,7 +174947,7 @@ async function importJourneysFromFile(file, options) {
   try {
     const data2 = fs35.default.readFileSync(getFilePath23(file), "utf8");
     const fileData = JSON.parse(data2);
-    await importJourneys2(fileData, options);
+    await importJourneys2(fileData, options, errorHandler);
     return true;
   } catch (error2) {
     printError2(error2);
@@ -174946,7 +174965,11 @@ async function importJourneysFromFiles(options) {
         allJourneysData.trees[id7] = obj;
       }
     }
-    await importJourneys2(allJourneysData, options);
+    await importJourneys2(
+      allJourneysData,
+      options,
+      errorHandler
+    );
     return true;
   } catch (error2) {
     printError2(error2);
@@ -175039,7 +175062,7 @@ async function describeJourney(journeyData, resolveTreeExport = onlineTreeExport
         nodeTypeMap[nodeData._type._id] = 1;
       }
     }
-    if (!state.getAmVersion() && _optionalChain([journeyData, 'access', _403 => _403.meta, 'optionalAccess', _404 => _404.originAmVersion])) {
+    if (!state.getAmVersion() && _optionalChain([journeyData, 'access', _401 => _401.meta, 'optionalAccess', _402 => _402.originAmVersion])) {
       state.setAmVersion(journeyData.meta.originAmVersion);
     }
     printMessage2(`${getOneLineDescription8(journeyData.tree)}`, "data");
@@ -175063,7 +175086,7 @@ ${getJourneyClassification2(journeyData).join(", ")}`,
         "data"
       );
     }
-    if (_optionalChain([journeyData, 'access', _405 => _405.tree, 'access', _406 => _406.uiConfig, 'optionalAccess', _407 => _407.categories]) && journeyData.tree.uiConfig.categories != "[]") {
+    if (_optionalChain([journeyData, 'access', _403 => _403.tree, 'access', _404 => _404.uiConfig, 'optionalAccess', _405 => _405.categories]) && journeyData.tree.uiConfig.categories != "[]") {
       printMessage2("\nCategories/Tags", "data");
       printMessage2(
         `${JSON.parse(journeyData.tree.uiConfig.categories).join(", ")}`,
@@ -175105,7 +175128,7 @@ Nodes (${Object.entries(allNodes).length}):`, "data");
         );
       }
     }
-    if (_optionalChain([journeyData, 'access', _408 => _408.themes, 'optionalAccess', _409 => _409.length])) {
+    if (_optionalChain([journeyData, 'access', _406 => _406.themes, 'optionalAccess', _407 => _407.length])) {
       printMessage2(`
 Themes (${journeyData.themes.length}):`, "data");
       for (const themeData of journeyData.themes) {
@@ -175199,14 +175222,14 @@ async function describeJourneyMd(journeyData, resolveTreeExport = onlineTreeExpo
         nodeTypeMap[nodeData._type._id] = 1;
       }
     }
-    if (!state.getAmVersion() && _optionalChain([journeyData, 'access', _410 => _410.meta, 'optionalAccess', _411 => _411.originAmVersion])) {
+    if (!state.getAmVersion() && _optionalChain([journeyData, 'access', _408 => _408.meta, 'optionalAccess', _409 => _409.originAmVersion])) {
       state.setAmVersion(journeyData.meta.originAmVersion);
     }
     printMessage2(
       `# ${getOneLineDescriptionMd(journeyData.tree)} - ${journeyData.tree.enabled === false ? ":o: `disabled`" : ":white_check_mark: `enabled`"}, ${getJourneyClassificationMd(journeyData).join(", ")}`,
       "data"
     );
-    if (_optionalChain([journeyData, 'access', _412 => _412.tree, 'access', _413 => _413.uiConfig, 'optionalAccess', _414 => _414.categories]) && journeyData.tree.uiConfig.categories != "[]") {
+    if (_optionalChain([journeyData, 'access', _410 => _410.tree, 'access', _411 => _411.uiConfig, 'optionalAccess', _412 => _412.categories]) && journeyData.tree.uiConfig.categories != "[]") {
       printMessage2(
         `\`${JSON.parse(journeyData.tree.uiConfig.categories).join("`, `")}\``,
         "data"
@@ -175250,7 +175273,7 @@ ${journeyData.tree.description}`, "data");
         );
       }
     }
-    if (_optionalChain([journeyData, 'access', _415 => _415.themes, 'optionalAccess', _416 => _416.length])) {
+    if (_optionalChain([journeyData, 'access', _413 => _413.themes, 'optionalAccess', _414 => _414.length])) {
       printMessage2(`## Themes (${journeyData.themes.length})`, "data");
       printMessage2(getTableHeaderMd7(), "data");
       for (const themeData of journeyData.themes) {
@@ -175390,7 +175413,10 @@ async function deleteJourneys2(options = {
     `Deleting journeys...`
   );
   try {
-    const status = await _deleteJourneys(options);
+    const status = await _deleteJourneys(
+      options,
+      errorHandler
+    );
     stopProgressIndicator2(
       indicatorId,
       `Deleted ${Object.keys(status).length} journeys`
@@ -175520,9 +175546,9 @@ function setup127() {
             journeyData = fileData.trees[options.journeyId];
           } else if (typeof options.journeyId === "undefined" && fileData.trees) {
             [journeyData] = Object.values(fileData.trees);
-          } else if (typeof options.journeyId !== "undefined" && options.journeyId === _optionalChain([fileData, 'access', _417 => _417.tree, 'optionalAccess', _418 => _418._id])) {
+          } else if (typeof options.journeyId !== "undefined" && options.journeyId === _optionalChain([fileData, 'access', _415 => _415.tree, 'optionalAccess', _416 => _416._id])) {
             journeyData = fileData;
-          } else if (typeof options.journeyId === "undefined" && _optionalChain([fileData, 'access', _419 => _419.tree, 'optionalAccess', _420 => _420._id])) {
+          } else if (typeof options.journeyId === "undefined" && _optionalChain([fileData, 'access', _417 => _417.tree, 'optionalAccess', _418 => _418._id])) {
             journeyData = fileData;
           } else {
             throw new Error(
@@ -177398,7 +177424,7 @@ async function importServiceFromFile(serviceId, file, options = {
     );
     const data2 = fs35.default.readFileSync(filePath, "utf8");
     const importData = JSON.parse(data2);
-    if (_optionalChain([importData, 'optionalAccess', _421 => _421.service, 'access', _422 => _422[serviceId]])) {
+    if (_optionalChain([importData, 'optionalAccess', _419 => _419.service, 'access', _420 => _420[serviceId]])) {
       await importService2(serviceId, importData, options);
       stopProgressIndicator2(
         indicatorId,
@@ -178615,7 +178641,7 @@ async function listRealms(long = false) {
   } catch (error2) {
     printMessage2(error2, "error");
     printMessage2(`Error listing realms: ${error2.message}`, "error");
-    printMessage2(_optionalChain([error2, 'access', _423 => _423.response, 'optionalAccess', _424 => _424.data]), "error");
+    printMessage2(_optionalChain([error2, 'access', _421 => _421.response, 'optionalAccess', _422 => _422.data]), "error");
   }
 }
 async function exportRealmById(realmId, file, includeMeta = true) {
@@ -181412,7 +181438,7 @@ var compareVersions = (v12, v2) => {
 // package.json
 var package_default2 = {
   name: "@rockcarver/frodo-cli",
-  version: "3.0.5",
+  version: "3.0.6",
   type: "module",
   description: "A command line interface to manage ForgeRock Identity Cloud tenants, ForgeOps deployments, and classic deployments.",
   keywords: [
@@ -181527,7 +181553,7 @@ var package_default2 = {
     ]
   },
   devDependencies: {
-    "@rockcarver/frodo-lib": "3.1.0",
+    "@rockcarver/frodo-lib": "3.3.0",
     "@types/colors": "^1.2.1",
     "@types/fs-extra": "^11.0.1",
     "@types/jest": "^29.2.3",