@itentialopensource/adapter-nokia_netact 0.1.1

package/adapter.js

@@ -0,0 +1,4743 @@
+/* @copyright Itential, LLC 2019 (pre-modifications) */
+
+/* eslint import/no-dynamic-require: warn */
+/* eslint object-curly-newline: warn */
+/* eslint default-param-last: warn */
+
+// Set globals
+/* global log */
+
+/* Required libraries.  */
+const path = require('path');
+
+/* Fetch in the other needed components for the this Adaptor */
+const AdapterBaseCl = require(path.join(__dirname, 'adapterBase.js'));
+
+/**
+ * This is the adapter/interface into Nokia_netact
+ */
+
+/* GENERAL ADAPTER FUNCTIONS */
+class NokiaNetact extends AdapterBaseCl {
+  /**
+   * NokiaNetact Adapter
+   * @constructor
+   */
+  /* Working on changing the way we do Emit methods due to size and time constrainsts
+  constructor(prongid, properties) {
+    // Instantiate the AdapterBase super class
+    super(prongid, properties);
+
+    const restFunctionNames = this.iapGetAdapterWorkflowFunctions();
+
+    // Dynamically bind emit functions
+    for (let i = 0; i < restFunctionNames.length; i += 1) {
+      // Bind function to have name fnNameEmit for fnName
+      const version = restFunctionNames[i].match(/__v[0-9]+/);
+      const baseFnName = restFunctionNames[i].replace(/__v[0-9]+/, '');
+      const fnNameEmit = version ? `${baseFnName}Emit${version}` : `${baseFnName}Emit`;
+      this[fnNameEmit] = function (...args) {
+        // extract the callback
+        const callback = args[args.length - 1];
+        // slice the callback from args so we can insert our own
+        const functionArgs = args.slice(0, args.length - 1);
+        // create a random name for the listener
+        const eventName = `${restFunctionNames[i]}:${Math.random().toString(36)}`;
+        // tell the calling class to start listening
+        callback({ event: eventName, status: 'received' });
+        // store parent for use of this context later
+        const parent = this;
+        // store emission function
+        const func = function (val, err) {
+          parent.removeListener(eventName, func);
+          parent.emit(eventName, val, err);
+        };
+        // Use apply to call the function in a specific context
+        this[restFunctionNames[i]].apply(this, functionArgs.concat([func])); // eslint-disable-line prefer-spread
+      };
+    }
+
+    // Uncomment if you have things to add to the constructor like using your own properties.
+    // Otherwise the constructor in the adapterBase will be used.
+    // Capture my own properties - they need to be defined in propertiesSchema.json
+    // if (this.allProps && this.allProps.myownproperty) {
+    //   mypropvariable = this.allProps.myownproperty;
+    // }
+  }
+  */
+
+  /**
+   * @callback healthCallback
+   * @param {Object} reqObj - the request to send into the healthcheck
+   * @param {Callback} callback - The results of the call
+   */
+  healthCheck(reqObj, callback) {
+    // you can modify what is passed into the healthcheck by changing things in the newReq
+    let newReq = null;
+    if (reqObj) {
+      newReq = Object.assign(...reqObj);
+    }
+    super.healthCheck(newReq, callback);
+  }
+
+  /**
+   * @iapGetAdapterWorkflowFunctions
+   */
+  iapGetAdapterWorkflowFunctions(inIgnore) {
+    let myIgnore = [
+      'healthCheck',
+      'iapGetAdapterWorkflowFunctions',
+      'hasEntities',
+      'getAuthorization'
+    ];
+    if (!inIgnore && Array.isArray(inIgnore)) {
+      myIgnore = inIgnore;
+    } else if (!inIgnore && typeof inIgnore === 'string') {
+      myIgnore = [inIgnore];
+    }
+
+    // The generic adapter functions should already be ignored (e.g. healthCheck)
+    // you can add specific methods that you do not want to be workflow functions to ignore like below
+    // myIgnore.push('myMethodNotInWorkflow');
+
+    return super.iapGetAdapterWorkflowFunctions(myIgnore);
+  }
+
+  /**
+   * iapUpdateAdapterConfiguration is used to update any of the adapter configuration files. This
+   * allows customers to make changes to adapter configuration without having to be on the
+   * file system.
+   *
+   * @function iapUpdateAdapterConfiguration
+   * @param {string} configFile - the name of the file being updated (required)
+   * @param {Object} changes - an object containing all of the changes = formatted like the configuration file (required)
+   * @param {string} entity - the entity to be changed, if an action, schema or mock data file (optional)
+   * @param {string} type - the type of entity file to change, (action, schema, mock) (optional)
+   * @param {string} action - the action to be changed, if an action, schema or mock data file (optional)
+   * @param {boolean} replace - true to replace entire mock data, false to merge/append
+   * @param {Callback} callback - The results of the call
+   */
+  iapUpdateAdapterConfiguration(configFile, changes, entity, type, action, replace, callback) {
+    const meth = 'adapter-iapUpdateAdapterConfiguration';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    super.iapUpdateAdapterConfiguration(configFile, changes, entity, type, action, replace, callback);
+  }
+
+  /**
+    * @summary Suspends adapter
+    *
+    * @function iapSuspendAdapter
+    * @param {Callback} callback - callback function
+    */
+  iapSuspendAdapter(mode, callback) {
+    const meth = 'adapter-iapSuspendAdapter';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapSuspendAdapter(mode, callback);
+    } catch (error) {
+      log.error(`${origin}: ${error}`);
+      return callback(null, error);
+    }
+  }
+
+  /**
+    * @summary Unsuspends adapter
+    *
+    * @function iapUnsuspendAdapter
+    * @param {Callback} callback - callback function
+    */
+  iapUnsuspendAdapter(callback) {
+    const meth = 'adapter-iapUnsuspendAdapter';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapUnsuspendAdapter(callback);
+    } catch (error) {
+      log.error(`${origin}: ${error}`);
+      return callback(null, error);
+    }
+  }
+
+  /**
+    * @summary Get the Adapter Queue
+    *
+    * @function iapGetAdapterQueue
+    * @param {Callback} callback - callback function
+    */
+  iapGetAdapterQueue(callback) {
+    const meth = 'adapter-iapGetAdapterQueue';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    return super.iapGetAdapterQueue(callback);
+  }
+
+  /* SCRIPT CALLS */
+  /**
+   * See if the API path provided is found in this adapter
+   *
+   * @function iapFindAdapterPath
+   * @param {string} apiPath - the api path to check on
+   * @param {Callback} callback - The results of the call
+   */
+  iapFindAdapterPath(apiPath, callback) {
+    const meth = 'adapter-iapFindAdapterPath';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    super.iapFindAdapterPath(apiPath, callback);
+  }
+
+  /**
+  * @summary Runs troubleshoot scripts for adapter
+  *
+  * @function iapTroubleshootAdapter
+  * @param {Object} props - the connection, healthcheck and authentication properties
+  *
+  * @param {boolean} persistFlag - whether the adapter properties should be updated
+  * @param {Callback} callback - The results of the call
+  */
+  iapTroubleshootAdapter(props, persistFlag, callback) {
+    const meth = 'adapter-iapTroubleshootAdapter';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapTroubleshootAdapter(props, persistFlag, this, callback);
+    } catch (error) {
+      log.error(`${origin}: ${error}`);
+      return callback(null, error);
+    }
+  }
+
+  /**
+    * @summary runs healthcheck script for adapter
+    *
+    * @function iapRunAdapterHealthcheck
+    * @param {Adapter} adapter - adapter instance to troubleshoot
+    * @param {Callback} callback - callback function
+    */
+  iapRunAdapterHealthcheck(callback) {
+    const meth = 'adapter-iapRunAdapterHealthcheck';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapRunAdapterHealthcheck(this, callback);
+    } catch (error) {
+      log.error(`${origin}: ${error}`);
+      return callback(null, error);
+    }
+  }
+
+  /**
+    * @summary runs connectivity check script for adapter
+    *
+    * @function iapRunAdapterConnectivity
+    * @param {Callback} callback - callback function
+    */
+  iapRunAdapterConnectivity(callback) {
+    const meth = 'adapter-iapRunAdapterConnectivity';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapRunAdapterConnectivity(callback);
+    } catch (error) {
+      log.error(`${origin}: ${error}`);
+      return callback(null, error);
+    }
+  }
+
+  /**
+    * @summary runs basicGet script for adapter
+    *
+    * @function iapRunAdapterBasicGet
+    * @param {Callback} callback - callback function
+    */
+  iapRunAdapterBasicGet(callback) {
+    const meth = 'adapter-iapRunAdapterBasicGet';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapRunAdapterBasicGet(callback);
+    } catch (error) {
+      log.error(`${origin}: ${error}`);
+      return callback(null, error);
+    }
+  }
+
+  /**
+   * @summary moves entites into Mongo DB
+   *
+   * @function iapMoveAdapterEntitiesToDB
+   * @param {getCallback} callback - a callback function to return the result (Generics)
+   *                                  or the error
+   */
+  iapMoveAdapterEntitiesToDB(callback) {
+    const meth = 'adapter-iapMoveAdapterEntitiesToDB';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapMoveAdapterEntitiesToDB(callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /**
+   * @summary Deactivate adapter tasks
+   *
+   * @function iapDeactivateTasks
+   *
+   * @param {Array} tasks - List of tasks to deactivate
+   * @param {Callback} callback
+   */
+  iapDeactivateTasks(tasks, callback) {
+    const meth = 'adapter-iapDeactivateTasks';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapDeactivateTasks(tasks, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /**
+   * @summary Activate adapter tasks that have previously been deactivated
+   *
+   * @function iapActivateTasks
+   *
+   * @param {Array} tasks - List of tasks to activate
+   * @param {Callback} callback
+   */
+  iapActivateTasks(tasks, callback) {
+    const meth = 'adapter-iapActivateTasks';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapActivateTasks(tasks, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /* CACHE CALLS */
+  /**
+   * @summary Populate the cache for the given entities
+   *
+   * @function iapPopulateEntityCache
+   * @param {String/Array of Strings} entityType - the entity type(s) to populate
+   * @param {Callback} callback - whether the cache was updated or not for each entity type
+   *
+   * @returns status of the populate
+   */
+  iapPopulateEntityCache(entityTypes, callback) {
+    const meth = 'adapter-iapPopulateEntityCache';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapPopulateEntityCache(entityTypes, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /**
+   * @summary Retrieves data from cache for specified entity type
+   *
+   * @function iapRetrieveEntitiesCache
+   * @param {String} entityType - entity of which to retrieve
+   * @param {Object} options - settings of which data to return and how to return it
+   * @param {Callback} callback - the data if it was retrieved
+   */
+  iapRetrieveEntitiesCache(entityType, options, callback) {
+    const meth = 'adapter-iapCheckEiapRetrieveEntitiesCachentityCached';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapRetrieveEntitiesCache(entityType, options, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /* BROKER CALLS */
+  /**
+   * @summary Determines if this adapter supports any in a list of entities
+   *
+   * @function hasEntities
+   * @param {String} entityType - the entity type to check for
+   * @param {Array} entityList - the list of entities we are looking for
+   *
+   * @param {Callback} callback - A map where the entity is the key and the
+   *                              value is true or false
+   */
+  hasEntities(entityType, entityList, callback) {
+    const meth = 'adapter-hasEntities';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.hasEntities(entityType, entityList, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /**
+   * @summary Get Appliance that match the deviceName
+   *
+   * @function getDevice
+   * @param {String} deviceName - the deviceName to find (required)
+   *
+   * @param {getCallback} callback - a callback function to return the result
+   *                                 (appliance) or the error
+   */
+  getDevice(deviceName, callback) {
+    const meth = 'adapter-getDevice';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.getDevice(deviceName, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /**
+   * @summary Get Appliances that match the filter
+   *
+   * @function getDevicesFiltered
+   * @param {Object} options - the data to use to filter the appliances (optional)
+   *
+   * @param {getCallback} callback - a callback function to return the result
+   *                                 (appliances) or the error
+   */
+  getDevicesFiltered(options, callback) {
+    const meth = 'adapter-getDevicesFiltered';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.getDevicesFiltered(options, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /**
+   * @summary Gets the status for the provided appliance
+   *
+   * @function isAlive
+   * @param {String} deviceName - the deviceName of the appliance. (required)
+   *
+   * @param {configCallback} callback - callback function to return the result
+   *                                    (appliance isAlive) or the error
+   */
+  isAlive(deviceName, callback) {
+    const meth = 'adapter-isAlive';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.isAlive(deviceName, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /**
+   * @summary Gets a config for the provided Appliance
+   *
+   * @function getConfig
+   * @param {String} deviceName - the deviceName of the appliance. (required)
+   * @param {String} format - the desired format of the config. (optional)
+   *
+   * @param {configCallback} callback - callback function to return the result
+   *                                    (appliance config) or the error
+   */
+  getConfig(deviceName, format, callback) {
+    const meth = 'adapter-getConfig';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.getConfig(deviceName, format, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /**
+   * @summary Gets the device count from the system
+   *
+   * @function iapGetDeviceCount
+   *
+   * @param {getCallback} callback - callback function to return the result
+   *                                    (count) or the error
+   */
+  iapGetDeviceCount(callback) {
+    const meth = 'adapter-iapGetDeviceCount';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapGetDeviceCount(callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /* GENERIC ADAPTER REQUEST - allows extension of adapter without new calls being added */
+  /**
+   * Makes the requested generic call
+   *
+   * @function iapExpandedGenericAdapterRequest
+   * @param {Object} metadata - metadata for the call (optional).
+   *                 Can be a stringified Object.
+   * @param {String} uriPath - the path of the api call - do not include the host, port, base path or version (optional)
+   * @param {String} restMethod - the rest method (GET, POST, PUT, PATCH, DELETE) (optional)
+   * @param {Object} pathVars - the parameters to be put within the url path (optional).
+   *                 Can be a stringified Object.
+   * @param {Object} queryData - the parameters to be put on the url (optional).
+   *                 Can be a stringified Object.
+   * @param {Object} requestBody - the body to add to the request (optional).
+   *                 Can be a stringified Object.
+   * @param {Object} addlHeaders - additional headers to be put on the call (optional).
+   *                 Can be a stringified Object.
+   * @param {getCallback} callback - a callback function to return the result (Generics)
+   *                 or the error
+   */
+  iapExpandedGenericAdapterRequest(metadata, uriPath, restMethod, pathVars, queryData, requestBody, addlHeaders, callback) {
+    const meth = 'adapter-iapExpandedGenericAdapterRequest';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.iapExpandedGenericAdapterRequest(metadata, uriPath, restMethod, pathVars, queryData, requestBody, addlHeaders, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /**
+   * Makes the requested generic call
+   *
+   * @function genericAdapterRequest
+   * @param {String} uriPath - the path of the api call - do not include the host, port, base path or version (required)
+   * @param {String} restMethod - the rest method (GET, POST, PUT, PATCH, DELETE) (required)
+   * @param {Object} queryData - the parameters to be put on the url (optional).
+   *                 Can be a stringified Object.
+   * @param {Object} requestBody - the body to add to the request (optional).
+   *                 Can be a stringified Object.
+   * @param {Object} addlHeaders - additional headers to be put on the call (optional).
+   *                 Can be a stringified Object.
+   * @param {getCallback} callback - a callback function to return the result (Generics)
+   *                 or the error
+   */
+  genericAdapterRequest(uriPath, restMethod, queryData, requestBody, addlHeaders, callback) {
+    const meth = 'adapter-genericAdapterRequest';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.genericAdapterRequest(uriPath, restMethod, queryData, requestBody, addlHeaders, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /**
+   * Makes the requested generic call with no base path or version
+   *
+   * @function genericAdapterRequestNoBasePath
+   * @param {String} uriPath - the path of the api call - do not include the host, port, base path or version (required)
+   * @param {String} restMethod - the rest method (GET, POST, PUT, PATCH, DELETE) (required)
+   * @param {Object} queryData - the parameters to be put on the url (optional).
+   *                 Can be a stringified Object.
+   * @param {Object} requestBody - the body to add to the request (optional).
+   *                 Can be a stringified Object.
+   * @param {Object} addlHeaders - additional headers to be put on the call (optional).
+   *                 Can be a stringified Object.
+   * @param {getCallback} callback - a callback function to return the result (Generics)
+   *                 or the error
+   */
+  genericAdapterRequestNoBasePath(uriPath, restMethod, queryData, requestBody, addlHeaders, callback) {
+    const meth = 'adapter-genericAdapterRequestNoBasePath';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return super.genericAdapterRequestNoBasePath(uriPath, restMethod, queryData, requestBody, addlHeaders, callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /* INVENTORY CALLS */
+  /**
+   * @summary run the adapter lint script to return the results.
+   *
+   * @function iapRunAdapterLint
+   * @param {Callback} callback - callback function
+   */
+  iapRunAdapterLint(callback) {
+    const meth = 'adapter-iapRunAdapterLint';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    return super.iapRunAdapterLint(callback);
+  }
+
+  /**
+   * @summary run the adapter test scripts (baseunit and unit) to return the results.
+   *    can not run integration as there can be implications with that.
+   *
+   * @function iapRunAdapterTests
+   * @param {Callback} callback - callback function
+   */
+  iapRunAdapterTests(callback) {
+    const meth = 'adapter-iapRunAdapterTests';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    return super.iapRunAdapterTests(callback);
+  }
+
+  /**
+   * @summary provide inventory information abbout the adapter
+   *
+   * @function iapGetAdapterInventory
+   * @param {Callback} callback - callback function
+   */
+  iapGetAdapterInventory(callback) {
+    const meth = 'adapter-iapGetAdapterInventory';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    return super.iapGetAdapterInventory(callback);
+  }
+
+  /**
+   * @callback healthCallback
+   * @param {Object} result - the result of the get request (contains an id and a status)
+   */
+  /**
+   * @callback getCallback
+   * @param {Object} result - the result of the get request (entity/ies)
+   * @param {String} error - any error that occurred
+   */
+  /**
+   * @callback createCallback
+   * @param {Object} item - the newly created entity
+   * @param {String} error - any error that occurred
+   */
+  /**
+   * @callback updateCallback
+   * @param {String} status - the status of the update action
+   * @param {String} error - any error that occurred
+   */
+  /**
+   * @callback deleteCallback
+   * @param {String} status - the status of the delete action
+   * @param {String} error - any error that occurred
+   */
+
+  /**
+   * @function getConfigurations
+   * @pronghornType method
+   * @name getConfigurations
+   * @summary Retrieve configuration headers
+   *
+   * @param {string} [type] - type param
+   * @param {string} [confId] - confId param
+   * @param {string} [name] - name param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getConfigurations
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getConfigurations(type = 'ACTUAL', confId, name, iapMetadata, callback) {
+    const meth = 'adapter-getConfigurations';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = { type, confId, name };
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'getConfigurations', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getConfigurations'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function createConfiguration
+   * @pronghornType method
+   * @name createConfiguration
+   * @summary Create a plan
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /createConfiguration
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  createConfiguration(body, iapMetadata, callback) {
+    const meth = 'adapter-createConfiguration';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'createConfiguration', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['createConfiguration'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function deleteConfiguration
+   * @pronghornType method
+   * @name deleteConfiguration
+   * @summary Delete a plan
+   *
+   * @param {string} confId - confId param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /deleteConfiguration
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  deleteConfiguration(confId, iapMetadata, callback) {
+    const meth = 'adapter-deleteConfiguration';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (confId === undefined || confId === null || confId === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['confId'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = { confId };
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'deleteConfiguration', reqObj, false, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['deleteConfiguration'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function updateConfiguration
+   * @pronghornType method
+   * @name updateConfiguration
+   * @summary Update a plan
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /updateConfiguration
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  updateConfiguration(body, iapMetadata, callback) {
+    const meth = 'adapter-updateConfiguration';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'updateConfiguration', reqObj, false, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['updateConfiguration'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getDescendantMOLites
+   * @pronghornType method
+   * @name getDescendantMOLites
+   * @summary Retrieve descendant Managed Objects
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getDescendantMOLites
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getDescendantMOLites(body, iapMetadata, callback) {
+    const meth = 'adapter-getDescendantMOLites';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'getDescendantMOLites', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDescendantMOLites'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getManagedObjects
+   * @pronghornType method
+   * @name getManagedObjects
+   * @summary Retrieve Managed Objects parameters
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getManagedObjects
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getManagedObjects(body, iapMetadata, callback) {
+    const meth = 'adapter-getManagedObjects';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'getManagedObjects', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getManagedObjects'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function updateManagedObjects
+   * @pronghornType method
+   * @name updateManagedObjects
+   * @summary Update Managed Objects in plan configuration
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /updateManagedObjects
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  updateManagedObjects(body, iapMetadata, callback) {
+    const meth = 'adapter-updateManagedObjects';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'updateManagedObjects', reqObj, false, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['updateManagedObjects'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function addManagedObjects
+   * @pronghornType method
+   * @name addManagedObjects
+   * @summary Add Managed Objects to plan configuration
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /addManagedObjects
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  addManagedObjects(body, iapMetadata, callback) {
+    const meth = 'adapter-addManagedObjects';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'addManagedObjects', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['addManagedObjects'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function removeManagedObjects
+   * @pronghornType method
+   * @name removeManagedObjects
+   * @summary Remove Managed Objects from plan configuration
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /removeManagedObjects
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  removeManagedObjects(body, iapMetadata, callback) {
+    const meth = 'adapter-removeManagedObjects';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'removeManagedObjects', reqObj, false, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['removeManagedObjects'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getMetaAdaptations
+   * @pronghornType method
+   * @name getMetaAdaptations
+   * @summary Retrieve adaptations
+   *
+   * @param {array} [adaptId] - adaptId param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getMetaAdaptations
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getMetaAdaptations(adaptId, iapMetadata, callback) {
+    const meth = 'adapter-getMetaAdaptations';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = { adaptId };
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'getMetaAdaptations', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getMetaAdaptations'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getMetaClasses
+   * @pronghornType method
+   * @name getMetaClasses
+   * @summary Retrieve Managed Objects classes
+   *
+   * @param {array} [adaptId] - adaptId param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getMetaClasses
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getMetaClasses(adaptId, iapMetadata, callback) {
+    const meth = 'adapter-getMetaClasses';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = { adaptId };
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'getMetaClasses', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getMetaClasses'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getMetaParameters
+   * @pronghornType method
+   * @name getMetaParameters
+   * @summary Retrieve metadata for given Managed Objects classes
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getMetaParameters
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getMetaParameters(body, iapMetadata, callback) {
+    const meth = 'adapter-getMetaParameters';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'getMetaParameters', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getMetaParameters'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getMOLites
+   * @pronghornType method
+   * @name getMOLites
+   * @summary Retrieve Managed Objects by their DNs
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getMOLites
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getMOLites(body, iapMetadata, callback) {
+    const meth = 'adapter-getMOLites';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'getMOLites', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getMOLites'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function query
+   * @pronghornType method
+   * @name query
+   * @summary Retrieve expression values associated with given query
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /query
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  query(body, iapMetadata, callback) {
+    const meth = 'adapter-query';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'query', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['query'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function queryMOLites
+   * @pronghornType method
+   * @name queryMOLites
+   * @summary Retrieve Managed Objects for given search criteria
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /queryMOLites
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  queryMOLites(body, iapMetadata, callback) {
+    const meth = 'adapter-queryMOLites';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'queryMOLites', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['queryMOLites'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getRelatedMOLites
+   * @pronghornType method
+   * @name getRelatedMOLites
+   * @summary Retrieve related Managed Objects
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getRelatedMOLites
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getRelatedMOLites(body, iapMetadata, callback) {
+    const meth = 'adapter-getRelatedMOLites';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'getRelatedMOLites', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getRelatedMOLites'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getRootMOLites
+   * @pronghornType method
+   * @name getRootMOLites
+   * @summary Retrieve root Managed Objects
+   *
+   * @param {string} [confId] - confId param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getRootMOLites
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getRootMOLites(confId, iapMetadata, callback) {
+    const meth = 'adapter-getRootMOLites';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = { confId };
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Persistency', 'getRootMOLites', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getRootMOLites'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function readOperationAttributes
+   * @pronghornType method
+   * @name readOperationAttributes
+   * @summary Retrieve operations attributes
+   *
+   * @param {string} [operationIds] - operationIds param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /readOperationAttributes
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  readOperationAttributes(operationIds, iapMetadata, callback) {
+    const meth = 'adapter-readOperationAttributes';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = { operationIds };
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Operations', 'readOperationAttributes', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['readOperationAttributes'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function readOperationDefinitions
+   * @pronghornType method
+   * @name readOperationDefinitions
+   * @summary Retrieve workflow operation definitions
+   *
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {GET} /readOperationDefinitions
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  readOperationDefinitions(iapMetadata, callback) {
+    const meth = 'adapter-readOperationDefinitions';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Operations', 'readOperationDefinitions', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['readOperationDefinitions'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function readOperationExecutions
+   * @pronghornType method
+   * @name readOperationExecutions
+   * @summary Retrieve operation executions
+   *
+   * @param {string} [before] - before param
+   * @param {string} [after] - after param
+   * @param {string} [operationNames] - operationNames param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /readOperationExecutions
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  readOperationExecutions(before, after, operationNames, iapMetadata, callback) {
+    const meth = 'adapter-readOperationExecutions';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = { before, after, operationNames };
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Operations', 'readOperationExecutions', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['readOperationExecutions'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function readOperationFeedbacks
+   * @pronghornType method
+   * @name readOperationFeedbacks
+   * @summary Retrieve operation feedbacks
+   *
+   * @param {string} [operationIds] - operationIds param
+   * @param {string} [after] - after param
+   * @param {string} [limit] - limit param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /readOperationFeedbacks
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  readOperationFeedbacks(operationIds, after, limit, iapMetadata, callback) {
+    const meth = 'adapter-readOperationFeedbacks';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = { operationIds, after, limit };
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Operations', 'readOperationFeedbacks', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['readOperationFeedbacks'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function interruptOperation
+   * @pronghornType method
+   * @name interruptOperation
+   * @summary Interrupt an operation
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /interruptOperation
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  interruptOperation(body, iapMetadata, callback) {
+    const meth = 'adapter-interruptOperation';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Operations', 'interruptOperation', reqObj, false, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['interruptOperation'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function scheduleOperation
+   * @pronghornType method
+   * @name scheduleOperation
+   * @summary Schedule an operation
+   *
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {GET} /scheduleOperation
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  scheduleOperation(iapMetadata, callback) {
+    const meth = 'adapter-scheduleOperation';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Operations', 'scheduleOperation', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['scheduleOperation'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function startOperation
+   * @pronghornType method
+   * @name startOperation
+   * @summary Start an operation
+   *
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {GET} /startOperation
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  startOperation(iapMetadata, callback) {
+    const meth = 'adapter-startOperation';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Operations', 'startOperation', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['startOperation'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function readOperationStatuses
+   * @pronghornType method
+   * @name readOperationStatuses
+   * @summary Retrieve operation statuses
+   *
+   * @param {string} [operationIds] - operationIds param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /readOperationStatuses
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  readOperationStatuses(operationIds, iapMetadata, callback) {
+    const meth = 'adapter-readOperationStatuses';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = { operationIds };
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = {};
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('Operations', 'readOperationStatuses', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['readOperationStatuses'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getOpenCmManagedObjects
+   * @pronghornType method
+   * @name getOpenCmManagedObjects
+   * @summary getManagedObjects
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getOpenCmManagedObjects
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getOpenCmManagedObjects(body, iapMetadata, callback) {
+    const meth = 'adapter-getOpenCmManagedObjects';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'getOpenCmManagedObjects', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getOpenCmManagedObjects'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function createManagedObjects
+   * @pronghornType method
+   * @name createManagedObjects
+   * @summary createManagedObjects
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /createManagedObjects
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  createManagedObjects(body, iapMetadata, callback) {
+    const meth = 'adapter-createManagedObjects';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'createManagedObjects', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['createManagedObjects'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function updateOpenCmManagedObjects
+   * @pronghornType method
+   * @name updateOpenCmManagedObjects
+   * @summary updateManagedObjects
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /updateOpenCmManagedObjects
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  updateOpenCmManagedObjects(body, iapMetadata, callback) {
+    const meth = 'adapter-updateOpenCmManagedObjects';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'updateOpenCmManagedObjects', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['updateOpenCmManagedObjects'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function deleteManagedObjects
+   * @pronghornType method
+   * @name deleteManagedObjects
+   * @summary deleteManagedObjects
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /deleteManagedObjects
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  deleteManagedObjects(body, iapMetadata, callback) {
+    const meth = 'adapter-deleteManagedObjects';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'deleteManagedObjects', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['deleteManagedObjects'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getOpenCmMOLites
+   * @pronghornType method
+   * @name getOpenCmMOLites
+   * @summary getMOLites
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getOpenCmMOLites
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getOpenCmMOLites(body, iapMetadata, callback) {
+    const meth = 'adapter-getOpenCmMOLites';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'getOpenCmMOLites', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getOpenCmMOLites'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getOpenCmRelatedMOLites
+   * @pronghornType method
+   * @name getOpenCmRelatedMOLites
+   * @summary getRelatedMOLites
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getOpenCmRelatedMOLites
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getOpenCmRelatedMOLites(body, iapMetadata, callback) {
+    const meth = 'adapter-getOpenCmRelatedMOLites';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'getOpenCmRelatedMOLites', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getOpenCmRelatedMOLites'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function queryOpenCmMOLites
+   * @pronghornType method
+   * @name queryOpenCmMOLites
+   * @summary queryMOLites
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /queryOpenCmMOLites
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  queryOpenCmMOLites(body, iapMetadata, callback) {
+    const meth = 'adapter-queryOpenCmMOLites';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'queryOpenCmMOLites', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['queryOpenCmMOLites'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getPersistencyMetadata
+   * @pronghornType method
+   * @name getPersistencyMetadata
+   * @summary getPersistencyMetadata
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getPersistencyMetadata
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getPersistencyMetadata(body, iapMetadata, callback) {
+    const meth = 'adapter-getPersistencyMetadata';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'getPersistencyMetadata', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getPersistencyMetadata'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getOpenCmConfigurations
+   * @pronghornType method
+   * @name getOpenCmConfigurations
+   * @summary getConfigurations
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getOpenCmConfigurations
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getOpenCmConfigurations(body, iapMetadata, callback) {
+    const meth = 'adapter-getOpenCmConfigurations';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'getOpenCmConfigurations', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getOpenCmConfigurations'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function createOpenCmConfiguration
+   * @pronghornType method
+   * @name createOpenCmConfiguration
+   * @summary createConfiguration
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /createOpenCmConfiguration
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  createOpenCmConfiguration(body, iapMetadata, callback) {
+    const meth = 'adapter-createOpenCmConfiguration';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'createOpenCmConfiguration', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['createOpenCmConfiguration'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function postPersistencyOpenCmPersistencyServiceSOAPUpdateConfiguration
+   * @pronghornType method
+   * @name postPersistencyOpenCmPersistencyServiceSOAPUpdateConfiguration
+   * @summary updateConfiguration
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /postPersistencyOpenCmPersistencyServiceSOAPUpdateConfiguration
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  postPersistencyOpenCmPersistencyServiceSOAPUpdateConfiguration(body, iapMetadata, callback) {
+    const meth = 'adapter-postPersistencyOpenCmPersistencyServiceSOAPUpdateConfiguration';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'postPersistencyOpenCmPersistencyServiceSOAPUpdateConfiguration', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['postPersistencyOpenCmPersistencyServiceSOAPUpdateConfiguration'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function deleteOpenCmConfiguration
+   * @pronghornType method
+   * @name deleteOpenCmConfiguration
+   * @summary deleteConfiguration
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /deleteOpenCmConfiguration
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  deleteOpenCmConfiguration(body, iapMetadata, callback) {
+    const meth = 'adapter-deleteOpenCmConfiguration';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmPersistencyPortBinding', 'deleteOpenCmConfiguration', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['deleteOpenCmConfiguration'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function getOperationsMetadata
+   * @pronghornType method
+   * @name getOperationsMetadata
+   * @summary getOperationsMetadata
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /getOperationsMetadata
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  getOperationsMetadata(body, iapMetadata, callback) {
+    const meth = 'adapter-getOperationsMetadata';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmOperationsPortBinding', 'getOperationsMetadata', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getOperationsMetadata'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function startOpenCmOperation
+   * @pronghornType method
+   * @name startOpenCmOperation
+   * @summary startOperation
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /startOpenCmOperation
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  startOpenCmOperation(body, iapMetadata, callback) {
+    const meth = 'adapter-startOpenCmOperation';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmOperationsPortBinding', 'startOpenCmOperation', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['startOpenCmOperation'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @function interruptOperationOpenCm
+   * @pronghornType method
+   * @name interruptOperationOpenCm
+   * @summary interruptOperationOpenCm
+   *
+   * @param {object} body - body param
+   * @param {object} iapMetadata - IAP Metadata object contains additional info needed for the request: payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, etc.
+   * @param {getCallback} callback - a callback function to return the result
+   * @return {object} results - An object containing the response of the action
+   *
+   * @route {POST} /interruptOperationOpenCm
+   * @roles admin
+   * @task true
+   */
+  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
+  interruptOperationOpenCm(body, iapMetadata, callback) {
+    const meth = 'adapter-interruptOperationOpenCm';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (body === undefined || body === null || body === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['body'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
+    const queryParamsAvailable = {};
+    const queryParams = {};
+    const pathVars = [];
+    const bodyVars = body;
+
+    // loop in template. long callback arg name to avoid identifier conflicts
+    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
+      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
+          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
+        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
+      }
+    });
+
+    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders, authData, callProperties, filter, priority, event
+    // see adapter code documentation for more information on the request object's fields
+    const reqObj = {
+      payload: bodyVars,
+      uriPathVars: pathVars,
+      uriQuery: queryParams
+    };
+
+    const reqFields = ['payload', 'uriPathVars', 'uriQuery', 'uriOptions', 'addlHeaders', 'authData', 'callProperties', 'filter', 'priority', 'event'];
+
+    // Merge and add new iapMetadata fields in reqObj
+    if (iapMetadata && typeof iapMetadata === 'object') {
+      Object.keys(iapMetadata).forEach((iapField) => {
+        if (reqFields.includes(iapField) && iapMetadata[iapField]) {
+          if (typeof reqObj[iapField] === 'object' && typeof iapMetadata[iapField] === 'object') {
+            reqObj[iapField] = { ...reqObj[iapField], ...iapMetadata[iapField] }; // Merge objects
+          } else if (Array.isArray(reqObj[iapField]) && Array.isArray(iapMetadata[iapField])) {
+            reqObj[iapField] = reqObj[iapField].concat(iapMetadata[iapField]); // Merge arrays
+          } else {
+            // Otherwise, add new iapMetadata fields to reqObj
+            reqObj[iapField] = iapMetadata[iapField];
+          }
+        }
+      });
+      // Add iapMetadata to reqObj for further work
+      reqObj.iapMetadata = iapMetadata;
+    }
+
+    try {
+      // Make the call -
+      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      return this.requestHandlerInst.identifyRequest('OpenCmOperationsPortBinding', 'interruptOperationOpenCm', reqObj, true, (irReturnData, irReturnError) => {
+        // if we received an error or their is no response on the results
+        // return an error
+        if (irReturnError) {
+          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
+          return callback(null, irReturnError);
+        }
+        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['interruptOperationOpenCm'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
+        // return the response
+        return callback(irReturnData, null);
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+}
+
+module.exports = NokiaNetact;